Vector Class (Templated) More...

#include <itpp/base/vec.h>

Public Types
typedef Num_T	value_type
	The type of the vector values.

Public Member Functions
	Vec (const Factory &f=DEFAULT_FACTORY)
	Default constructor. An element factory `f` can be specified.

	Vec (int size, const Factory &f=DEFAULT_FACTORY)
	Constructor with size parameter. An element factory `f` can be specified.

	Vec (const Vec< Num_T > &v)
	Copy constructor.

	Vec (const Vec< Num_T > &v, const Factory &f)
	Copy constructor, which takes an element factory `f` as an additional argument.

	Vec (const char *str, const Factory &f=DEFAULT_FACTORY)
	Constructor taking a char string as input. An element factory `f` can be specified.

	Vec (const std::string &str, const Factory &f=DEFAULT_FACTORY)
	Constructor taking a string as input. An element factory `f` can be specified.

	Vec (const Num_T *c_array, int size, const Factory &f=DEFAULT_FACTORY)
	Constructor taking a C-array as input. Copies all data. An element factory `f` can be specified.

	~Vec ()
	Destructor.

int	length () const
	The size of the vector.

int	size () const
	The size of the vector.

void	set_size (int size, bool copy=false)
	Set length of vector. if copy = true then keeping the old values.

void	set_length (int size, bool copy=false)
	Set length of vector. if copy = true then keeping the old values.

void	zeros ()
	Set the vector to the all zero vector.

void	clear ()
	Set the vector to the all zero vector.

void	ones ()
	Set the vector to the all one vector.

void	set (const char *str)
	Set the vector equal to the values in the `str` string.

void	set (const std::string &str)
	Set the vector equal to the values in the `str` string.

const Num_T &	operator[] (int i) const
	C-style index operator. First element is 0.

const Num_T &	operator() (int i) const
	Index operator. First element is 0.

Num_T &	operator[] (int i)
	C-style index operator. First element is 0.

Num_T &	operator() (int i)
	Index operator. First element is 0.

Vec< Num_T >	operator() (int i1, int i2) const
	Sub-vector with elements from `i1` to `i2`. Index -1 indicates the last element.

Vec< Num_T >	operator() (const Vec< int > &indexlist) const
	Sub-vector with elements given by the list of indices `indexlist`.

Vec< Num_T >	operator() (const Vec< bin > &binlist) const
	Sub-vector with elements with indexes where `binlist` is `1`.

const Num_T &	get (int i) const
	Accessor-style method. First element is 0.

Vec< Num_T >	get (int i1, int i2) const
	Get the elements from `i1` to `i2`. Index -1 indicates the last element.

Vec< Num_T >	get (const Vec< int > &indexlist) const
	Get the elements given by the list of indices `indexlist`.

Vec< Num_T >	get (const Vec< bin > &binlist) const
	Get the elements with indexes where `binlist` is `1`.

void	set (int i, Num_T t)
	Modifier-style method. First element is 0.

Mat< Num_T >	transpose () const
	Matrix transpose. Converts to a matrix with the vector in the first row.

Mat< Num_T >	T () const
	Matrix transpose. Converts to a matrix with the vector in the first row.

Mat< Num_T >	hermitian_transpose () const
	Hermitian matrix transpose. Converts to a matrix with the conjugate of the vector in the first row.

Mat< Num_T >	H () const
	Hermitian matrix transpose. Converts to a matrix with the conjugate of the vector in the first row.

Vec< Num_T > &	operator+= (const Vec< Num_T > &v)
	Addition of vector.

Vec< Num_T > &	operator+= (Num_T t)
	Addition of scalar.

Vec< Num_T > &	operator-= (const Vec< Num_T > &v)
	Subtraction of vector.

Vec< Num_T > &	operator-= (Num_T t)
	Subtraction of scalar.

Vec< Num_T > &	operator*= (Num_T t)
	Multiply with a scalar.

Vec< Num_T > &	operator/= (Num_T t)
	Elementwise division.

