declarations

// Type definitions for TypeScript-STL v1.0.8 // Project: https://github.com/samchon/typescript-stl // Definitions by: Jeongho Nam <http://samchon.org> // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped declare module "typescript-stl" { export = std; } /** * <h1> TypeScript-STL </h1> * <a href="https://nodei.co/npm/typescript-stl"> * <img src="https://nodei.co/npm/typescript-stl.png?downloads=true&downloadRank=true&stars=true"> </a> * * STL (Standard Template Library) Containers and Algorithms for TypeScript. * * TypeScript-STL is a TypeScript's Standard Template Library who is migrated from C++ STL. Most of classes * and functions of STL have implemented. Just enjoy it. * * @git https://github.com/samchon/typescript-stl * @author Jeongho Nam <http://samchon.org> */ declare namespace std { /** * Type definition of {@link Vector} and it's the original name used in C++. */ export import vector = Vector; /** * Type definition of {@link List} and it's the original name used in C++. */ export import list = List; /** * Type definition of {@link Deque} and it's the original name used in C++. */ export import deque = Deque; /** * Type definition of {@link Stack} and it's the original name used in C++. */ type stack<T> = Stack<T>; /** * Type definition of {@link Queue} and it's the original name used in C++. */ type queue<T> = Queue<T>; /** * Type definition of {@link PriorityQueue} and it's the original name used in C++. */ type priority_queue<T> = PriorityQueue<T>; var stack: typeof Stack; var queue: typeof Queue; var priority_queue: typeof PriorityQueue; /** * Type definition of {@link TreeSet} and it's the original name used in C++. */ export import set = TreeSet; /** * Type definition of {@link TreeMultiSet} and it's the original name used in C++. */ export import multiset = TreeMultiSet; /** * Type definition of {@link HashSet} and it's the original name used in C++. */ export import unordered_set = HashSet; /** * Type definition of {@link HashMultiSet} and it's the original name used in C++. */ export import unordered_multiset = HashMultiSet; /** * Type definition of {@link TreeMap} and it's the original name used in C++. */ export import map = TreeMap; /** * Type definition of {@link TreeMultiMap} and it's the original name used in C++. */ export import multimap = TreeMultiMap; /** * Type definition of {@link HashMap} and it's the original name used in C++. */ export import unordered_map = HashMap; /** * Type definition of {@link HashMultiMap} and it's the original name used in C++. */ export import unordered_multimap = HashMultiMap; type exception = Exception; type logic_error = LogicError; type domain_error = DomainError; type invalid_argument = InvalidArgument; type length_error = LengthError; type out_of_range = OutOfRange; type runtime_error = RuntimeError; type overflow_error = OverflowError; type underflow_error = UnderflowError; type range_error = RangeError; type system_error = SystemError; type error_category = ErrorCategory; type error_condition = ErrorCondition; type error_code = ErrorCode; var exception: typeof Exception; var logic_error: typeof LogicError; var domain_error: typeof DomainError; var invalid_argument: typeof InvalidArgument; var length_error: typeof LengthError; var out_of_range: typeof OutOfRange; var runtime_error: typeof RuntimeError; var overflow_error: typeof OverflowError; var underflow_error: typeof UnderflowError; var range_error: typeof RangeError; var system_error: typeof SystemError; var error_category: typeof ErrorCategory; var error_condition: typeof ErrorCondition; var error_code: typeof ErrorCode; } /** * Base classes composing STL in background. * * @author Jeongho Nam <http://samchon.org> */ declare namespace std.base { } declare namespace std { /** * Apply function to range. * * Applies function fn to each of the elements in the range [first, last). * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param fn Unary function that accepts an element in the range as argument. This can either be a function p * ointer or a move constructible function object. Its return value, if any, is ignored. * * @return Returns fn. */ function for_each<T, InputIterator extends Iterator<T>, Func extends (val: T) => any>(first: InputIterator, last: InputIterator, fn: Func): Func; /** * Test condition on all elements in range. * * Returns <code>true</code> if pred returns <code>true</code> for all the elements in the range * [first, last) or if the range is {@link IContainer.empty empty}, and <code>false</code> otherwise. * * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to * <code>boolean</code>. The value returned indicates whether the element fulfills the condition * checked by this function. The function shall not modify its argument. * * @return <code>true</code> if pred returns true for all the elements in the range or if the range is * {@link IContainer.empty empty}, and <code>false</code> otherwise. */ function all_of<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): boolean; /** * Test if any element in range fulfills condition. * * Returns <code>true</code> if pred returns true for any of the elements in the range * [first, last), and <code>false</code> otherwise. * * If [first, last) is an {@link IContainer.empty empty} range, the function returns * <code>false</code>. * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to * <code>boolean</code>. The value returned indicates whether the element fulfills the condition * checked by this function. The function shall not modify its argument. * * @return <code>true</code> if pred returns <code>true</code> for any of the elements in the range * [first, last), and <code>false</code> otherwise. If [first, last) is an * {@link IContainer.empty empty} range, the function returns <code>false</code>. */ function any_of<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): boolean; /** * Test if no elements fulfill condition. * * Returns <code>true</code> if pred returns false for all the elements in the range * [first, last) or if the range is {@link IContainer.empty empty}, and <code>false</code> otherwise. * * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to * <code>boolean</code>. The value returned indicates whether the element fulfills the condition * checked by this function. The function shall not modify its argument. * * @return <code>true</code> if pred returns <code>false</code> for all the elements in the range * [first, last) or if the range is {@link IContainer.empty empty}, and <code>false</code> * otherwise. */ function none_of<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): boolean; /** * Test whether the elements in two ranges are equal. * * Compares the elements in the range [first1, last1) with those in the range beginning at * first2, and returns <code>true</code> if all of the elements in both ranges match. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to * as many elements of this sequence as those in the range [first1, last1). * * @return <code>true</code> if all the elements in the range [first1, last1) compare equal to those * of the range starting at first2, and <code>false</code> otherwise. */ function equal<T, Iterator1 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator<T>): boolean; /** * Test whether the elements in two ranges are equal. * * Compares the elements in the range [first1, last1) with those in the range beginning at * first2, and returns <code>true</code> if all of the elements in both ranges match. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to * as many elements of this sequence as those in the range [first1, last1). * @param pred Binary function that accepts two elements as argument (one of each of the two sequences, in the same * order), and returns a value convertible to <code>bool</code>. The value returned indicates whether * the elements are considered to match in the context of this function. * * @return <code>true</code> if all the elements in the range [first1, last1) compare equal to those * of the range starting at first2, and <code>false</code> otherwise. */ function equal<T, Iterator1 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator<T>, pred: (x: T, y: T) => boolean): boolean; /** * Test whether range is permutation of another. * * Compares the elements in the range [first1, last1) with those in the range beginning at * first2, and returns <code>true</code> if all of the elements in both ranges match, even in a different * order. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to * as many elements of this sequence as those in the range [first1, last1). * * @return <code>true</code> if all the elements in the range [first1, last1) compare equal to those * of the range starting at first2 in any order, and <code>false</code> otherwise. */ function is_permutation<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2): boolean; /** * Test whether range is permutation of another. * * Compares the elements in the range [first1, last1) with those in the range beginning at * first2, and returns <code>true</code> if all of the elements in both ranges match, even in a different * order. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to * as many elements of this sequence as those in the range [first1, last1). * @param pred Binary function that accepts two elements as argument (one of each of the two sequences, in the same * order), and returns a value convertible to <code>bool</code>. The value returned indicates whether * the elements are considered to match in the context of this function. * * @return <code>true</code> if all the elements in the range [first1, last1) compare equal to those * of the range starting at first2 in any order, and <code>false</code> otherwise. */ function is_permutation<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, pred: (x: T, y: T) => boolean): boolean; /** * Lexicographical less-than comparison. * * Returns <code>true</code> if the range [first1, last1) compares lexicographically less * than the range [first2, last2). * * A lexicographical comparison is the kind of comparison generally used to sort words alphabetically in * dictionaries; It involves comparing sequentially the elements that have the same position in both ranges against * each other until one element is not equivalent to the other. The result of comparing these first non-matching * elements is the result of the lexicographical comparison. * * If both sequences compare equal until one of them ends, the shorter sequence is lexicographically less * than the longer one. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the second sequence. * @param last2 An {@link Iterator} to the final position of the second sequence. The ranged used is * [first2, last2). * * @return <code>true</code> if the first range compares lexicographically less than than the second. * <code>false</code> otherwise (including when all the elements of both ranges are equivalent). */ function lexicographical_compare<T, T1 extends T, T2 extends T, Iterator1 extends Iterator<T1>, Iterator2 extends Iterator<T2>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2): boolean; /** * Lexicographical comparison. * * Returns <code>true</code> if the range [first1, last1) compares lexicographically * relationship than the range [first2, last2). * * A lexicographical comparison is the kind of comparison generally used to sort words alphabetically in * dictionaries; It involves comparing sequentially the elements that have the same position in both ranges against * each other until one element is not equivalent to the other. The result of comparing these first non-matching * elements is the result of the lexicographical comparison. * * If both sequences compare equal until one of them ends, the shorter sequence is lexicographically * relationship than the longer one. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the second sequence. * @param last2 An {@link Iterator} to the final position of the second sequence. The ranged used is * [first2, last2). * @param compare Binary function that accepts two arguments of the types pointed by the iterators, and returns a * value convertible to <code>bool</code>. The value returned indicates whether the first argument is * considered to go before the second in the specific strict weak ordering it defines. * * @return <code>true</code> if the first range compares lexicographically relationship than than the * second. <code>false</code> otherwise (including when all the elements of both ranges are equivalent). */ function lexicographical_compare<T, T1 extends T, T2 extends T, Iterator1 extends Iterator<T1>, Iterator2 extends Iterator<T2>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2, compare: (x: T, y: T) => boolean): boolean; /** * Find value in range. * * Returns an iterator to the first element in the range [first, last) that compares equal to * val. If no such element is found, the function returns last. * * The function uses {@link equal_to equal_to} to compare the individual elements to val. * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param val Value to search for in the range. * * @return An {@link Iterator} to the first element in the range that compares equal to val. If no elements * match, the function returns last. */ function find<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, val: T): InputIterator; /** * Find element in range. * * Returns an iterator to the first element in the range [first, last) for which pred returns * <code>true</code>. If no such element is found, the function returns last. * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param pred Unary function that accepts an element in the range as argument and returns a value convertible * to <code>bool</code>. The value returned indicates whether the element is considered a match in * the context of this function. The function shall not modify its argument. * * @return An {@link Iterator} to the first element in the range for which pred does not return * <code>false</code>. If pred is <code>false</code> for all elements, the function returns * last. */ function find_if<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): InputIterator; /** * Find element in range. * * Returns an iterator to the first element in the range [first, last) for which pred returns * <code>true</code>. If no such element is found, the function returns last. * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param pred Unary function that accepts an element in the range as argument and returns a value convertible * to <code>bool</code>. The value returned indicates whether the element is considered a match in * the context of this function. The function shall not modify its argument. * * @return An {@link Iterator} to the first element in the range for which pred returns <code>false</code>. * If pred is <code>true</code> for all elements, the function returns last. */ function find_if_not<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): InputIterator; /** * Find last subsequence in range. * * Searches the range [first1, last1) for the last occurrence of the sequence defined by * [first2, last2), and returns an {@link Iterator} to its first element, or last1,/i> if no * occurrences are found. * * The elements in both ranges are compared sequentially using {@link equal_to}: A subsequence of * [first1, last1) is considered a match only when this is <code>true</code> for all the elements of * [first2, last2). * * This function returns the last of such occurrences. For an algorithm that returns the first instead, see * {@link search}. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the element values to be searched for. * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used * is [first2, last2). * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the * same order), and returns a value convertible to <code>bool</code>. The value returned indicates * whether the elements are considered to match in the context of this function. * * @return An {@link Iterator} to the first element of the last occurrence of [first2, last2) in * [first1, last1). If the sequence is not found, the function returns ,i>last1. Otherwise * [first2, last2) is an empty range, the function returns last1. */ function find_end<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2): Iterator1; /** * Find last subsequence in range. * * Searches the range [first1, last1) for the last occurrence of the sequence defined by * [first2, last2), and returns an {@link Iterator} to its first element, or last1,/i> if no * occurrences are found. * * The elements in both ranges are compared sequentially using pred: A subsequence of * [first1, last1) is considered a match only when this is <code>true</code> for all the elements of * [first2, last2). * * This function returns the last of such occurrences. For an algorithm that returns the first instead, see * {@link search}. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the element values to be searched for. * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used * is [first2, last2). * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the * same order), and returns a value convertible to <code>bool</code>. The value returned indicates * whether the elements are considered to match in the context of this function. * * @return An {@link Iterator} to the first element of the last occurrence of [first2, last2) in * [first1, last1). If the sequence is not found, the function returns ,i>last1. Otherwise * [first2, last2) is an empty range, the function returns last1. */ function find_end<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2, pred: (x: T, y: T) => boolean): Iterator1; /** * Find element from set in range. * * Returns an iterator to the first element in the range [first1, last1) that matches any of the * elements in [first2, last2). If no such element is found, the function returns last1. * * The elements in [first1, last1) are sequentially compared to each of the values in * [first2, last2) using {@link equal_to}, until a pair matches. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the element values to be searched for. * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used * is [first2, last2). * * @return An {@link Iterator} to the first element in [first1, last1) that is part of * [first2, last2). If no matches are found, the function returns last1. */ function find_first_of<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2): Iterator1; /** * Find element from set in range. * * Returns an iterator to the first element in the range [first1, last1) that matches any of the * elements in [first2, last2). If no such element is found, the function returns last1. * * The elements in [first1, last1) are sequentially compared to each of the values in * [first2, last2) using pred, until a pair matches. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the element values to be searched for. * @param last2 An {@link Iterator} to the final position of the element values to be searched for. The range used * is [first2, last2). * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the * same order), and returns a value convertible to <code>bool</code>. The value returned indicates * whether the elements are considered to match in the context of this function. * * @return An {@link Iterator} to the first element in [first1, last1) that is part of * [first2, last2). If no matches are found, the function returns last1. */ function find_first_of<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, last2: Iterator2, pred: (x: T, y: T) => boolean): Iterator1; /** * Find equal adjacent elements in range. * * Searches the range [first, last) for the first occurrence of two consecutive elements that match, * and returns an {@link Iterator} to the first of these two elements, or last if no such pair is found. * * Two elements match if they compare equal using {@link equal_to}. * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * * @return An {@link Iterator} to the first element of the first pair of matching consecutive elements in the range * [first, last). If no such pair is found, the function returns last. */ function adjacent_find<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator): InputIterator; /** * Find equal adjacent elements in range. * * Searches the range [first, last) for the first occurrence of two consecutive elements that match, * and returns an {@link Iterator} to the first of these two elements, or last if no such pair is found. * * Two elements match if they compare equal using pred. * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param pred Unary function that accepts an element in the range as argument and returns a value convertible to * <code>bool</code>. The value returned indicates whether the element is considered a match in the * context of this function. The function shall not modify its argument. * * @return An {@link Iterator} to the first element of the first pair of matching consecutive elements in the range * [first, last). If no such pair is found, the function returns last. */ function adjacent_find<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (x: T, y: T) => boolean): InputIterator; /** * Search range for subsequence. * * Searches the range [first1, last1) for the first occurrence of the sequence defined by * [first2, last2), and returns an iterator to its first element, or last1 if no occurrences are * found. * * The elements in both ranges are compared sequentially using {@link equal_to}: A subsequence of * [first1, last1) is considered a match only when this is true for all the elements of * [first2, last2). * * This function returns the first of such occurrences. For an algorithm that returns the last instead, see * {@link find_end}. * * @param first1 {@link Iterator Forward iterator} to the initial position of the searched sequence. * @param last1 {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is * [first1, last1), which contains all the elements between first1 and last1, * including the element pointed by first1 but not the element pointed by last1. * @param first2 {@link Iterator Forward iterator} to the initial position of the sequence to be searched for. * @param last2 {@link Iterator Forward iterator} to the final position of the sequence to be searched for. The range * used is [first2, last2). * * @return An iterator to the first element of the first occurrence of [first2, last2) in first1 * and last1. If the sequence is not found, the function returns last1. Otherwise * [first2, last2) is an empty range, the function returns first1. */ function search<T, ForwardIterator1 extends Iterator<T>, ForwardIterator2 extends Iterator<T>>(first1: ForwardIterator1, last1: ForwardIterator1, first2: ForwardIterator2, last2: ForwardIterator2): ForwardIterator1; /** * Search range for subsequence. * * Searches the range [first1, last1) for the first occurrence of the sequence defined by * [first2, last2), and returns an iterator to its first element, or last1 if no occurrences are * found. * * The elements in both ranges are compared sequentially using pred: A subsequence of * [first1, last1) is considered a match only when this is true for all the elements of * [first2, last2). * * This function returns the first of such occurrences. For an algorithm that returns the last instead, see * {@link find_end}. * * @param first1 {@link Iterator Forward iterator} to the initial position of the searched sequence. * @param last1 {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is * [first1, last1), which contains all the elements between first1 and last1, * including the element pointed by first1 but not the element pointed by last1. * @param first2 {@link Iterator Forward iterator} to the initial position of the sequence to be searched for. * @param last2 {@link Iterator Forward iterator} to the final position of the sequence to be searched for. The range * used is [first2, last2). * @param pred Binary function that accepts two elements as arguments (one of each of the two sequences, in the same * order), and returns a value convertible to bool. The returned value indicates whether the elements are * considered to match in the context of this function. The function shall not modify any of its * arguments. * * @return An iterator to the first element of the first occurrence of [first2, last2) in * [first1, last1). If the sequence is not found, the function returns last1. Otherwise * [first2, last2) is an empty range, the function returns first1. */ function search<T, ForwardIterator1 extends Iterator<T>, ForwardIterator2 extends Iterator<T>>(first1: ForwardIterator1, last1: ForwardIterator1, first2: ForwardIterator2, last2: ForwardIterator2, pred: (x: T, y: T) => boolean): ForwardIterator1; /** * Search range for elements. * * Searches the range [first, last) for a sequence of count elements, each comparing equal to * val. * * The function returns an iterator to the first of such elements, or last if no such sequence is found. * * * @param first {@link Iterator Forward iterator} to the initial position of the searched sequence. * @param last {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is * [first, last), which contains all the elements between first and last, * including the element pointed by first but not the element pointed by last. * @param count Minimum number of successive elements to match. * @param val Individual value to be compared, or to be used as argument for {@link equal_to}. * * @return An iterator to the first element of the sequence. If no such sequence is found, the function returns * last. */ function search_n<T, ForwardIterator extends base.IArrayIterator<T>>(first: ForwardIterator, last: ForwardIterator, count: number, val: T): ForwardIterator; /** * Search range for elements. * * Searches the range [first, last) for a sequence of count elements, each comparing equal to * val. * * The function returns an iterator to the first of such elements, or last if no such sequence is found. * * * @param first {@link Iterator Forward iterator} to the initial position of the searched sequence. * @param last {@link Iterator Forward iterator} to the final position of the searched sequence. The range used is * [first, last), which contains all the elements between first and last, * including the element pointed by first but not the element pointed by last. * @param count Minimum number of successive elements to match. * @param val Individual value to be compared, or to be used as argument for pred. * @param pred Binary function that accepts two arguments (one element from the sequence as first, and val as * second), and returns a value convertible to <code>bool</code>. The value returned indicates whether the * element is considered a match in the context of this function. The function shall not modify any of its * arguments. * * @return An {@link Iterator} to the first element of the sequence. If no such sequence is found, the function * returns last. */ function search_n<T, ForwardIterator extends base.IArrayIterator<T>>(first: ForwardIterator, last: ForwardIterator, count: number, val: T, pred: (x: T, y: T) => boolean): ForwardIterator; /** * Return first position where two ranges differ. * * Compares the elements in the range [first1, last1) with those in the range beginning at * first2, and returns the first element of both sequences that does not match. * * The function returns a {@link Pair} of {@link iterators Iterator} to the first element in each range that * does not match. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to * as many elements of this sequence as those in the range [first1, last1). * * @return A {@link Pair}, where its members {@link Pair.first first} and {@link Pair.second second} point to the * first element in both sequences that did not compare equal to each other. If the elements compared in * both sequences have all matched, the function returns a {@link Pair} with {@link Pair.first first} set * to last1 and {@link Pair.second second} set to the element in that same relative position in the * second sequence. If none matched, it returns {@link make_pair}(first1, first2). */ function mismatch<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2): Pair<Iterator1, Iterator2>; /** * Return first position where two ranges differ. * * Compares the elements in the range [first1, last1) with those in the range beginning at * first2, and returns the first element of both sequences that does not match. * * The function returns a {@link Pair} of {@link iterators Iterator} to the first element in each range that * does not match. * * @param first1 An {@link Iterator} to the initial position of the first sequence. * @param last1 An {@link Iterator} to the final position in a sequence. The range used is * [first1, last1), including the element pointed by first1, but not the element * pointed by last1. * @param first2 An {@link Iterator} to the initial position of the second sequence. The comparison includes up to * as many elements of this sequence as those in the range [first1, last1). * @param pred Binary function that accepts two elements as argument (one of each of the two sequences, in the same * order), and returns a value convertible to <code>bool</code>. The value returned indicates whether * the elements are considered to match in the context of this function. * * @return A {@link Pair}, where its members {@link Pair.first first} and {@link Pair.second second} point to the * first element in both sequences that did not compare equal to each other. If the elements compared in * both sequences have all matched, the function returns a {@link Pair} with {@link Pair.first first} set * to last1 and {@link Pair.second second} set to the element in that same relative position in the * second sequence. If none matched, it returns {@link make_pair}(first1, first2). */ function mismatch<T, Iterator1 extends Iterator<T>, Iterator2 extends Iterator<T>>(first1: Iterator1, last1: Iterator1, first2: Iterator2, compare: (x: T, y: T) => boolean): Pair<Iterator1, Iterator2>; /** * Count appearances of value in range. * * Returns the number of elements in the range [first, last) that compare equal to val. * * The function uses {@link equal_to} to compare the individual elements to val. * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param val Value to match. * * @return The number of elements in the range [first, last) that compare equal to val. */ function count<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, val: T): number; /** * Return number of elements in range satisfying condition. * * Returns the number of elements in the range [first, last) for which pred is <code>true</code>. * * * @param first An {@link Iterator} to the initial position in a sequence. * @param last An {@link Iterator} to the final position in a sequence. The range used is [first, last), * which contains all the elements between first and last, including the element pointed by * first but not the element pointed by last. * @param pred Unary function that accepts an element in the range as argument, and returns a value convertible * to <code>bool</code>. The value returned indicates whether the element is counted by this function. * The function shall not modify its argument. This can either be a function pointer or a function * object. */ function count_if<T, InputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, pred: (val: T) => boolean): number; } declare namespace std { /** * Copy range of elements. * * Copies the elements in the range [first, last) into the range beginning at result. * * The function returns an iterator to the end of the destination range (which points to the element following the * last element copied). * * The ranges shall not overlap in such a way that result points to an element in the range * [first, last). For such cases, see {@link copy_backward}. * * @param first {@link Iterator Input iterator} to the initial position in a sequence to be copied. * @param last {@link Iterator Input iterator} to the initial position in a sequence to be copied. The range used is * [first, last), which contains all the elements between first and last, * including the element pointed by first but not the element pointed by last. * @param result {@link Iterator Output iterator} to the initial position in the destination sequence. This shall not * point to any element in the range [first, last). * * @return An iterator to the end of the destination range where elements have been copied. */ function copy<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, last: InputIterator, result: OutputIterator): OutputIterator; /** * Copy elements. * * Copies the first n elements from the range beginning at first into the range beginning at * result. * * The function returns an iterator to the end of the destination range (which points to one past the last element * copied). * * If n is negative, the function does nothing. * * If the ranges overlap, some of the elements in the range pointed by result may have undefined but valid values. * * * @param first {@link Iterator Input iterator} to the initial position in a sequence of at least n elements to * be copied. InputIterator shall point to a type assignable to the elements pointed by * OutputIterator. * @param n Number of elements to copy. If this value is negative, the function does nothing. * @param result {@link Iterator Output iterator} to the initial position in the destination sequence of at least * n elements. This shall not point to any element in the range [first, last]. * * @return An iterator to the end of the destination range where elements have been copied. */ function copy_n<T, InputIterator extends Iterator<T>, OutputIterator extends Iterator<T>>(first: InputIterator, n: number, result: OutputIterator): OutputIterator; /** * Copy certain elements of range. * * Copies the elements in the range [first, last) for which pred returns <code>true</code> to the * range beginning at result. * * @param first {@link Iterator Input iterator} to the initial position in a sequence to be copied. * @param last {@link Iterator Input iterator} to the initi