Progeneric.Ptl.Algorithms

Class TestOper

java.lang.Object

Progeneric.Ptl.Algorithms.TestOper

public final class TestOper
extends java.lang.Object

Implements algorithms that test ranges of iterators.

Method Summary

Methods

Modifier and Type	Method and Description
static <T> boolean	Any(T[] x, int first, int last, IPredicate<T> pred) Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T> boolean	Any(T[] x, int first, int last, T value) Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Any(TInpIter first, long n, IPredicate<T> pred) Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Any(TInpIter first, long n, T value) Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Any(TInpIter first, TInpIter last, IPredicate<T> pred) Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Any(TInpIter first, TInpIter last, T value) Compares a range element by element for equality with a specified value.
static <T> boolean	Equal(T[] x, int first, int last, IFunc0Arg<T> func) Compares a range element by element for equality with the result of a specified function object generator.
static <T> boolean	Equal(T[] x, int first, int last, IFunc1Arg<java.lang.Integer,T> func) Compares a range element by element for equality with the result of a specified function generator.
static <T> boolean	Equal(T[] x, int first, int last, IPredicate<T> pred) Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T> boolean	Equal(T[] x, int first, int last, T value) Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Equal(TInpIter first, long n, IFunc0Arg<T> func) Compares a range element by element for equality with the result of a specified function object generator.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Equal(TInpIter first, long n, IPredicate<T> pred) Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Equal(TInpIter first, long n, T value) Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Equal(TInpIter first, TInpIter last, IFunc0Arg<T> func) Compares a range element by element for equality with the result of a specified function object generator.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Equal(TInpIter first, TInpIter last, IPredicate<T> pred) Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	Equal(TInpIter first, TInpIter last, T value) Compares a range element by element for equality with a specified value.
static <T> boolean	None(T[] x, int first, int last, IPredicate<T> pred) Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T> boolean	None(T[] x, int first, int last, T value) Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	None(TInpIter first, long n, IPredicate<T> pred) Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	None(TInpIter first, long n, T value) Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	None(TInpIter first, TInpIter last, IPredicate<T> pred) Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	None(TInpIter first, TInpIter last, T value) Compares a range element by element for equality with a specified value.
static <T> boolean	PAny(T[] x, int first, int last, IPredicate<T> pred) Parallel Any: Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T> boolean	PAny(T[] x, int first, int last, T value) Parallel Any: Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PAny(TInpIter first, long n, IPredicate<T> pred) Parallel Any: Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PAny(TInpIter first, long n, T value) Parallel Any: Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PAny(TInpIter first, TInpIter last, IPredicate<T> pred) Parallel Any: Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PAny(TInpIter first, TInpIter last, T value) Parallel Any: Compares a range element by element for equality with a specified value.
static <T> boolean	PEqual(T[] x, int first, int last, IFunc1Arg<java.lang.Integer,T> func) Parallel Equal: Compares a range element by element for equality with the result of a specified function generator.
static <T> boolean	PEqual(T[] x, int first, int last, IPredicate<T> pred) Parallel Equal: Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T> boolean	PEqual(T[] x, int first, int last, T value) Parallel Equal: Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PEqual(TInpIter first, long n, IFunc1Arg<java.lang.Long,T> func) Parallel Equal: Compares a range element by element for equality with the result of a specified function object generator.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PEqual(TInpIter first, long n, IPredicate<T> pred) Parallel Equal: Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PEqual(TInpIter first, long n, T value) Parallel Equal: Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PEqual(TInpIter first, TInpIter last, IFunc1Arg<java.lang.Long,T> func) Parallel Equal: Compares a range element by element for equality with the result of a specified function object generator.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PEqual(TInpIter first, TInpIter last, IPredicate<T> pred) Parallel Equal: Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PEqual(TInpIter first, TInpIter last, T value) Parallel Equal: Compares a range element by element for equality with a specified value.
static <T> boolean	PNone(T[] x, int first, int last, IPredicate<T> pred) Parallel None: Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T> boolean	PNone(T[] x, int first, int last, T value) Parallel None: Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PNone(TInpIter first, long n, IPredicate<T> pred) Parallel None: Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PNone(TInpIter first, long n, T value) Parallel None: Compares a range element by element for equality with a specified value.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PNone(TInpIter first, TInpIter last, IPredicate<T> pred) Parallel None: Compares a range element by element for equivalence in a sense specified by a unary predicate.
static <T,TInpIter extends IInpIter<T,TInpIter>> boolean	PNone(TInpIter first, TInpIter last, T value) Parallel None: Compares a range element by element for equality with a specified value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

Equal

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Equal(TInpIter first,
                                                      TInpIter last,
                                                      T value)

Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if all the elements in the input range are identical to the specified value; otherwise, false.

Equal

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Equal(TInpIter first,
                                                      long n,
                                                      T value)

Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if all the elements in the input range are identical to the specified value; otherwise, false.