Vec< Num_T > &	operator/= (const Vec< Num_T > &v)
	Elementwise division.

Vec< Num_T >	right (int nr) const
	Get the right `nr` elements from the vector.

Vec< Num_T >	left (int nr) const
	Get the left `nr` elements from the vector.

Vec< Num_T >	mid (int start, int nr) const
	Get the middle part of vector from `start` including `nr` elements.

Vec< Num_T >	split (int pos)
	Split the vector into two parts at element `pos`.

void	shift_right (Num_T t, int n=1)
	Shift in element `t` at position 0 `n` times.

void	shift_right (const Vec< Num_T > &v)
	Shift in vector `v` at position 0.

void	shift_left (Num_T t, int n=1)
	Shift out the `n` left elements and at the same time shift in the element `t` at last position `n` times.

void	shift_left (const Vec< Num_T > &v)
	Shift in vector `v` at last positions.

void	set_subvector (int i1, int i2, const Vec< Num_T > &v)
	This function is deprecated. Please use set_subvector(i, v) instead.

void	set_subvector (int i, const Vec< Num_T > &v)
	Set subvector to elements of vector `v` starting from element `i`.

void	set_subvector (int i1, int i2, Num_T t)
	Set subvector defined by indices `i1` and `i2` to `t`.

void	replace_mid (int i, const Vec< Num_T > &v)
	An alias function of set_subvector(i, &v)

void	del (int i)
	Delete element number `i`.

void	del (int i1, int i2)
	Delete elements from `i1` to `i2`.

void	ins (int i, Num_T t)
	Insert element `t` before element with index `i` (0 <= i <= datasize)

void	ins (int i, const Vec< Num_T > &v)
	Insert vector `v` before element with index `i` (0 <= i <= datasize)

Vec< Num_T > &	operator= (Num_T t)
	Assign all elements in vector to `t`.

Vec< Num_T > &	operator= (const Vec< Num_T > &v)
	Assign vector the value and length of `v`.

Vec< Num_T > &	operator= (const Mat< Num_T > &m)
	Assign vector equal to the 1-dimensional matrix `m`.

Vec< Num_T > &	operator= (const char *str)
	Assign vector the values in the string `str`.

Vec< Num_T > &	operator= (const std::string &str)
	Assign vector the values in the string `str`.

Vec< bin >	operator== (Num_T t) const
	Elementwise equal to the scalar `t`.

Vec< bin >	operator!= (Num_T t) const
	Elementwise not-equal to the scalar `t`.

Vec< bin >	operator< (Num_T t) const
	Elementwise less than the scalar `t`.

Vec< bin >	operator<= (Num_T t) const
	Elementwise less than and equal to the scalar `t`.

Vec< bin >	operator> (Num_T t) const
	Elementwise greater than the scalar `t`.

Vec< bin >	operator>= (Num_T t) const
	Elementwise greater than and equal to the scalar `t`.

bool	operator== (const Vec< Num_T > &v) const
	Compare with vector `v`. Return false if sizes or values differ.

bool	operator!= (const Vec< Num_T > &v) const
	Compare with vector `v`. Return true if sizes or values differ.

Num_T &	_elem (int i)
	Index operator without boundary check. Not recommended for use.

const Num_T &	_elem (int i) const
	Index operator without boundary check. Not recommended for use.

Num_T *	_data ()
	Get the pointer to the internal structure. Not recommended for use.

const Num_T *	_data () const
	Get the pointer to the internal structure. Not recommended for use.

Protected Member Functions
void	alloc (int size)
	Allocate storage for a vector of length `size`.

void	free ()
	Free the storage space allocated by the vector.

Protected Attributes
int	datasize
	The current number of elements in the vector.

Num_T *	data
	A pointer to the data area.

const Factory &	factory
	Element factory (set to DEFAULT_FACTORY to use Num_T default constructors only)

