SearchOper (Parallel Template Library (PTL)™ 4.0)

java.lang.Object
- Progeneric.Ptl.Algorithms.SearchOper

```
public final class SearchOper
extends java.lang.Object
```
Implements algorithms that return information about the elements in the range without changing the elements.

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> int`	`AdjacentFind(T[] x, int first, int last)` Searches for two adjacent elements that are equal.
`static <T> int`	`AdjacentFind(T[] x, int first, int last, IFunc2Arg<T,T,java.lang.Boolean> pred)` Searches for two adjacent elements that satisfy a specified condition.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`AdjacentFind(TInpIter first, long n)` Searches for two adjacent elements that are equal.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`AdjacentFind(TInpIter first, long n, IFunc2Arg<T,T,java.lang.Boolean> pred)` Searches for two adjacent elements that satisfy a specified condition.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`AdjacentFind(TInpIter first, TInpIter last)` Searches for two adjacent elements that are equal.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`AdjacentFind(TInpIter first, TInpIter last, IFunc2Arg<T,T,java.lang.Boolean> pred)` Searches for two adjacent elements that satisfy a specified condition.
`static <T extends java.lang.Comparable<T>> boolean`	`BinarySearch(T[] x, int first, int last, T value)` Tests whether there is an element in a sorted range that is equal to a specified value.
`static <T> boolean`	`BinarySearch(T[] x, int first, int last, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Tests whether there is an element in a sorted range that is equal to a specified value or that is equivalent to it in a sense specified by a binary predicate.
`static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> boolean`	`BinarySearch(TInpIter first, TInpIter last, T value)` Tests whether there is an element in a sorted range that is equal to a specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> boolean`	`BinarySearch(TInpIter first, TInpIter last, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Tests whether there is an element in a sorted range that is equal to a specified value or that is equivalent to it in a sense specified by a binary predicate.
`static <T extends java.lang.Comparable<T>> Tuple2<java.lang.Integer,java.lang.Integer>`	`EqualRange(T[] x, int first, int last, T value)` Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equal to the specified value.
`static <T> Tuple2<java.lang.Integer,java.lang.Integer>`	`EqualRange(T[] x, int first, int last, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equivalent with the specified value.
`static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> Tuple2<TInpIter,TInpIter>`	`EqualRange(TInpIter first, long n, T value)` Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equal to the specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> Tuple2<TInpIter,TInpIter>`	`EqualRange(TInpIter first, long n, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equivalent with the specified value.
`static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> Tuple2<TInpIter,TInpIter>`	`EqualRange(TInpIter first, TInpIter last, T value)` Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equal to the specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> Tuple2<TInpIter,TInpIter>`	`EqualRange(TInpIter first, TInpIter last, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equivalent with the specified value.
`static <T> int`	`Find(IStreamable<T>[] x, int first, int last, IPredicate<T> pred)` Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
`static <T> int`	`Find(IStreamable<T>[] x, int first, int last, T value)` Locates the position in a range of the first occurrence of an element that has a specified value.
`static <T> int`	`Find(T[] x, int first, int last, IPredicate<T> pred)` Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
`static <T> int`	`Find(T[] x, int first, int last, T value)` Locates the position in a range of the first occurrence of an element that has a specified value.
`static <T> int`	`Find(T[] x, int first1, int last1, T[] y, int first2, int last2)` Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2).
`static <T> int`	`Find(T[] x, int first1, int last1, T[] y, int first2, int last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Find(TInpIter first, long n, IPredicate<T> pred)` Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Find(TInpIter first, long n, T value)` Locates the position in a range of the first occurrence of an element that has a specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Find(TInpIter first1, long n, TInpIter first2, TInpIter last2)` Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2).
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Find(TInpIter first1, long n, TInpIter first2, TInpIter last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Find(TInpIter first, TInpIter last, IPredicate<T> pred)` Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Find(TInpIter first, TInpIter last, T value)` Locates the position in a range of the first occurrence of an element that has a specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Find(TInpIter first1, TInpIter last1, TInpIter first2, TInpIter last2)` Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2).
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Find(TInpIter first1, TInpIter last1, TInpIter first2, TInpIter last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
`static <T extends java.lang.Comparable<T>> int`	`LowerBound(T[] x, int first, int last, T value)` Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value.
`static <T> int`	`LowerBound(T[] x, int first, int last, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value, where the ordering criterion is specified by a binary predicate.
`static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`LowerBound(TInpIter first, long n, T value)` Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`LowerBound(TInpIter first, long n, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value, where the ordering criterion is specified by a binary predicate.
`static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`LowerBound(TInpIter first, TInpIter last, T value)` Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`LowerBound(TInpIter first, TInpIter last, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value, where the ordering criterion is specified by a binary predicate.
`static <T> int`	`PAdjacentFind(T[] x, int first, int last)` Parallel AdjacentFind: Searches for two adjacent elements that are equal.
`static <T> int`	`PAdjacentFind(T[] x, int first, int last, IFunc2Arg<T,T,java.lang.Boolean> pred)` Parallel AdjacentFind: Searches for two adjacent elements that satisfy a specified condition.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PAdjacentFind(TInpIter first, long n)` Parallel AdjacentFind: Searches for two adjacent elements that are equal.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PAdjacentFind(TInpIter first, long n, IFunc2Arg<T,T,java.lang.Boolean> pred)` Parallel AdjacentFind: Searches for two adjacent elements that satisfy a specified condition.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PAdjacentFind(TInpIter first, TInpIter last)` Parallel AdjacentFind: Searches for two adjacent elements that are equal.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PAdjacentFind(TInpIter first, TInpIter last, IFunc2Arg<T,T,java.lang.Boolean> pred)` Parallel AdjacentFind: Searches for two adjacent elements that satisfy a specified condition.
`static <T> int`	`PFind(T[] x, int first, int last, IPredicate<T> pred)` Parallel Find: Locates the position of any occurrence of an of an element that satisfies a specified condition.
`static <T> int`	`PFind(T[] x, int first, int last, T value)` Parallel Find: Locates the position any occurrence of an element in a range that has a specified value.
`static <T> int`	`PFind(T[] x, int first1, int last1, T[] y, int first2, int last2)` Parallel Find: Locates the position of any occurrence in the range [first1, last1) of any of the elements in [first2, last2).
`static <T> int`	`PFind(T[] x, int first1, int last1, T[] y, int first2, int last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Parallel Find: Locates the position of any occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PFind(TInpIter first, long n, IPredicate<T> pred)` Parallel Find: Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PFind(TInpIter first, long n, T value)` Parallel Find: Locates the position any element in a range that has a specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PFind(TInpIter first1, long n, TInpIter first2, TInpIter last2)` Parallel Find: Locates the position any occurrence in the range [first1, last1) of any of the elements in [first2, last2).
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PFind(TInpIter first1, long n, TInpIter first2, TInpIter last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Parallel Find: Locates the position of any occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PFind(TInpIter first, TInpIter last, IPredicate<T> pred)` Parallel Find: Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PFind(TInpIter first, TInpIter last, T value)` Parallel Find: Locates the position of any element in a range that has a specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PFind(TInpIter first1, TInpIter last1, TInpIter first2, TInpIter last2)` Parallel Find: Locates the position any occurrence in the range [first1, last1) of any of the elements in [first2, last2).
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PFind(TInpIter first1, TInpIter last1, TInpIter first2, TInpIter last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Parallel Find: Locates the position of any occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
`static <T> int`	`PSearch(T[] x, int first, int last, int count, IPredicate<T> pred)` Parallel Search: Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
`static <T> int`	`PSearch(T[] x, int first, int last, int count, T value)` Parallel Search: Searches in a range for the first subsequence of a specified number of elements that have a particular value.
`static <T> int`	`PSearch(T[] x, int first1, int last1, T[] y, int first2, int last2)` Parallel Search: Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
`static <T> int`	`PSearch(T[] x, int first1, int last1, T[] y, int first2, int last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Parallel Search: Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PSearch(TInpIter first, long n, int count, IPredicate<T> pred)` Parallel Search: Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PSearch(TInpIter first, long n, int count, T value)` Parallel Search: Searches in a range for the first subsequence of a specified number of elements that have a particular value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PSearch(TInpIter first1, long n, TInpIter first2, TInpIter last2)` Parallel Search: Searches for the first subsequence of [first1, first1 + n) that is equivalent to [first2, last2) when compared element by element.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PSearch(TInpIter first1, long n, TInpIter first2, TInpIter last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Parallel Search: Searches for the first subsequence of [first1, first1 + n) that is equivalent to [first2, last2) when compared element by element.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PSearch(TInpIter first, TInpIter last, int count, IPredicate<T> pred)` Parallel Search: Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PSearch(TInpIter first, TInpIter last, int count, T value)` Parallel Search: Searches in a range for the first subsequence of a specified number of elements that have a particular value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PSearch(TInpIter first1, TInpIter last1, TInpIter first2, TInpIter last2)` Parallel Search: Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`PSearch(TInpIter first1, TInpIter last1, TInpIter first2, TInpIter last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Parallel Search: Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
`static <T> int`	`Search(T[] x, int first, int last, int count, IPredicate<T> pred)` Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
`static <T> int`	`Search(T[] x, int first, int last, int count, T value)` Searches in a range for the first subsequence of a specified number of elements that have a particular value.
`static <T> int`	`Search(T[] x, int first1, int last1, T[] y, int first2, int last2)` Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
`static <T> int`	`Search(T[] x, int first1, int last1, T[] y, int first2, int last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Search(TInpIter first, long n, int count, IPredicate<T> pred)` Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Search(TInpIter first, long n, int count, T value)` Searches in a range for the first subsequence of a specified number of elements that have a particular value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Search(TInpIter first1, long n, TInpIter first2, TInpIter last2)` Searches for the first subsequence of [first1, first1 + n) that is equivalent to [first2, last2) when compared element by element.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Search(TInpIter first1, long n, TInpIter first2, TInpIter last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Searches for the first subsequence of [first1, first1 + n) that is equivalent to [first2, last2) when compared element by element.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Search(TInpIter first, TInpIter last, int count, IPredicate<T> pred)` Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Search(TInpIter first, TInpIter last, int count, T value)` Searches in a range for the first subsequence of a specified number of elements that have a particular value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Search(TInpIter first1, TInpIter last1, TInpIter first2, TInpIter last2)` Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`Search(TInpIter first1, TInpIter last1, TInpIter first2, TInpIter last2, IFunc2Arg<T,T,java.lang.Boolean> pred)` Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
`static <T extends java.lang.Comparable<T>> int`	`UpperBound(T[] x, int first, int last, T value)` Finds the position of the first element in an ordered range that has a value greater than a specified value.
`static <T> int`	`UpperBound(T[] x, int first, int last, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Finds the position of the first element in an ordered range that has a value greater than a specified value, where the ordering criterion may be specified by a binary predicate.
`static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`UpperBound(TInpIter first, long n, T value)` Finds the position of the first element in an ordered range that has a value greater than a specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`UpperBound(TInpIter first, long n, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Finds the position of the first element in an ordered range that has a value greater than a specified value, where the ordering criterion may be specified by a binary predicate.
`static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`UpperBound(TInpIter first, TInpIter last, T value)` Finds the position of the first element in an ordered range that has a value greater than a specified value.
`static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter`	`UpperBound(TInpIter first, TInpIter last, T value, IFunc2Arg<T,T,java.lang.Boolean> pred)` Finds the position of the first element in an ordered range that has a value greater than a specified value, where the ordering criterion may be specified by a binary predicate.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - Find
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Find(TInpIter first,
                                                      TInpIter last,
                                                      T value)
```
    Locates the position in a range of the first occurrence of an element that has a specified value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value to be searched for.
    
    Returns:
    An input iterator addressing the first occurrence of the specified value in the range being searched. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Find
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Find(TInpIter first,
                                                      long n,
                                                      T value)
```
    Locates the position in a range of the first occurrence of an element that has a specified value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    value - The value to be searched for.
    
    Returns:
    An input iterator addressing the first occurrence of the specified value in the range being searched. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PFind(TInpIter first,
                                                       TInpIter last,
                                                       T value)
```
    Parallel Find: Locates the position of any element in a range that has a specified value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value to be searched for.
    
    Returns:
    An input iterator addressing the first occurrence of the specified value in the range being searched. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PFind(TInpIter first,
                                                       long n,
                                                       T value)
```
    Parallel Find: Locates the position any element in a range that has a specified value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    value - The value to be searched for.
    
    Returns:
    An input iterator addressing the first occurrence of the specified value in the range being searched. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Find
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Find(TInpIter first,
                                                      TInpIter last,
                                                      IPredicate<T> pred)
```
    Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An input iterator addressing the first occurrence of an element that satisfies a specified condition in the range being searched. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Find
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Find(TInpIter first,
                                                      long n,
                                                      IPredicate<T> pred)
```
    Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An input iterator addressing the first occurrence of an element that satisfies a specified condition in the range being searched. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PFind(TInpIter first,
                                                       TInpIter last,
                                                       IPredicate<T> pred)
```
    Parallel Find: Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An input iterator addressing the first occurrence of an element that satisfies a specified condition in the range being searched. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PFind(TInpIter first,
                                                       long n,
                                                       IPredicate<T> pred)
```
    Parallel Find: Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An input iterator addressing the first occurrence of an element that satisfies a specified condition in the range being searched. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Find
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Find(TInpIter first1,
                                                      TInpIter last1,
                                                      TInpIter first2,
                                                      TInpIter last2)
```
    Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2).
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    last1 - An input iterator addressing the position one past the final element in the range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    
    Returns:
    An input iterator addressing the position of the first element in the first range that matches any of the elements in second range. If no such iterator exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - Find
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Find(TInpIter first1,
                                                      long n,
                                                      TInpIter first2,
                                                      TInpIter last2)
```
    Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2).
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    
    Returns:
    An input iterator addressing the position of the first element in the first range that matches any of the elements in second range. If no such iterator exists, the return value is (first1 + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PFind(TInpIter first1,
                                                       TInpIter last1,
                                                       TInpIter first2,
                                                       TInpIter last2)
```
    Parallel Find: Locates the position any occurrence in the range [first1, last1) of any of the elements in [first2, last2).
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    last1 - An input iterator addressing the position one past the final element in the range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    
    Returns:
    An input iterator addressing the position of the first element in the first range that matches any of the elements in second range. If no such iterator exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PFind(TInpIter first1,
                                                       long n,
                                                       TInpIter first2,
                                                       TInpIter last2)
```
    Parallel Find: Locates the position any occurrence in the range [first1, last1) of any of the elements in [first2, last2).
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    
    Returns:
    An input iterator addressing the position of the first element in the first range that matches any of the elements in second range. If no such iterator exists, the return value is (first1 + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - Find
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Find(TInpIter first1,
                                                      TInpIter last1,
                                                      TInpIter first2,
                                                      TInpIter last2,
                                                      IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    last1 - An input iterator addressing the position one past the final element in the range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An input iterator addressing the position of the first element in the first range that is equivalent in a sense specified by a binary predicate with any of the elements in second range. If no such iterator exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - Find
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Find(TInpIter first1,
                                                      long n,
                                                      TInpIter first2,
                                                      TInpIter last2,
                                                      IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An input iterator addressing the position of the first element in the first range that is equivalent in a sense specified by a binary predicate with any of the elements in second range. If no such iterator exists, the return value is (first1 + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PFind(TInpIter first1,
                                                       TInpIter last1,
                                                       TInpIter first2,
                                                       TInpIter last2,
                                                       IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Parallel Find: Locates the position of any occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    last1 - An input iterator addressing the position one past the final element in the range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An input iterator addressing the position of the first element in the first range that is equivalent in a sense specified by a binary predicate with any of the elements in second range. If no such iterator exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PFind(TInpIter first1,
                                                       long n,
                                                       TInpIter first2,
                                                       TInpIter last2,
                                                       IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Parallel Find: Locates the position of any occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An input iterator addressing the position of the first element in the first range that is equivalent in a sense specified by a binary predicate with any of the elements in second range. If no such iterator exists, the return value is (first1 + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - Find
```
public static <T> int Find(T[] x,
           int first,
           int last,
           T value)
```
    Locates the position in a range of the first occurrence of an element that has a specified value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value to be searched for.
    
    Returns:
    An integer addressing the first occurrence of the specified value in the range being searched. If no such position exists, the return value is last.
  - Find
```
public static <T> int Find(T[] x,
           int first,
           int last,
           IPredicate<T> pred)
```
    Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An integer addressing the first occurrence of an element that satisfies a specified condition in the range being searched. If no such position exists, the return value is last.
  - PFind
```
public static <T> int PFind(T[] x,
            int first,
            int last,
            T value)
```
    Parallel Find: Locates the position any occurrence of an element in a range that has a specified value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value to be searched for.
    
    Returns:
    An integer addressing the first occurrence of the specified value in the range being searched. If no such position exists, the return value is last.
  - PFind
```
public static <T> int PFind(T[] x,
            int first,
            int last,
            IPredicate<T> pred)
```
    Parallel Find: Locates the position of any occurrence of an of an element that satisfies a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An integer addressing the first occurrence of an element that satisfies a specified condition in the range being searched. If no such position exists, the return value is last.
  - Find
```
public static <T> int Find(T[] x,
           int first1,
           int last1,
           T[] y,
           int first2,
           int last2)
```
    Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2).
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    Parameters:
    x - The first specified array.
    first1 - An integer addressing the position of the first element in the range to be searched.
    last1 - An integer addressing the position one past the final element in the range to be searched.
    y - The second specified array.
    first2 - An integer addressing the position of the first element in the range to be matched.
    last2 - An integer addressing the position one past the final element in the range to be matched.
    
    Returns:
    An integer addressing the position of the first element in the first range that matches any of the elements in second range. If no such position exists, the return value is last1.
  - Find
```
public static <T> int Find(T[] x,
           int first1,
           int last1,
           T[] y,
           int first2,
           int last2,
           IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Locates the position of the first occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    Parameters:
    x - The first specified array.
    first1 - An integer addressing the position of the first element in the range to be searched.
    last1 - An integer addressing the position one past the final element in the range to be searched.
    y - The second specified array.
    first2 - An integer addressing the position of the first element in the range to be matched.
    last2 - An integer addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An integer addressing the position of the first element in the first range that is equivalent in a sense specified by a binary predicate with any of the elements in second range. If no such position exists, the return value is last1.
  - PFind
```
public static <T> int PFind(T[] x,
            int first1,
            int last1,
            T[] y,
            int first2,
            int last2)
```
    Parallel Find: Locates the position of any occurrence in the range [first1, last1) of any of the elements in [first2, last2).
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    Parameters:
    x - The first specified array.
    first1 - An integer addressing the position of the first element in the range to be searched.
    last1 - An integer addressing the position one past the final element in the range to be searched.
    y - The second specified array.
    first2 - An integer addressing the position of the first element in the range to be matched.
    last2 - An integer addressing the position one past the final element in the range to be matched.
    
    Returns:
    An integer addressing the position of the first element in the first range that matches any of the elements in second range. If no such position exists, the return value is last1.
  - PFind
```
public static <T> int PFind(T[] x,
            int first1,
            int last1,
            T[] y,
            int first2,
            int last2,
            IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Parallel Find: Locates the position of any occurrence in the range [first1, last1) of any of the elements in [first2, last2), where the equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    Parameters:
    x - The first specified array.
    first1 - An integer addressing the position of the first element in the range to be searched.
    last1 - An integer addressing the position one past the final element in the range to be searched.
    y - The second specified array.
    first2 - An integer addressing the position of the first element in the range to be matched.
    last2 - An integer addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An integer addressing the position of the first element in the first range that is equivalent in a sense specified by a binary predicate with any of the elements in second range. If no such position exists, the return value is last1.
  - Find
```
public static <T> int Find(IStreamable<T>[] x,
           int first,
           int last,
           T value)
```
    Locates the position in a range of the first occurrence of an element that has a specified value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value to be searched for.
    
    Returns:
    An integer addressing the first occurrence of the specified value in the range being searched. If no such position exists, the return value is last.
  - Find
```
public static <T> int Find(IStreamable<T>[] x,
           int first,
           int last,
           IPredicate<T> pred)
```
    Locates the position in a range of the first occurrence of an element that satisfies a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    pred - A user-defined predicate function that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An integer addressing the first occurrence of an element that satisfies a specified condition in the range being searched. If no such position exists, the return value is last.
  - AdjacentFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter AdjacentFind(TInpIter first,
                                                              TInpIter last)
```
    Searches for two adjacent elements that are equal.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    
    Returns:
    Returns the first iterator i such that i and i + 1 are both valid iterators in the range [first, last) and i.Current == (i + 1).Current. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - AdjacentFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter AdjacentFind(TInpIter first,
                                                              long n)
```
    Searches for two adjacent elements that are equal.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    
    Returns:
    Returns the first iterator i such that i and i + 1 are both valid iterators in the range [first, first + n) and i.Current == (i + 1).Current. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PAdjacentFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PAdjacentFind(TInpIter first,
                                                               TInpIter last)
```
    Parallel AdjacentFind: Searches for two adjacent elements that are equal.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    
    Returns:
    Returns any iterator i such that i and i + 1 are both valid iterators in the range [first, last) and i.Current == (i + 1).Current. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PAdjacentFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PAdjacentFind(TInpIter first,
                                                               long n)
```
    Parallel AdjacentFind: Searches for two adjacent elements that are equal.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    
    Returns:
    Returns any iterator i such that i and i + 1 are both valid iterators in the range [first, first + n) and i.Current == (i + 1).Current. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - AdjacentFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter AdjacentFind(TInpIter first,
                                                              TInpIter last,
                                                              IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Searches for two adjacent elements that satisfy a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    pred - The binary predicate giving the condition to be satisfied by the values of the adjacent elements in the range being searched.
    
    Returns:
    Returns the first iterator i such that i and i + 1 are both valid iterators in the range [first, last) and pred(i.Current, (i + 1).Current) is true. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - AdjacentFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter AdjacentFind(TInpIter first,
                                                              long n,
                                                              IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Searches for two adjacent elements that satisfy a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    pred - The binary predicate giving the condition to be satisfied by the values of the adjacent elements in the range being searched.
    
    Returns:
    Returns the first iterator i such that i and i + 1 are both valid iterators in the range [first, first + n) and pred(i.Current, (i + 1).Current) is true. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PAdjacentFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PAdjacentFind(TInpIter first,
                                                               TInpIter last,
                                                               IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Parallel AdjacentFind: Searches for two adjacent elements that satisfy a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    pred - The binary predicate giving the condition to be satisfied by the values of the adjacent elements in the range being searched.
    
    Returns:
    Returns any iterator i such that i and i + 1 are both valid iterators in the range [first, last) and pred(i.Current, (i + 1).Current) is true. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PAdjacentFind
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PAdjacentFind(TInpIter first,
                                                               long n,
                                                               IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Parallel AdjacentFind: Searches for two adjacent elements that satisfy a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    pred - The binary predicate giving the condition to be satisfied by the values of the adjacent elements in the range being searched.
    
    Returns:
    Returns any iterator i such that i and i + 1 are both valid iterators in the range [first, first + n) and pred(i.Current, (i + 1).Current) is true. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - AdjacentFind
```
public static <T> int AdjacentFind(T[] x,
                   int first,
                   int last)
```
    Searches for two adjacent elements that are equal.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    
    Returns:
    Returns the first position i such that i and i + 1 are both valid iterators in the range [first, last) and i.Current == (i + 1).Current. If no such position exists, the return value is last.
  - AdjacentFind
```
public static <T> int AdjacentFind(T[] x,
                   int first,
                   int last,
                   IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Searches for two adjacent elements that satisfy a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    pred - The binary predicate giving the condition to be satisfied by the values of the adjacent elements in the range being searched.
    
    Returns:
    Returns the first position i such that i and i + 1 are both valid iterators in the range [first, last) and pred(i.Current, (i + 1).Current) is true. If no such position exists, the return value is last.
  - PAdjacentFind
```
public static <T> int PAdjacentFind(T[] x,
                    int first,
                    int last)
```
    Parallel AdjacentFind: Searches for two adjacent elements that are equal.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    
    Returns:
    Returns any position i such that i and i + 1 are both valid iterators in the range [first, last) and i.Current == (i + 1).Current. If no such position exists, the return value is last.
  - PAdjacentFind
```
public static <T> int PAdjacentFind(T[] x,
                    int first,
                    int last,
                    IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Parallel AdjacentFind: Searches for two adjacent elements that satisfy a specified condition.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    pred - The binary predicate giving the condition to be satisfied by the values of the adjacent elements in the range being searched.
    
    Returns:
    Returns any position i such that i and i + 1 are both valid iterators in the range [first, last) and pred(i.Current, (i + 1).Current) is true. If no such position exists, the return value is last.
  - Search
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Search(TInpIter first,
                                                        TInpIter last,
                                                        int count,
                                                        T value)
```
    Searches in a range for the first subsequence of a specified number of elements that have a particular value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    count - The size of the subsequence being searched for.
    value - The value of the elements in the sequence being searched for.
    
    Returns:
    An input iterator addressing the position of the first element of the first subsequence that matches the specified value. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Search
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Search(TInpIter first,
                                                        long n,
                                                        int count,
                                                        T value)
```
    Searches in a range for the first subsequence of a specified number of elements that have a particular value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    count - The size of the subsequence being searched for.
    value - The value of the elements in the sequence being searched for.
    
    Returns:
    An input iterator addressing the position of the first element of the first subsequence that matches the specified value. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PSearch
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PSearch(TInpIter first,
                                                         TInpIter last,
                                                         int count,
                                                         T value)
```
    Parallel Search: Searches in a range for the first subsequence of a specified number of elements that have a particular value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    count - The size of the subsequence being searched for.
    value - The value of the elements in the sequence being searched for.
    
    Returns:
    An input iterator addressing the position of the first element of any subsequence that matches the specified value. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PSearch
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PSearch(TInpIter first,
                                                         long n,
                                                         int count,
                                                         T value)
```
    Parallel Search: Searches in a range for the first subsequence of a specified number of elements that have a particular value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    count - The size of the subsequence being searched for.
    value - The value of the elements in the sequence being searched for.
    
    Returns:
    An input iterator addressing the position of the first element of any subsequence that matches the specified value. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Search
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Search(TInpIter first,
                                                        TInpIter last,
                                                        int count,
                                                        IPredicate<T> pred)
```
    Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    count - The size of the subsequence being searched for.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An input iterator addressing the position of the first element of the first subsequence that matches the specified binary predicate. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Search
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Search(TInpIter first,
                                                        long n,
                                                        int count,
                                                        IPredicate<T> pred)
```
    Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    count - The size of the subsequence being searched for.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An input iterator addressing the position of the first element of the first subsequence that matches the specified binary predicate. If no such iterator exists, the return value is (first + n).
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PSearch
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PSearch(TInpIter first,
                                                         TInpIter last,
                                                         int count,
                                                         IPredicate<T> pred)
```
    Parallel Search: Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    count - The size of the subsequence being searched for.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An input iterator addressing the position of the first element of any subsequence that matches the specified binary predicate. If no such iterator exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PSearch
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PSearch(TInpIter first,
                                                         long n,
                                                         int count,
                                                         IPredicate<T> pred)
```
    Parallel Search: Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    count - The size of the subsequence being searched for.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An input iterator addressing the position of the first element of any subsequence that matches the specified binary predicate. If no such iterator exists, the return value is (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Search
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Search(TInpIter first1,
                                                        TInpIter last1,
                                                        TInpIter first2,
                                                        TInpIter last2)
```
    Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    last1 - An input iterator addressing the position one past the final element in the range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    
    Returns:
    An input iterator addressing the position of the first element of the first subsequence that matches the specified sequence. If no such iterator exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - Search
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Search(TInpIter first1,
                                                        long n,
                                                        TInpIter first2,
                                                        TInpIter last2)
```
    Searches for the first subsequence of [first1, first1 + n) that is equivalent to [first2, last2) when compared element by element.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    
    Returns:
    An input iterator addressing the position of the first element of the first subsequence that matches the specified sequence. If no such iterator exists, the return value is (first1 + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PSearch
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PSearch(TInpIter first1,
                                                         TInpIter last1,
                                                         TInpIter first2,
                                                         TInpIter last2)
```
    Parallel Search: Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    last1 - An input iterator addressing the position one past the final element in the range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    
    Returns:
    An input iterator addressing the position of the first element of any subsequence that matches the specified sequence. If no such iterator exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PSearch
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PSearch(TInpIter first1,
                                                         long n,
                                                         TInpIter first2,
                                                         TInpIter last2)
```
    Parallel Search: Searches for the first subsequence of [first1, first1 + n) that is equivalent to [first2, last2) when compared element by element.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    
    Returns:
    An input iterator addressing the position of the first element of any subsequence that matches the specified sequence. If no such iterator exists, the return value is (first1 + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - Search
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Search(TInpIter first1,
                                                        TInpIter last1,
                                                        TInpIter first2,
                                                        TInpIter last2,
                                                        IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element. The equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    last1 - An input iterator addressing the position one past the final element in the range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An input iterator addressing the position of the first element of the first subsequence that is equivalent in a sense specified by a binary predicate. If no such iterator exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - Search
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter Search(TInpIter first1,
                                                        long n,
                                                        TInpIter first2,
                                                        TInpIter last2,
                                                        IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Searches for the first subsequence of [first1, first1 + n) that is equivalent to [first2, last2) when compared element by element. The equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An input iterator addressing the position of the first element of the first subsequence that is equivalent in a sense specified by a binary predicate. If no such iterator exists, the return value is (first1 + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PSearch
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PSearch(TInpIter first1,
                                                         TInpIter last1,
                                                         TInpIter first2,
                                                         TInpIter last2,
                                                         IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Parallel Search: Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element. The equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    last1 - An input iterator addressing the position one past the final element in the range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An input iterator addressing the position of the first element of any subsequence that is equivalent in a sense specified by a binary predicate. If no such iterator exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PSearch
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter PSearch(TInpIter first1,
                                                         long n,
                                                         TInpIter first2,
                                                         TInpIter last2,
                                                         IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Parallel Search: Searches for the first subsequence of [first1, first1 + n) that is equivalent to [first2, last2) when compared element by element. The equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    TInpIter - The type of iterators in the specified ranges.
    Parameters:
    first1 - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    first2 - An input iterator addressing the position of the first element in the range to be matched.
    last2 - An input iterator addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An input iterator addressing the position of the first element of any subsequence that is equivalent in a sense specified by a binary predicate. If no such iterator exists, the return value is (first1 + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - Search
```
public static <T> int Search(T[] x,
             int first,
             int last,
             int count,
             T value)
```
    Searches in a range for the first subsequence of a specified number of elements that have a particular value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    count - The size of the subsequence being searched for.
    value - The value of the elements in the sequence being searched for.
    
    Returns:
    An integer addressing the position of the first element of the first subsequence that matches the specified value. If no such position exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Search
```
public static <T> int Search(T[] x,
             int first,
             int last,
             int count,
             IPredicate<T> pred)
```
    Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    count - The size of the subsequence being searched for.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An integer addressing the position of the first element of the first subsequence that matches the specified binary predicate. If no such position exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PSearch
```
public static <T> int PSearch(T[] x,
              int first,
              int last,
              int count,
              T value)
```
    Parallel Search: Searches in a range for the first subsequence of a specified number of elements that have a particular value.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    count - The size of the subsequence being searched for.
    value - The value of the elements in the sequence being searched for.
    
    Returns:
    An integer addressing the position of the first element of any subsequence that matches the specified value. If no such position exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - PSearch
```
public static <T> int PSearch(T[] x,
              int first,
              int last,
              int count,
              IPredicate<T> pred)
```
    Parallel Search: Searches in a range for the first subsequence of a specified number of elements that satisfy a predicate.
    Remarks: The range to be searched must be valid. The complexity is linear with the size of the range.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    count - The size of the subsequence being searched for.
    pred - A user-defined predicate function object that defines the condition to be satisfied by the element being searched for.
    
    Returns:
    An integer addressing the position of the first element of any subsequence that matches the specified binary predicate. If no such position exists, the return value is last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - Search
```
public static <T> int Search(T[] x,
             int first1,
             int last1,
             T[] y,
             int first2,
             int last2)
```
    Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    Parameters:
    x - The specified first array.
    first1 - An integer addressing the position of the first element in the range to be searched.
    last1 - An integer addressing the position one past the final element in the range to be searched.
    y - The specified second array.
    first2 - An integer addressing the position of the first element in the range to be matched.
    last2 - An integer addressing the position one past the final element in the range to be matched.
    
    Returns:
    An integer addressing the position of the first element of the first subsequence that matches the specified sequence. If no such position exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - Search
```
public static <T> int Search(T[] x,
             int first1,
             int last1,
             T[] y,
             int first2,
             int last2,
             IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element. The equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    Parameters:
    x - The specified first array.
    first1 - An integer addressing the position of the first element in the range to be searched.
    last1 - An integer addressing the position one past the final element in the range to be searched.
    y - The specified second array.
    first2 - An integer addressing the position of the first element in the range to be matched.
    last2 - An integer addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An integer addressing the position of the first element of the first subsequence that is equivalent in a sense specified by a binary predicate. If no such position exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PSearch
```
public static <T> int PSearch(T[] x,
              int first1,
              int last1,
              T[] y,
              int first2,
              int last2)
```
    Parallel Search: Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    Parameters:
    x - The specified first array.
    first1 - An integer addressing the position of the first element in the range to be searched.
    last1 - An integer addressing the position one past the final element in the range to be searched.
    y - The specified second array.
    first2 - An integer addressing the position of the first element in the range to be matched.
    last2 - An integer addressing the position one past the final element in the range to be matched.
    
    Returns:
    An integer addressing the position of the first element of any subsequence that matches the specified sequence. If no such position exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - PSearch
```
public static <T> int PSearch(T[] x,
              int first1,
              int last1,
              T[] y,
              int first2,
              int last2,
              IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Parallel Search: Searches for the first subsequence of [first1, last1) that is equivalent to [first2, last2) when compared element by element. The equivalence of the elements is specified by a binary predicate.
    Remarks: The ranges referenced must be valid. The complexity is linear with the size of each range.
    
    Type Parameters:
    T - The type of elements in the specified ranges.
    Parameters:
    x - The specified first array.
    first1 - An integer addressing the position of the first element in the range to be searched.
    last1 - An integer addressing the position one past the final element in the range to be searched.
    y - The specified second array.
    first2 - An integer addressing the position of the first element in the range to be matched.
    last2 - An integer addressing the position one past the final element in the range to be matched.
    pred - A user-defined predicate function object that defines the condition to be satisfied if two elements are to be taken as equivalent.
    
    Returns:
    An integer addressing the position of the first element of any subsequence that is equivalent in a sense specified by a binary predicate. If no such position exists, the return value is last1.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when any of the specified ranges is invalid.
  - LowerBound
```
public static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> TInpIter LowerBound(TInpIter first,
                                                                                            TInpIter last,
                                                                                            T value)
```
    Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value that is searched for in the ordered range.
    
    Returns:
    An input iterator addressing the position of the first element in an ordered range that has a value greater than or equal to a specified value. If the value is greater than any of the elements in [first, last), it returns last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - LowerBound
```
public static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> TInpIter LowerBound(TInpIter first,
                                                                                            long n,
                                                                                            T value)
```
    Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    value - The value that is searched for in the ordered range.
    
    Returns:
    An input iterator addressing the position of the first element in an ordered range that has a value greater than or equal to a specified value. If the value is greater than any of the elements in [first, first + n), it returns (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - LowerBound
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter LowerBound(TInpIter first,
                                                            TInpIter last,
                                                            T value,
                                                            IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value, where the ordering criterion is specified by a binary predicate.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value that is searched for in the ordered range.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    An input iterator addressing the position of the first element in an ordered range that has a value greater than or equal to a specified value. If the value is greater than any of the elements in [first, last), it returns last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - LowerBound
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter LowerBound(TInpIter first,
                                                            long n,
                                                            T value,
                                                            IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value, where the ordering criterion is specified by a binary predicate.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    value - The value that is searched for in the ordered range.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    An input iterator addressing the position of the first element in an ordered range that has a value greater than or equal to a specified value. If the value is greater than any of the elements in [first, first + n), it returns (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - LowerBound
```
public static <T extends java.lang.Comparable<T>> int LowerBound(T[] x,
                                                 int first,
                                                 int last,
                                                 T value)
```
    Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value that is searched for in the ordered range.
    
    Returns:
    An integer addressing the position of the first element in an ordered range that has a value greater than or equal to a specified value. If the value is greater than any of the elements in [first, last), it returns last.
  - LowerBound
```
public static <T> int LowerBound(T[] x,
                 int first,
                 int last,
                 T value,
                 IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Finds the position of the first element in an ordered range that has a value greater than or equal to a specified value, where the ordering criterion is specified by a binary predicate.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value that is searched for in the ordered range.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    An integer addressing the position of the first element in an ordered range that has a value greater than or equal to a specified value. If the value is greater than any of the elements in [first, last), it returns last.
  - UpperBound
```
public static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> TInpIter UpperBound(TInpIter first,
                                                                                            TInpIter last,
                                                                                            T value)
```
    Finds the position of the first element in an ordered range that has a value greater than a specified value.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value that is searched for in the ordered range.
    
    Returns:
    An input iterator addressing the position of the first element in an ordered range that has a value greater than a specified value. If the value is greater than any of the elements in [first, last), it returns last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - UpperBound
```
public static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> TInpIter UpperBound(TInpIter first,
                                                                                            long n,
                                                                                            T value)
```
    Finds the position of the first element in an ordered range that has a value greater than a specified value.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    value - The value that is searched for in the ordered range.
    
    Returns:
    An input iterator addressing the position of the first element in an ordered range that has a value greater than a specified value. If the value is greater than any of the elements in [first, first + n), it returns (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - UpperBound
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter UpperBound(TInpIter first,
                                                            TInpIter last,
                                                            T value,
                                                            IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Finds the position of the first element in an ordered range that has a value greater than a specified value, where the ordering criterion may be specified by a binary predicate.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value that is searched for in the ordered range.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    An input iterator addressing the position of the first element in an ordered range that has a value greater than a specified value, where the ordering criterion may be specified by a binary predicate. If the value is greater than any of the elements in [first, last), it returns last.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - UpperBound
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> TInpIter UpperBound(TInpIter first,
                                                            long n,
                                                            T value,
                                                            IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Finds the position of the first element in an ordered range that has a value greater than a specified value, where the ordering criterion may be specified by a binary predicate.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    value - The value that is searched for in the ordered range.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    An input iterator addressing the position of the first element in an ordered range that has a value greater than a specified value, where the ordering criterion may be specified by a binary predicate. If the value is greater than any of the elements in [first, first + n), it returns (first + n).
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - UpperBound
```
public static <T extends java.lang.Comparable<T>> int UpperBound(T[] x,
                                                 int first,
                                                 int last,
                                                 T value)
```
    Finds the position of the first element in an ordered range that has a value greater than a specified value.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value that is searched for in the ordered range.
    
    Returns:
    An integer addressing the position of the first element in an ordered range that has a value greater than a specified value. If the value is greater than any of the elements in [first, last), it returns last.
  - UpperBound
```
public static <T> int UpperBound(T[] x,
                 int first,
                 int last,
                 T value,
                 IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Finds the position of the first element in an ordered range that has a value greater than a specified value, where the ordering criterion may be specified by a binary predicate.
    Remarks: The sorted source range referenced must be valid. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value that is searched for in the ordered range.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    An integer addressing the position of the first element in an ordered range that has a value greater than a specified value, where the ordering criterion may be specified by a binary predicate. If the value is greater than any of the elements in [first, last), it returns last.
  - BinarySearch
```
public static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> boolean BinarySearch(TInpIter first,
                                                                                             TInpIter last,
                                                                                             T value)
```
    Tests whether there is an element in a sorted range that is equal to a specified value.
    Remarks: The range to be searched must be valid and sorted. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value required to be matched by the value of the element.
    
    Returns:
    True if an element is found in the range that is equal to the specified value; otherwise, false.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - BinarySearch
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean BinarySearch(TInpIter first,
                                                             TInpIter last,
                                                             T value,
                                                             IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Tests whether there is an element in a sorted range that is equal to a specified value or that is equivalent to it in a sense specified by a binary predicate.
    Remarks: The range to be searched must be valid and sorted. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value required to be matched by the value of the element, where the equivalence of the elements is specified by the binary predicate.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    True if an element is found in the range that is equivalent to the specified value; otherwise, false.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - BinarySearch
```
public static <T extends java.lang.Comparable<T>> boolean BinarySearch(T[] x,
                                                       int first,
                                                       int last,
                                                       T value)
```
    Tests whether there is an element in a sorted range that is equal to a specified value.
    Remarks: The range to be searched must be valid and sorted. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value required to be matched by the value of the element.
    
    Returns:
    True if an element is found in the range that is equal to the specified value; otherwise, false.
  - BinarySearch
```
public static <T> boolean BinarySearch(T[] x,
                       int first,
                       int last,
                       T value,
                       IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Tests whether there is an element in a sorted range that is equal to a specified value or that is equivalent to it in a sense specified by a binary predicate.
    Remarks: The range to be searched must be valid and sorted. The complexity of the algorithm is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value required to be matched by the value of the element, where the equivalence of the elements is specified by the binary predicate.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    True if an element is found in the range that is equivalent to the specified value; otherwise, false.
  - EqualRange
```
public static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> Tuple2<TInpIter,TInpIter> EqualRange(TInpIter first,
                                                                                                             TInpIter last,
                                                                                                             T value)
```
    Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equal to the specified value.
    Remarks: The sorted source range referenced must be valid. The complexity is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value to be searched for in the ordered range.
    
    Returns:
    A pair of input iterators that specify a subrange contained within the range searched in which all of the elements are equal to the specified value. It is essentially a combination of the values returned by LowerBound and UpperBound.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - EqualRange
```
public static <T extends java.lang.Comparable<T>,TInpIter extends IInpIter<T,TInpIter>> Tuple2<TInpIter,TInpIter> EqualRange(TInpIter first,
                                                                                                             long n,
                                                                                                             T value)
```
    Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equal to the specified value.
    Remarks: The sorted source range referenced must be valid. The complexity is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    value - The value to be searched for in the ordered range.
    
    Returns:
    A pair of input iterators that specify a subrange contained within the range searched in which all of the elements are equal to the specified value. It is essentially a combination of the values returned by LowerBound and UpperBound.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - EqualRange
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> Tuple2<TInpIter,TInpIter> EqualRange(TInpIter first,
                                                                             TInpIter last,
                                                                             T value,
                                                                             IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equivalent with the specified value. The sense of equivalence or ordering is specified by a binary predicate.
    Remarks: The sorted source range referenced must be valid. The complexity is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    last - An input iterator addressing the position one past the final element in the range to be searched.
    value - The value to be searched for in the ordered range.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    A pair of input iterators that specify a subrange contained within the range searched in which all of the elements are equivalent to the specified value. It is essentially a combination of the values returned by LowerBound and UpperBound.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - EqualRange
```
public static <T,TInpIter extends IInpIter<T,TInpIter>> Tuple2<TInpIter,TInpIter> EqualRange(TInpIter first,
                                                                             long n,
                                                                             T value,
                                                                             IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equivalent with the specified value. The sense of equivalence or ordering is specified by a binary predicate.
    Remarks: The sorted source range referenced must be valid. The complexity is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    TInpIter - The type of iterators in the specified range.
    Parameters:
    first - An input iterator addressing the position of the first element in the range to be searched.
    n - The number of elements in the specified range to be searched.
    value - The value to be searched for in the ordered range.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    A pair of input iterators that specify a subrange contained within the range searched in which all of the elements are equivalent to the specified value. It is essentially a combination of the values returned by LowerBound and UpperBound.
    
    Throws:
    
    java.lang.RuntimeException - Thrown when the specified range is invalid.
  - EqualRange
```
public static <T extends java.lang.Comparable<T>> Tuple2<java.lang.Integer,java.lang.Integer> EqualRange(T[] x,
                                                                                         int first,
                                                                                         int last,
                                                                                         T value)
```
    Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equal to the specified value.
    Remarks: The sorted source range referenced must be valid. The complexity is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value to be searched for in the ordered range.
    
    Returns:
    A pair of input iterators that specify a subrange contained within the range searched in which all of the elements are equal to the specified value. It is essentially a combination of the values returned by LowerBound and UpperBound.
  - EqualRange
```
public static <T> Tuple2<java.lang.Integer,java.lang.Integer> EqualRange(T[] x,
                                                         int first,
                                                         int last,
                                                         T value,
                                                         IFunc2Arg<T,T,java.lang.Boolean> pred)
```
    Finds a pair of input iterators that specify a subrange contained within a sorted range in which all of the elements are equivalent with the specified value. The sense of equivalence or ordering is specified by a binary predicate.
    Remarks: The sorted source range referenced must be valid. The complexity is logarithmic for random-access iterators and linear otherwise.
    
    Type Parameters:
    T - The type of elements in the specified range.
    Parameters:
    x - The specified array.
    first - An integer addressing the position of the first element in the range to be searched.
    last - An integer addressing the position one past the final element in the range to be searched.
    value - The value to be searched for in the ordered range.
    pred - A user-defined predicate function object that defines the sense in which one element is less than another.
    
    Returns:
    A pair of input iterators that specify a subrange contained within the range searched in which all of the elements are equivalent to the specified value. It is essentially a combination of the values returned by LowerBound and UpperBound.

Class SearchOper

Method Summary

Methods inherited from class java.lang.Object

Method Detail

Find

Find

PFind

PFind

Find

Find

PFind

PFind

Find

Find

PFind

PFind

Find

Find

PFind

PFind

Find

Find

PFind

PFind

Find

Find

PFind

PFind

Find

Find

AdjacentFind

AdjacentFind

PAdjacentFind

PAdjacentFind

AdjacentFind

AdjacentFind

PAdjacentFind

PAdjacentFind

AdjacentFind

AdjacentFind

PAdjacentFind

PAdjacentFind

Search

Search

PSearch

PSearch

Search

Search

PSearch

PSearch

Search

Search

PSearch

PSearch

Search

Search

PSearch

PSearch

Search

Search

PSearch

PSearch

Search

Search

PSearch

PSearch

LowerBound

LowerBound

LowerBound

LowerBound

LowerBound

LowerBound

UpperBound

UpperBound

UpperBound

UpperBound

UpperBound

UpperBound

BinarySearch

BinarySearch