vector.hpp File Reference

#include "config.hpp"
#include <cstddef>
#include <vector>
#include <iostream>
#include <fstream>
#include <sstream>
#include <limits>
#include <cmath>
#include <algorithm>
#include "frwrddecl.hpp"
#include "type_opers.hpp"
#include "type_traits.hpp"
#include "type_pair_traits.hpp"
#include "function_traits.hpp"
#include "mixcomp.hpp"
#include "exception.hpp"
#include "vecalg.hpp"
#include "refcntr.hpp"
#include "_utility.hpp"
#include "factory.hpp"
#include "cmp.hpp"
#include "io.hpp"
#include "functional.hpp"
#include "big_int.hpp"
#include "subvector/indexed.hpp"
#include "std_import.hpp"
#include "vector.cpp"

Go to the source code of this file.

Namespaces
namespace	Arageli
namespace	Arageli::_Internal
namespace	std
Classes
struct	Arageli::fromseq_t
struct	Arageli::fromval_t
struct	Arageli::fromvec_t
struct	Arageli::fromsize_t
struct	Arageli::fromstr_t
struct	Arageli::binary_function_traits< function_tag::subscript, vector< T, REFCNT >, Index >
struct	Arageli::binary_function_traits< function_tag::subscript, const vector< T, REFCNT >, Index >
struct	Arageli::binary_function_traits< function_tag::parentheses_1, vector< T, REFCNT >, Index >
struct	Arageli::binary_function_traits< function_tag::parentheses_1, const vector< T, REFCNT >, Index >
struct	Arageli::_element_type_vec_val_1< X, is_assignable >
struct	Arageli::_element_type_vec_val_1< X, true >
struct	Arageli::_element_type_vec_val< T, X >
class	Arageli::vector< T, REFCNT >
	Template class vector definition. More...
struct	Arageli::vector< T, REFCNT >::other_element_type< T1 >
	Defines vector type with other element type and the same reference counter. More...
struct	Arageli::vector< T, REFCNT >::other_element_type_refcnt< T1, REFCNT1 >
	Defines vector type with other element type ane reference counter. More...
struct	Arageli::type_traits< vector< T, REFCNT > >
struct	Arageli::type_traits< vector< T, REFCNT > >::other_element_type_refcnt< T1, REFCNT2 >
struct	Arageli::unary_function_traits< Tag, vector< T, REFCNT > >
struct	Arageli::_Internal::select_non_vector< vector< T1, REFCNT1 >, T2 >
struct	Arageli::_Internal::select_non_vector< T1, vector< T2, REFCNT2 > >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, IS_CONVERT_12, IS_CONVERT_21, Tag_class >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, false, Tag_class >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, false, Tag_class >::function_traits
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, true, Tag_class >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, true, Tag_class >::function_traits
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, true, false, Tag_class >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, true, false, Tag_class >::function_traits
struct	Arageli::bfgs_vector_helper_1< function_tag::cmp, V1, V2, false, false, Tag_class >
struct	Arageli::bfgs_vector_helper_1< function_tag::cmp, V1, V2, false, false, Tag_class >::function_traits
struct	Arageli::bfgs_vector_helper_1< function_tag::cmp, V1, V2, false, true, Tag_class >
struct	Arageli::bfgs_vector_helper_1< function_tag::cmp, V1, V2, false, true, Tag_class >::function_traits
struct	Arageli::bfgs_vector_helper_1< function_tag::cmp, V1, V2, true, false, Tag_class >
struct	Arageli::bfgs_vector_helper_1< function_tag::cmp, V1, V2, true, false, Tag_class >::function_traits
struct	Arageli::bfgs_vector_helper_1< function_tag::each_cmp, V1, V2, false, false, Tag_class >
struct	Arageli::bfgs_vector_helper_1< function_tag::each_cmp, V1, V2, false, false, Tag_class >::function_traits
struct	Arageli::bfgs_vector_helper_1< function_tag::each_cmp, V1, V2, false, true, Tag_class >
struct	Arageli::bfgs_vector_helper_1< function_tag::each_cmp, V1, V2, false, true, Tag_class >::function_traits
struct	Arageli::bfgs_vector_helper_1< function_tag::each_cmp, V1, V2, true, false, Tag_class >
struct	Arageli::bfgs_vector_helper_1< function_tag::each_cmp, V1, V2, true, false, Tag_class >::function_traits
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, false, function_tag::each_compare >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, false, function_tag::each_compare >::function_traits
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, true, function_tag::each_compare >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, true, function_tag::each_compare >::function_traits
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, true, false, function_tag::each_compare >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, true, false, function_tag::each_compare >::function_traits
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, false, function_tag::all_compare >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, false, function_tag::all_compare >::function_traits
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, true, function_tag::all_compare >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, false, true, function_tag::all_compare >::function_traits
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, true, false, function_tag::all_compare >
struct	Arageli::bfgs_vector_helper_1< Tag, V1, V2, true, false, function_tag::all_compare >::function_traits
struct	Arageli::bfgs_vector_helper_2< Tag, T1, T2 >
struct	Arageli::bfgs_vector_helper_3< Tag, T1, T2 >
struct	Arageli::binary_function_gate_slot< Tag, vector< T, REFCNT >, T1, T2 >
struct	Arageli::binary_function_gate_slot< Tag, const vector< T, REFCNT >, T1, T2 >
struct	Arageli::binary_function_gate_slot< Tag, vector< T, REFCNT > &, T1, T2 >
struct	Arageli::binary_function_gate_slot< Tag, const vector< T, REFCNT > &, T1, T2 >
struct	Arageli::factory< vector< T, REFCNT > >
	Specialization of the template 'factory' for the Arageli::vector template. More...