Friends
Vec< Num_T >	operator+ (const Vec< Num_T > &v1, const Vec< Num_T > &v2)
	Addition of two vectors.

Vec< Num_T >	operator+ (const Vec< Num_T > &v, Num_T t)
	Addition of a vector and a scalar.

Vec< Num_T >	operator+ (Num_T t, const Vec< Num_T > &v)
	Addition of a scalar and a vector.

Vec< Num_T >	operator- (const Vec< Num_T > &v1, const Vec< Num_T > &v2)
	Subtraction of `v2` from `v1`.

Vec< Num_T >	operator- (const Vec< Num_T > &v, Num_T t)
	Subtraction of scalar from vector.

Vec< Num_T >	operator- (Num_T t, const Vec< Num_T > &v)
	Subtraction of vector from scalar.

Vec< Num_T >	operator- (const Vec< Num_T > &v)
	Negation of vector.

Vec< Num_T >	operator* (const Vec< Num_T > &v, Num_T t)
	Elementwise multiplication of vector and scalar.

Vec< Num_T >	operator* (Num_T t, const Vec< Num_T > &v)
	Elementwise multiplication of vector and scalar.

Vec< Num_T >	elem_mult (const Vec< Num_T > &a, const Vec< Num_T > &b)
	Elementwise multiplication.

Vec< Num_T >	elem_mult (const Vec< Num_T > &a, const Vec< Num_T > &b, const Vec< Num_T > &c)
	Elementwise multiplication of three vectors.

Vec< Num_T >	elem_mult (const Vec< Num_T > &a, const Vec< Num_T > &b, const Vec< Num_T > &c, const Vec< Num_T > &d)
	Elementwise multiplication of four vectors.

void	elem_mult_out (const Vec< Num_T > &a, const Vec< Num_T > &b, Vec< Num_T > &out)
	Elementwise multiplication, storing the result in vector `out`.

void	elem_mult_out (const Vec< Num_T > &a, const Vec< Num_T > &b, const Vec< Num_T > &c, Vec< Num_T > &out)
	Elementwise multiplication of three vectors, storing the result in vector `out`.

void	elem_mult_out (const Vec< Num_T > &a, const Vec< Num_T > &b, const Vec< Num_T > &c, const Vec< Num_T > &d, Vec< Num_T > &out)
	Elementwise multiplication of four vectors, storing the result in vector `out`.

void	elem_mult_inplace (const Vec< Num_T > &a, Vec< Num_T > &b)
	In-place element-wise multiplication of two vectors. Fast version of b = elem_mult(a,b).

Num_T	elem_mult_sum (const Vec< Num_T > &a, const Vec< Num_T > &b)
	Element-wise multiplication of two vectors, followed by summation of the resultant elements. Fast version of sum(elem_mult(a,b))

Vec< Num_T >	operator/ (const Vec< Num_T > &v, Num_T t)
	Elementwise division.

Vec< Num_T >	operator/ (Num_T t, const Vec< Num_T > &v)
	Elementwise division.

Vec< Num_T >	elem_div (const Vec< Num_T > &v1, const Vec< Num_T > &v2)
	Elementwise division.

Vec< Num_T >	elem_div (Num_T t, const Vec< Num_T > &v)
	This function is deprecated. Please use operator/(Num_T, const Vec<Num_T> &) instead.

void	elem_div_out (const Vec< Num_T > &v1, const Vec< Num_T > &v2, Vec< Num_T > &out)
	Elementwise division.

Num_T	elem_div_sum (const Vec< Num_T > &a, const Vec< Num_T > &b)
	Elementwise division, followed by summation of the resultant elements. Fast version of sum(elem_mult(a,b))

Vec< Num_T >	concat (const Vec< Num_T > &v, Num_T t)
	Append element `t` to the end of the vector `v`.

Vec< Num_T >	concat (Num_T t, const Vec< Num_T > &v)
	Insert element `t` at the beginning of the vector `v`.