Equal

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Equal(TInpIter first,
                                                      TInpIter last,
                                                      IPredicate<T> pred)

Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if all the elements in the input range satisfy the specified predicate; otherwise, false.

Equal

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Equal(TInpIter first,
                                                      long n,
                                                      IPredicate<T> pred)

Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if all the elements in the input range satisfy the specified predicate; otherwise, false.

Equal

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Equal(TInpIter first,
                                                      TInpIter last,
                                                      IFunc0Arg<T> func)

Compares a range element by element for equality with the result of a specified function object generator.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

func - A function object with no arguments that is used to generate the values that are compared with the elements in the range.

Returns:

True if all the elements in the input range are identical to the results of a specified function object generator; otherwise, false.

Equal

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Equal(TInpIter first,
                                                      long n,
                                                      IFunc0Arg<T> func)

Compares a range element by element for equality with the result of a specified function object generator.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

func - A function object with no arguments that is used to generate the values that are compared with the elements in the range.

Returns:

True if all the elements in the input range are identical to the results of a specified function object generator; otherwise, false.

Equal

public static <T> boolean Equal(T[] x,
                int first,
                int last,
                T value)

Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if all the elements in the input range are identical to the specified value; otherwise, false.

Equal

public static <T> boolean Equal(T[] x,
                int first,
                int last,
                IPredicate<T> pred)

Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if all the elements in the input range satisfy the specified predicate; otherwise, false.

Equal

public static <T> boolean Equal(T[] x,
                int first,
                int last,
                IFunc0Arg<T> func)

Compares a range element by element for equality with the result of a specified function object generator.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

func - A function object with no arguments that is used to generate the values that are compared with the elements in the range.

Returns:

True if all the elements in the input range are identical to the results of a specified function object generator; otherwise, false.

Equal

public static <T> boolean Equal(T[] x,
                int first,
                int last,
                IFunc1Arg<java.lang.Integer,T> func)

Compares a range element by element for equality with the result of a specified function generator.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

func - A function with one argument that is used to generate the values that are compared with the elements in the range.

Returns:

True if all the elements in the input range are identical to the results of a specified function generator; otherwise, false.

PEqual

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PEqual(TInpIter first,
                                                       TInpIter last,
                                                       T value)

Parallel Equal: Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if all the elements in the input range are identical to the specified value; otherwise, false.

PEqual

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PEqual(TInpIter first,
                                                       long n,
                                                       T value)

Parallel Equal: Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if all the elements in the input range are identical to the specified value; otherwise, false.

PEqual

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PEqual(TInpIter first,
                                                       TInpIter last,
                                                       IPredicate<T> pred)

Parallel Equal: Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if all the elements in the input range satisfy the specified predicate; otherwise, false.

PEqual

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PEqual(TInpIter first,
                                                       long n,
                                                       IPredicate<T> pred)

Parallel Equal: Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if all the elements in the input range satisfy the specified predicate; otherwise, false.

PEqual

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PEqual(TInpIter first,
                                                       TInpIter last,
                                                       IFunc1Arg<java.lang.Long,T> func)

Parallel Equal: Compares a range element by element for equality with the result of a specified function object generator.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

func - A function object with no arguments that is used to generate the values that are compared with the elements in the range.

Returns:

True if all the elements in the input range are identical to the results of a specified function object generator; otherwise, false.

PEqual

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PEqual(TInpIter first,
                                                       long n,
                                                       IFunc1Arg<java.lang.Long,T> func)

Parallel Equal: Compares a range element by element for equality with the result of a specified function object generator.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

func - A function object with no arguments that is used to generate the values that are compared with the elements in the range.

Returns:

True if all the elements in the input range are identical to the results of a specified function object generator; otherwise, false.

PEqual

public static <T> boolean PEqual(T[] x,
                 int first,
                 int last,
                 T value)

Parallel Equal: Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if all the elements in the input range are identical to the specified value; otherwise, false.

PEqual

public static <T> boolean PEqual(T[] x,
                 int first,
                 int last,
                 IPredicate<T> pred)

Parallel Equal: Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if all the elements in the input range satisfy the specified predicate; otherwise, false.

PEqual

public static <T> boolean PEqual(T[] x,
                 int first,
                 int last,
                 IFunc1Arg<java.lang.Integer,T> func)

Parallel Equal: Compares a range element by element for equality with the result of a specified function generator.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

func - A function with one argument that is used to generate the values that are compared with the elements in the range.

Returns:

True if all the elements in the input range are identical to the results of a specified function generator; otherwise, false.

Any

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Any(TInpIter first,
                                                    TInpIter last,
                                                    T value)

Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if any of the elements in the input range are identical to the specified value; otherwise, false.

Any

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Any(TInpIter first,
                                                    long n,
                                                    T value)

Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if any of the elements in the input range are identical to the specified value; otherwise, false.