Vector element modification operators.
This group of operators applied the specified operation for each item of the vector and argument (if any). Returns reference to the vector.
#define	_ARAGELI_VECTOR_ASSIGN_FUNC(MNEM, OPER)
Standard mathematical functions on vector.
template<typename T, bool REFCNT>
vector< T, true >	Arageli::sin (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::cos (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::tan (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::sinh (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::cosh (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::tanh (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::asin (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::acos (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::atan (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::abs (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::exp (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::floor (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::ceil (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::log (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::log10 (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, true >	Arageli::sqrt (const vector< T, REFCNT > &x)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
vector< T1, REFCNT1 >	Arageli::pow (const vector< T1, REFCNT1 > &a, const vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename P>
vector< T1, REFCNT1 >	Arageli::pow (const vector< T1, REFCNT1 > &a, const P &b)
Standard mathematical functions on vector.
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::sin (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::cos (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::tan (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::sinh (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::cosh (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::tanh (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::asin (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::acos (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::atan (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::abs (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::exp (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::floor (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::ceil (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::log (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::log10 (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, true >	std::sqrt (const Arageli::vector< T, REFCNT > &x)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
Arageli::vector< T1, REFCNT1 >	std::pow (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename P>
Arageli::vector< T1, REFCNT1 >	std::pow (const Arageli::vector< T1, REFCNT1 > &a, const P &b)
Standard algorithm overloading for Arageli::vector.
template<typename T, bool REFCNT, typename Fu>
Fu	std::for_each (Arageli::vector< T, REFCNT > &x, Fu f)
template<typename T, bool REFCNT, typename Fu>
Fu	std::for_each (const Arageli::vector< T, REFCNT > &x, Fu f)
template<typename T, bool REFCNT, typename T1>
Arageli::vector< T, REFCNT >::iterator	std::find (Arageli::vector< T, REFCNT > &x, const T1 &val)
template<typename T, bool REFCNT, typename T1>
Arageli::vector< T, REFCNT >::const_iterator	std::find (const Arageli::vector< T, REFCNT > &x, const T1 &val)
template<typename T, bool REFCNT, typename Fu>
Arageli::vector< T, REFCNT >::iterator	std::find_if (Arageli::vector< T, REFCNT > &x, Fu f)
template<typename T, bool REFCNT, typename Fu>
Arageli::vector< T, REFCNT >::const_iterator	std::find_if (const Arageli::vector< T, REFCNT > &x, Fu f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
Arageli::vector< T1, REFCNT1 >::iterator	std::find_end (Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::find_end (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
Arageli::vector< T1, REFCNT1 >::iterator	std::find_end (Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::find_end (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
Arageli::vector< T1, REFCNT1 >::iterator	std::find_first_of (Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::find_first_of (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
Arageli::vector< T1, REFCNT1 >::iterator	std::find_first_of (Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::find_first_of (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T, bool REFCNT>
Arageli::vector< T, REFCNT >::iterator	std::adjacent_find (Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
Arageli::vector< T, REFCNT >::const_iterator	std::adjacent_find (const Arageli::vector< T, REFCNT > &x)
template<typename T, bool REFCNT, typename Fb>
Arageli::vector< T, REFCNT >::iterator	std::adjacent_find (Arageli::vector< T, REFCNT > &x, Fb f)
template<typename T, bool REFCNT, typename Fb>
Arageli::vector< T, REFCNT >::const_iterator	std::adjacent_find (const Arageli::vector< T, REFCNT > &x, Fb f)
template<typename T, bool REFCNT, typename T1>
Arageli::vector< T, REFCNT >::difference_type	std::count (const Arageli::vector< T, REFCNT > &x, const T1 &val)
template<typename T, bool REFCNT, typename Fu>
Arageli::vector< T, REFCNT >::difference_type	std::count_if (const Arageli::vector< T, REFCNT > &x, Fu f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
pair< typename Arageli::vector< T1, REFCNT1 >::const_iterator, typename Arageli::vector< T2, REFCNT2 >::const_iterator >	std::mismatch (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
pair< typename Arageli::vector< T1, REFCNT1 >::const_iterator, typename Arageli::vector< T2, REFCNT2 >::const_iterator >	std::mismatch (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
pair< typename Arageli::vector< T1, REFCNT1 >::const_iterator, typename Arageli::vector< T2, REFCNT2 >::iterator >	std::mismatch (const Arageli::vector< T1, REFCNT1 > &a, Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
pair< typename Arageli::vector< T1, REFCNT1 >::const_iterator, typename Arageli::vector< T2, REFCNT2 >::iterator >	std::mismatch (const Arageli::vector< T1, REFCNT1 > &a, Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
pair< typename Arageli::vector< T1, REFCNT1 >::iterator, typename Arageli::vector< T2, REFCNT2 >::const_iterator >	std::mismatch (Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
pair< typename Arageli::vector< T1, REFCNT1 >::iterator, typename Arageli::vector< T2, REFCNT2 >::const_iterator >	std::mismatch (Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
bool	std::equal (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
bool	std::equal (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::search (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::search (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
Arageli::vector< T1, REFCNT1 >::iterator	std::search (Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fb>
Arageli::vector< T1, REFCNT1 >::iterator	std::search (Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Fb f)
template<typename T1, bool REFCNT1, typename Size, typename T>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::search (const Arageli::vector< T1, REFCNT1 > &a, Size count, const T &value)
template<typename T1, bool REFCNT1, typename Size, typename T, typename Fb>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::search (const Arageli::vector< T1, REFCNT1 > &a, Size count, const T &value, Fb f)
template<typename T1, bool REFCNT1, typename Size, typename T>
Arageli::vector< T1, REFCNT1 >::iterator	std::search (Arageli::vector< T1, REFCNT1 > &a, Size count, const T &value)
template<typename T1, bool REFCNT1, typename Size, typename T, typename Fb>
Arageli::vector< T1, REFCNT1 >::iterator	std::search (Arageli::vector< T1, REFCNT1 > &a, Size count, const T &value, Fb f)
template<typename T1, bool REFCNT1, typename Out>
Out	std::copy (const Arageli::vector< T1, REFCNT1 > &a, Out out)
template<typename T1, bool REFCNT1, typename Out>
Out	std::copy_backward (const Arageli::vector< T1, REFCNT1 > &a, Out out)
template<typename T1, bool REFCNT1, typename Fu>
void	std::transform (Arageli::vector< T1, REFCNT1 > &a, Fu f)
	Applies f to each item of a and stores the result to the same item.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fu>
void	std::transform (const Arageli::vector< T1, REFCNT1 > &a, Arageli::vector< T2, REFCNT2 > &b, Fu f)
	Applies f to each item in a and stores the result to corresponding item of b.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3, typename Fb>
void	std::transform (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Arageli::vector< T3, REFCNT3 > &c, Fb f)
template<typename T1, bool REFCNT1, typename T2>
void	std::replace (Arageli::vector< T1, REFCNT1 > &a, const T2 &oldv, const T2 &newv)
template<typename T1, bool REFCNT1, typename Fu, typename T2>
void	std::replace_if (Arageli::vector< T1, REFCNT1 > &a, Fu f, const T2 &newv)
template<typename T1, bool REFCNT1, typename Out, typename T2>
Out	std::replace_copy (Arageli::vector< T1, REFCNT1 > &a, Out out, const T2 &oldv, const T2 &newv)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3>
void	std::replace_copy (Arageli::vector< T1, REFCNT1 > &a, Arageli::vector< T2, REFCNT2 > &b, const T3 &oldv, const T3 &newv)
template<typename T1, bool REFCNT1, typename Out, typename Fu, typename T2>
Out	std::replace_copy_if (Arageli::vector< T1, REFCNT1 > &a, Out out, Fu f, const T2 &newv)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Fu, typename T3>
void	std::replace_copy_if (Arageli::vector< T1, REFCNT1 > &a, Arageli::vector< T2, REFCNT2 > &b, Fu f, const T3 &newv)
template<typename T1, bool REFCNT1, typename T2>
void	std::fill (Arageli::vector< T1, REFCNT1 > &a, const T2 &v)
template<typename T1, bool REFCNT1, typename Fn>
void	std::generate (Arageli::vector< T1, REFCNT1 > &a, Fn f)
template<typename T1, bool REFCNT1, typename T2>
Arageli::vector< T1, REFCNT1 >::iterator	std::remove (Arageli::vector< T1, REFCNT1 > &a, const T2 &v)
template<typename T1, bool REFCNT1, typename Fu>
Arageli::vector< T1, REFCNT1 >::iterator	std::remove_if (Arageli::vector< T1, REFCNT1 > &a, Fu f)
template<typename T1, bool REFCNT1, typename T2, typename Out>
Out	std::remove_copy (const Arageli::vector< T1, REFCNT1 > &a, Out out, const T2 &v)
template<typename T1, bool REFCNT1, typename Fu, typename Out>
Out	std::remove_copy (const Arageli::vector< T1, REFCNT1 > &a, Out out, Fu f)
template<typename T1, bool REFCNT1>
Arageli::vector< T1, REFCNT1 >::iterator	std::unique (Arageli::vector< T1, REFCNT1 > &a)
template<typename T1, bool REFCNT1, typename Fb>
Arageli::vector< T1, REFCNT1 >::iterator	std::unique (Arageli::vector< T1, REFCNT1 > &a, Fb f)
template<typename T1, bool REFCNT1, typename Out>
Out	std::unique_copy (const Arageli::vector< T1, REFCNT1 > &a, Out out)
template<typename T1, bool REFCNT1, typename Out, typename Fu>
Out	std::unique_copy (const Arageli::vector< T1, REFCNT1 > &a, Out out, Fu f)
template<typename T1, bool REFCNT1>
void	std::reverse (Arageli::vector< T1, REFCNT1 > &a)
template<typename T1, bool REFCNT1, typename Out>
Out	std::reverse_copy (const Arageli::vector< T1, REFCNT1 > &a, Out out)
template<typename T1, bool REFCNT1>
void	std::rotate (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::iterator middle)
template<typename T1, bool REFCNT1>
void	std::rotate (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::difference_type middle)
template<typename T1, bool REFCNT1, typename Out>
Out	std::rotate (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::iterator middle, Out out)
template<typename T1, bool REFCNT1, typename Out>
Out	std::rotate (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::difference_type middle, Out out)
template<typename T1, bool REFCNT1>
void	std::random_shuffle (Arageli::vector< T1, REFCNT1 > &a)
template<typename T1, bool REFCNT1, typename Rand>
void	std::random_shuffle (Arageli::vector< T1, REFCNT1 > &a, Rand r)
template<typename T1, bool REFCNT1, typename Fu>
Arageli::vector< T1, REFCNT1 >::iterator	std::partition (Arageli::vector< T1, REFCNT1 > &a, Fu f)
template<typename T1, bool REFCNT1, typename Fu>
Arageli::vector< T1, REFCNT1 >::iterator	std::stable_partition (Arageli::vector< T1, REFCNT1 > &a, Fu f)
template<typename T1, bool REFCNT1>
void	std::sort (Arageli::vector< T1, REFCNT1 > &a)
template<typename T1, bool REFCNT1, typename Cmp>
void	std::sort (Arageli::vector< T1, REFCNT1 > &a, Cmp cmp)
template<typename T1, bool REFCNT1>
void	std::stable_sort (Arageli::vector< T1, REFCNT1 > &a)
template<typename T1, bool REFCNT1, typename Cmp>
void	std::stable_sort (Arageli::vector< T1, REFCNT1 > &a, Cmp cmp)
template<typename T1, bool REFCNT1>
void	std::partial_sort (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::iterator middle)
template<typename T1, bool REFCNT1>
void	std::partial_sort (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::difference_type middle)
template<typename T1, bool REFCNT1, typename Cmp>
void	std::partial_sort (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::iterator middle, Cmp cmp)
template<typename T1, bool REFCNT1, typename Cmp>
void	std::partial_sort (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::difference_type middle, Cmp cmp)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
Arageli::vector< T2, REFCNT2 >::iterator	std::partial_sort_copy (const Arageli::vector< T1, REFCNT1 > &a, Arageli::vector< T2, REFCNT2 > &b)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Cmp>
Arageli::vector< T2, REFCNT2 >::iterator	std::partial_sort_copy (const Arageli::vector< T1, REFCNT1 > &a, Arageli::vector< T2, REFCNT2 > &b, Cmp cmp)
template<typename T1, bool REFCNT1>
void	std::nth_element (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::iterator nth)
template<typename T1, bool REFCNT1, typename Cmp>
void	std::nth_element (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::iterator nth, Cmp cmp)
template<typename T1, bool REFCNT1>
void	std::nth_element (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::difference_type nth)
template<typename T1, bool REFCNT1, typename Cmp>
void	std::nth_element (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::difference_type nth, Cmp cmp)
template<typename T1, bool REFCNT1, typename T2>
Arageli::vector< T1, REFCNT1 >::iterator	std::lower_bound (Arageli::vector< T1, REFCNT1 > &a, const T2 &v)
template<typename T1, bool REFCNT1, typename T2, typename Cmp>
Arageli::vector< T1, REFCNT1 >::iterator	std::lower_bound (Arageli::vector< T1, REFCNT1 > &a, const T2 &v, Cmp cmp)
template<typename T1, bool REFCNT1, typename T2>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::lower_bound (const Arageli::vector< T1, REFCNT1 > &a, const T2 &v)
template<typename T1, bool REFCNT1, typename T2, typename Cmp>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::lower_bound (const Arageli::vector< T1, REFCNT1 > &a, const T2 &v, Cmp cmp)
template<typename T1, bool REFCNT1, typename T2>
Arageli::vector< T1, REFCNT1 >::iterator	std::upper_bound (Arageli::vector< T1, REFCNT1 > &a, const T2 &v)
template<typename T1, bool REFCNT1, typename T2, typename Cmp>
Arageli::vector< T1, REFCNT1 >::iterator	std::upper_bound (Arageli::vector< T1, REFCNT1 > &a, const T2 &v, Cmp cmp)
template<typename T1, bool REFCNT1, typename T2>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::upper_bound (const Arageli::vector< T1, REFCNT1 > &a, const T2 &v)
template<typename T1, bool REFCNT1, typename T2, typename Cmp>
Arageli::vector< T1, REFCNT1 >::const_iterator	std::upper_bound (const Arageli::vector< T1, REFCNT1 > &a, const T2 &v, Cmp cmp)
template<typename T1, bool REFCNT1, typename T2>
pair< typename Arageli::vector< T1, REFCNT1 >::iterator, typename Arageli::vector< T1, REFCNT1 >::iterator >	std::equal_range (Arageli::vector< T1, REFCNT1 > &a, const T2 &v)
template<typename T1, bool REFCNT1, typename T2, typename Cmp>
pair< typename Arageli::vector< T1, REFCNT1 >::iterator, typename Arageli::vector< T1, REFCNT1 >::iterator >	std::equal_range (Arageli::vector< T1, REFCNT1 > &a, const T2 &v, Cmp cmp)
template<typename T1, bool REFCNT1, typename T2>
pair< typename Arageli::vector< T1, REFCNT1 >::const_iterator, typename Arageli::vector< T1, REFCNT1 >::const_iterator >	std::equal_range (const Arageli::vector< T1, REFCNT1 > &a, const T2 &v)
template<typename T1, bool REFCNT1, typename T2, typename Cmp>
pair< typename Arageli::vector< T1, REFCNT1 >::const_iterator, typename Arageli::vector< T1, REFCNT1 >::const_iterator >	std::equal_range (const Arageli::vector< T1, REFCNT1 > &a, const T2 &v, Cmp cmp)
template<typename T, bool REFCNT, typename T1>
bool	std::binary_search (const Arageli::vector< T, REFCNT > &x, const T1 &val)
template<typename T, bool REFCNT, typename T1, typename Cmp>
bool	std::binary_search (const Arageli::vector< T, REFCNT > &x, const T1 &val, Cmp cmp)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Out>
Out	std::merge (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Out out)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename Out, typename Cmp>
Out	std::merge (const Arageli::vector< T1, REFCNT1 > &a, const Arageli::vector< T2, REFCNT2 > &b, Out out, Cmp cmp)
template<typename T1, bool REFCNT1, typename Out>
Out	std::inplace_merge (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::iterator middle)
template<typename T1, bool REFCNT1, typename Out, typename Cmp>
Out	std::inplace_merge (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::iterator middle, Cmp cmp)
template<typename T1, bool REFCNT1, typename Out>
Out	std::inplace_merge (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::difference_type middle)
template<typename T1, bool REFCNT1, typename Out, typename Cmp>
Out	std::inplace_merge (Arageli::vector< T1, REFCNT1 > &a, typename Arageli::vector< T1, REFCNT1 >::difference_type middle, Cmp cmp)
Defines
#define	_ARAGELI_VECTOR_RIGHT_OPER(MNEM)
#define	ARAGELI_VECTOR_MATH_FUNCS1_DECL(NAME)
#define	ARAGELI_VECTOR_STD_MATH_FUNCS1(NAME)
#define	ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_VECTOR
Functions
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_plus (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_minus (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_multiplies (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_divides (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_modulus (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_bitwise_or (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_bitwise_and (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_bitwise_xor (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_shift_left (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, typename T2, bool REFCNT2>
vector< T2, REFCNT2 > &	Arageli::left_assign_shift_right (const T1 &x, vector< T2, REFCNT2 > &y)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T1_factory>
T1	Arageli::dotprod (const vector< T1, REFCNT1 > &a, const vector< T2, REFCNT2 > &b, const T1_factory &t1fctr)
	Dot product (scalar product) of two vectors.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
T1	Arageli::dotprod (const vector< T1, REFCNT1 > &a, const vector< T2, REFCNT2 > &b)
	Dot product (scalar product) of two vectors.
template<typename T, bool REFCNT, typename T2, typename T2_factory>
T2 &	Arageli::product (const vector< T, REFCNT > &x, T2 &res, const T2_factory &t2fctr)
	Multiplies all elements of vector.
template<typename T, bool REFCNT, typename T2, typename T2_factory>
T2 &	Arageli::sum (const vector< T, REFCNT > &x, T2 &res, const T2_factory &t2fctr)
	Sums all elements of vector.
template<typename T, bool REFCNT, typename T2>
T2 &	Arageli::product (const vector< T, REFCNT > &x, T2 &res)
	Multiplies all elements of vector.
template<typename T, bool REFCNT, typename T2>
T2 &	Arageli::sum (const vector< T, REFCNT > &x, T2 &res)
	Sums all elements of vector.
template<typename T, bool REFCNT>
T	Arageli::product (const vector< T, REFCNT > &x)
	Multiplies all elements of vector.
template<typename T, bool REFCNT>
T	Arageli::sum (const vector< T, REFCNT > &x)
	Sums all elements of vector.
template<typename Out, typename T, bool REFCNT>
Out &	Arageli::output_list (Out &out, const vector< T, REFCNT > &x, const char *first_bracket=vector_output_list_first_bracket_default, const char *second_bracket=vector_output_list_second_bracket_default, const char *separator=vector_output_list_separator_default)
	Simple output of the vector.
template<typename In, typename T, bool REFCNT>
In &	Arageli::input_list (In &in, vector< T, REFCNT > &x, const char *first_bracket=vector_input_list_first_bracket_default, const char *second_bracket=vector_input_list_second_bracket_default, const char *separator=vector_input_list_separator_default, const char *range=vector_input_list_range_default)
	Simple input of the vector.
template<typename T, bool REFCNT>
std::ostream &	Arageli::output_aligned (std::ostream &out, const vector< T, REFCNT > &x, const char *left_col=vector_output_aligned_left_col_default, const char *right_col=vector_output_aligned_right_col_default)
	Aligned output of the vector.
template<typename T, bool REFCNT>
std::ostream &	Arageli::vector_output_row (std::ostream &out, const vector< T, REFCNT > &x)
	Prints vector as a row-vector.
template<typename T, bool REFCNT>
std::ostream &	Arageli::vector_output_col (std::ostream &out, const vector< T, REFCNT > &x)
	Prints vector as a column-vector.
template<typename T, bool REFCNT>
std::ostream &	Arageli::operator<< (std::ostream &out, const vector< T, REFCNT > &x)
	Standard output routine (default type of outputting) for the vector.
template<typename T, bool REFCNT>
std::istream &	Arageli::operator>> (std::istream &in, vector< T, REFCNT > &x)
	Standard input routine (default type of inputting) for the vector.
template<typename T, bool REFCNT>
std::ofstream &	Arageli::operator<< (std::ofstream &out, const vector< T, REFCNT > &x)
	WARNING! TEMPORARY!.
template<typename T, bool REFCNT>
std::ifstream &	Arageli::operator>> (std::ifstream &in, vector< T, REFCNT > &x)
	WARNING! TEMPORARY!.
template<typename T, bool REFCNT>
std::ostringstream &	Arageli::operator<< (std::ostringstream &out, const vector< T, REFCNT > &x)
	WARNING! TEMPORARY!.
template<typename T, bool REFCNT>
std::istringstream &	Arageli::operator>> (std::istringstream &in, vector< T, REFCNT > &x)
	WARNING! TEMPORARY!.
template<typename T, bool REFCNT>
vector< T, REFCNT >	Arageli::opposite (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, REFCNT > &	Arageli::opposite (const vector< T, REFCNT > &x, vector< T, REFCNT > *y)
template<typename T, bool REFCNT>
vector< T, REFCNT > &	Arageli::opposite (vector< T, REFCNT > *x)
template<typename T, bool REFCNT>
vector< T, REFCNT >	Arageli::inverse (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
vector< T, REFCNT > &	Arageli::inverse (const vector< T, REFCNT > &x, vector< T, REFCNT > *y)
template<typename T, bool REFCNT>
vector< T, REFCNT > &	Arageli::inverse (vector< T, REFCNT > *x)
template<typename T, bool REFCNT>
bool	Arageli::is_unit (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
bool	Arageli::is_opposite_unit (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
bool	Arageli::is_null (const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream &	Arageli::output_polynom_first (std::ostream &out, const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream &	Arageli::output_polynom_internal (std::ostream &out, const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::ostream &	Arageli::output_pow (std::ostream &out, const vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream &	Arageli::input_polynom_first (std::istream &in, vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream &	Arageli::input_polynom_internal (std::istream &in, vector< T, REFCNT > &x)
template<typename T, bool REFCNT>
std::istream &	Arageli::input_pow (std::istream &in, vector< T, REFCNT > &x)
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2, typename T3, bool REFCNT3>
void	Arageli::fill_subvector (const vector< T1, REFCNT1 > &orig, const vector< T2, REFCNT2 > &indexes, vector< T3, REFCNT3 > &res)
	Makes subvector from another vector and index vector.
template<typename T1, bool REFCNT1, typename T2, bool REFCNT2>
void	std::swap (Arageli::vector< T1, REFCNT1 > &a, Arageli::vector< T2, REFCNT2 > &b)
	Swaps two vectors without actully copying (if possible).
template<typename T1, bool REFCNT1>
void	std::swap (Arageli::vector< T1, REFCNT1 > &a, Arageli::vector< T1, REFCNT1 > &b)
	Swaps two vectors without actully copying (if possible).
Variables
const fromseq_t	Arageli::fromseq = fromseq_t()
const fromval_t	Arageli::fromval = fromval_t()
const fromvec_t	Arageli::fromvec = fromvec_t()
const fromsize_t	Arageli::fromsize = fromsize_t()
const fromstr_t	Arageli::fromstr = fromstr_t()

---

Detailed Description

Template class vector definition and relative operations. This file contains template class vector, relative nonmember functions and a specialization of type_traits common template for the vector class.

This file contains only declarations of all noninline operations. Implementation of other operations see in vector.cpp file.

Indexes of entries in a vector begin from zero.

Definition in file vector.hpp.

---

Define Documentation

#define _ARAGELI_VECTOR_ASSIGN_FUNC	(	MNEM,
		OPER		)

Definition at line 797 of file vector.hpp.

#define _ARAGELI_VECTOR_RIGHT_OPER

(

MNEM

)

Value:

template <typename T1, typename T2, bool REFCNT2>   \
    inline vector<T2, REFCNT2>& left_assign_##MNEM      \
    (const T1& x, vector<T2, REFCNT2>& y)               \
    { return y.left_assign_##MNEM(x); }

Definition at line 1259 of file vector.hpp.

#define ARAGELI_INCLUDE_CPP_WITH_EXPORT_TEMPLATE_VECTOR

Definition at line 3694 of file vector.hpp.

#define ARAGELI_VECTOR_MATH_FUNCS1_DECL

(

NAME

)

Value:

template <typename T, bool REFCNT>                  \
    vector<T, true> NAME (const vector<T, REFCNT>& x);

Definition at line 2301 of file vector.hpp.

#define ARAGELI_VECTOR_STD_MATH_FUNCS1

(

NAME

)

Value:

template <typename T, bool REFCNT>          \
    inline Arageli::vector<T, true> NAME        \
    (const Arageli::vector<T, REFCNT>& x)       \
    { return Arageli::NAME(x); }

Definition at line 2358 of file vector.hpp.

---