Vec< Num_T >	concat (const Vec< Num_T > &v1, const Vec< Num_T > &v2)
	Concatenate vectors `v1` and `v2`.

Vec< Num_T >	concat (const Vec< Num_T > &v1, const Vec< Num_T > &v2, const Vec< Num_T > &v3)
	Concatenate vectors `v1`, `v2` and `v3`.

Vec< Num_T >	concat (const Vec< Num_T > &v1, const Vec< Num_T > &v2, const Vec< Num_T > &v3, const Vec< Num_T > &v4)
	Concatenate vectors `v1`, `v2`, `v3` and `v4`.

Vec< Num_T >	concat (const Vec< Num_T > &v1, const Vec< Num_T > &v2, const Vec< Num_T > &v3, const Vec< Num_T > &v4, const Vec< Num_T > &v5)
	Concatenate vectors `v1`, `v2`, `v3`, `v4` and `v5`.

Detailed Description

template<class Num_T>
class itpp::Vec< Num_T >

Vector Class (Templated)

Author: Tony Ottosson, Tobias Ringstrom, Adam Piatyszek and Conrad Sanderson

Vectors can be of arbitrary types, but conversions and functions are prepared for bin, short, int, double, and complex<double> vectors and these are predefined as: bvec, svec, ivec, vec, and cvec. double and complex<double> are double and complex<double> respectively.

Examples:

Vector Constructors: When constructing a vector without a length (memory) use

vec temp;

For construction of a vector of a given length use

vec temp(length);

It is also possible to assign the constructed vector the value and size of another vector by

vec temp(invector);

If you have explicit values you would like to assign to the vector it is possible to do this using strings as:

vec a("0 0.7 5 9.3"); // that is a = [0, 0.7, 5, 9.3]
vec a="0 0.7 5 9.3";  // the constructor is called implicitly
ivec b="0:5";  // that is, b = [0, 1, 2, 3, 4, 5]
vec c="3:2.5:13";  // that is, c = [3, 5.5, 8, 10.5, 13]

It is also possible to change length by

temp.set_size(new_length, false);

where false is used to indicate that the old values in temp are not copied. If you would like to preserve the values, use true.

There are a number of methods to access parts of a vector. Examples are

a(5);     // Element number 5
a(5,9);  // Elements 5, 6, 7, 8, and 9
a.left(10);  // The 10 leftmost elements (the first)
a.right(10); // The 10 rightmost elements (the last)
a.mid(5, 7); // 7 elements starting from element 5

It is also possible to modify parts of a vector, as in e.g.

a.del(5);    // deletes element number 5
a.ins(3.4, 9); // inserts the element 3.4 at position 9
a.set_subvector(12, b); // replaces elements from 12 with the vector b

It is, of course, also possible to perform common linear algebra operations, such as addition, subtraction, and scalar product (*). Observe though, that vectors are assumed to be column-vectors in operations with matrices.

Most elementary functions such as sin(), cosh(), log(), abs(), ..., are also available as operations on the individual elements of the vectors. Please see the individual functions for more details.

By default, the Vec elements are created using the default constructor for the element type. This can be changed by specifying a suitable Factory in the Vec constructor call; see Detailed Description for Factory.

Definition at line 244 of file vec.h.

Member Function Documentation

template<class Num_T >

Vec< Num_T > Vec< Num_T >::split ( int pos )

Split the vector into two parts at element pos.

Return the first part containing elements 0 to pos-1, and keep the second part containing the remaining elements starting from pos (empty vector if pos is equal to the length of the vector).

Definition at line 1262 of file vec.h.

References itpp::Vec< Num_T >::data, and it_assert_debug.

The documentation for this class was generated from the following files:

itpp/base/vec.h
itpp/fixed/cfix.cpp
itpp/fixed/cfix.h
itpp/fixed/fix.cpp
itpp/fixed/fix.h

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Friends

Detailed Description

template<class Num_T> class itpp::Vec< Num_T >

Member Function Documentation

template<class Num_T>
class itpp::Vec< Num_T >