Any

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Any(TInpIter first,
                                                    TInpIter last,
                                                    IPredicate<T> pred)

Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if any of the elements in the input range satisfy the specified predicate; otherwise, false.

Any

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean Any(TInpIter first,
                                                    long n,
                                                    IPredicate<T> pred)

Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if any of the elements in the input range satisfy the specified predicate; otherwise, false.

Any

public static <T> boolean Any(T[] x,
              int first,
              int last,
              T value)

Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if any of the elements in the input range are identical to the specified value; otherwise, false.

Any

public static <T> boolean Any(T[] x,
              int first,
              int last,
              IPredicate<T> pred)

Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if any of the elements in the input range satisfy the specified predicate; otherwise, false.

PAny

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PAny(TInpIter first,
                                                     TInpIter last,
                                                     T value)

Parallel Any: Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if any of the elements in the input range are identical to the specified value; otherwise, false.

PAny

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PAny(TInpIter first,
                                                     long n,
                                                     T value)

Parallel Any: Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if any of the elements in the input range are identical to the specified value; otherwise, false.

PAny

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PAny(TInpIter first,
                                                     TInpIter last,
                                                     IPredicate<T> pred)

Parallel Any: Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if any of the elements in the input range satisfy the specified predicate; otherwise, false.

PAny

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PAny(TInpIter first,
                                                     long n,
                                                     IPredicate<T> pred)

Parallel Any: Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if any of the elements in the input range satisfy the specified predicate; otherwise, false.

PAny

public static <T> boolean PAny(T[] x,
               int first,
               int last,
               T value)

Parallel Any: Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

value - The value that the elements in the range are compared to.

Returns:

True if any of the elements in the input range are identical to the specified value; otherwise, false.

PAny

public static <T> boolean PAny(T[] x,
               int first,
               int last,
               IPredicate<T> pred)

Parallel Any: Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if any of the elements in the input range satisfy the specified predicate; otherwise, false.

None

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean None(TInpIter first,
                                                     TInpIter last,
                                                     T value)

Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

value - The value that all the elements in the range are compared to.

Returns:

True if none of the elements in the input range are identical to the specified value; otherwise, false.

None

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean None(TInpIter first,
                                                     long n,
                                                     T value)

Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

value - The value that all the elements in the range are compared to.

Returns:

True if none of the elements in the input range are identical to the specified value; otherwise, false.

None

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean None(TInpIter first,
                                                     TInpIter last,
                                                     IPredicate<T> pred)

Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if none of the elements in the input range satisfy the specified predicate; otherwise, false.

None

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean None(TInpIter first,
                                                     long n,
                                                     IPredicate<T> pred)

Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if none of the elements in the input range satisfy the specified predicate; otherwise, false.

None

public static <T> boolean None(T[] x,
               int first,
               int last,
               T value)

Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

value - The value that all the elements in the range are compared to.

Returns:

True if none of the elements in the input range are identical to the specified value; otherwise, false.

None

public static <T> boolean None(T[] x,
               int first,
               int last,
               IPredicate<T> pred)

Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if none of the elements in the input range satisfy the specified predicate; otherwise, false.

PNone

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PNone(TInpIter first,
                                                      TInpIter last,
                                                      T value)

Parallel None: Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

value - The value that all the elements in the range are compared to.

Returns:

True if none of the elements in the input range are identical to the specified value; otherwise, false.

PNone

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PNone(TInpIter first,
                                                      long n,
                                                      T value)

Parallel None: Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

value - The value that all the elements in the range are compared to.

Returns:

True if none of the elements in the input range are identical to the specified value; otherwise, false.

PNone

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PNone(TInpIter first,
                                                      TInpIter last,
                                                      IPredicate<T> pred)

Parallel None: Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An input iterator addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if none of the elements in the input range satisfy the specified predicate; otherwise, false.

PNone

public static <T,TInpIter extends IInpIter<T,TInpIter>> boolean PNone(TInpIter first,
                                                      long n,
                                                      IPredicate<T> pred)

Parallel None: Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

n - The number of elements in the specified range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if none of the elements in the input range satisfy the specified predicate; otherwise, false.

PNone

public static <T> boolean PNone(T[] x,
                int first,
                int last,
                T value)

Parallel None: Compares a range element by element for equality with a specified value.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

value - The value that all the elements in the range are compared to.

Returns:

True if none of the elements in the input range are identical to the specified value; otherwise, false.

PNone

public static <T> boolean PNone(T[] x,
                int first,
                int last,
                IPredicate<T> pred)

Parallel None: Compares a range element by element for equivalence in a sense specified by a unary predicate.

Remarks: The ranges to be tested 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 tested.

last - An integer addressing the position one past the final element in the range to be tested.

pred - A user-defined predicate function object that defines the condition to be satisfied by the elements in the range.

Returns:

True if none of the elements in the input range satisfy the specified predicate; otherwise, false.