MATRIX::VtVector Class Reference

#include <VtVector.hh>

Public Member Functions
— Constructors —
	VtVector (const unsigned int size)
	VtVector (double v1, double v2)
	VtVector (double v1, double v2, double v3)
	VtVector (double v1, double v2, double v3, double v4)
	VtVector (double v1, double v2, double v3, double v4, double v5)
	VtVector (double v1, double v2, double v3, double v4, double v5, double v6)
	VtVector (const VtVector &rhs)
	~VtVector ()
— Operators —
double	operator[] (unsigned int row) const
double &	operator[] (const unsigned int row)
double	operator() (unsigned int row) const
double &	operator() (const unsigned int row)
const VtVector &	operator= (const VtVector &rhs)
	$\vec{v} = \vec{w}$ More...
const VtVector &	operator+= (const double rhs)
	$\vec{v} = (v_\mu + \alpha)$ More...
const VtVector &	operator-= (const double rhs)
	$\vec{v} = (v_\mu - \alpha)$ More...
const VtVector &	operator*= (const double rhs)
	$\vec{v} = (v_\mu \cdot \alpha)$ More...
const VtVector &	operator/= (const double rhs)
	$\vec{v} = (v_\mu / \alpha)$ More...
const VtVector &	operator+= (const VtVector &rhs)
	$\vec{v} = (v_\mu + w_\mu)$ More...
const VtVector &	operator-= (const VtVector &rhs)
	$\vec{v} = (v_\mu - w_\mu)$ More...
const VtVector	operator+ (const VtVector &rhs) const
	$\vec{v} + \vec{w}$ More...
const VtVector	operator- (const VtVector &rhs) const
	$\vec{v} - \vec{w}$ More...
const double	operator* (const VtVector &rhs) const
	$\vec{v} * \vec{w} = \sum_\mu v_\mu \cdot w_\mu$ More...
VtVector	operator* (const double rhs) const
	$\vec{v} = (v_\mu \cdot \alpha)$ More...
— Access methods —
unsigned int	size () const
	vector dimension More...
unsigned int	nrow () const
	vector dimension More...
double	mag2 () const
	$\sum_i v_i^2$ More...
double	mag () const
	$\sqrt{\sum_i v_i^2}$ vector length More...
VtVector	unit () const
	return a unit vector More...

— Expert functions —
unsigned int	v_size
double *	v
void	print (std::ostream &os) const
	called by cout More...
void	place_at (const VtVector &rhs, const unsigned int row)
	copy a smaller vector at a certain place More...
void	copy (const VtVector &rhs, const unsigned int offset)
	to be used if vector dimensions differ More...
void	clear (void)
	set vector elements to 0 More...

Detailed Description

Vector class

Constructor & Destructor Documentation

VtVector() [1/7]

MATRIX::VtVector::VtVector

(

const unsigned int

size

)

                                           :
    v_size(rows),
    v(new double[size()]) {
    memset(v, 0, size() * sizeof(double));
  }

VtVector() [2/7]

MATRIX::VtVector::VtVector	(	double	v1,
		double	v2
	)

                                        :
    v_size(2), v(new double[2]) {
    v[0] = v1;
    v[1] = v2;
  }

VtVector() [3/7]

MATRIX::VtVector::VtVector	(	double	v1,
		double	v2,
		double	v3
	)

                                                   :
    v_size(3), v(new double[3]) {
    v[0] = v1;
    v[1] = v2;
    v[2] = v3;
  }

VtVector() [4/7]

MATRIX::VtVector::VtVector	(	double	v1,
		double	v2,
		double	v3,
		double	v4
	)

                                                              :
    v_size(4), v(new double[4]) {
    v[0] = v1;
    v[1] = v2;
    v[2] = v3;
    v[3] = v4;
  }

VtVector() [5/7]

MATRIX::VtVector::VtVector	(	double	v1,
		double	v2,
		double	v3,
		double	v4,
		double	v5
	)

                                                                         :
    v_size(5), v(new double[5]) {
    v[0] = v1;
    v[1] = v2;
    v[2] = v3;
    v[3] = v4;
    v[4] = v5;
  }

VtVector() [6/7]

MATRIX::VtVector::VtVector	(	double	v1,
		double	v2,
		double	v3,
		double	v4,
		double	v5,
		double	v6
	)

                                  :
    v_size(6), v(new double[6]) {
    v[0] = v1;
    v[1] = v2;
    v[2] = v3;
    v[3] = v4;
    v[4] = v5;
    v[5] = v6;
  }

VtVector() [7/7]

MATRIX::VtVector::VtVector

(

const VtVector &

rhs

)

                                       :
    v_size(rhs.size()),
    v(new double[size()]) {
    memcpy(v, rhs.v, size() * sizeof(double));
  }

~VtVector()

MATRIX::VtVector::~VtVector

(

)

                      {
    //    pthread_mutex_lock(&VTmutex);
    delete[] v;
    //    pthread_mutex_unlock(&VTmutex);
  }

Member Function Documentation

clear()

void MATRIX::VtVector::clear

(

void

)

set vector elements to 0

                       {
    memset(v, 0, v_size * sizeof(double));
    return;
  }

copy()

void MATRIX::VtVector::copy	(	const VtVector &	rhs,
		const unsigned int	offset
	)

to be used if vector dimensions differ

                                                                    {
 
#ifndef VtFAST
    assert(offset <= rhs.nrow());
#endif
 
    const unsigned int rows = rhs.nrow() - offset;
    const unsigned int nrow = (v_size < rows) ? v_size : rows;
 
    memcpy(v, rhs.v+offset, nrow * sizeof(double));
 
    return;
  }

mag()

double MATRIX::VtVector::mag

(

)

const

$\sqrt{\sum_i v_i^2}$ vector length

mag2()

double MATRIX::VtVector::mag2

(

)

const

$\sum_i v_i^2$

                              {
    double sum=0;
    for(unsigned int i=0; i<size(); ++i)
      sum += v[i] * v[i];
    return sum;
  }

nrow()

unsigned int MATRIX::VtVector::nrow

(

)

const

vector dimension

operator()() [1/2]

double& MATRIX::VtVector::operator()

(

const unsigned int

row

)

operator()() [2/2]

double MATRIX::VtVector::operator()

(

unsigned int

row

)

const

operator*() [1/2]

VtVector MATRIX::VtVector::operator*

(

const double

rhs

)

const

$\vec{v} = (v_\mu \cdot \alpha)$

                                                     {
    VtVector tmp(*this);
    return tmp *= rhs;
  }

operator*() [2/2]

const double MATRIX::VtVector::operator*

(

const VtVector &

rhs

)

const

$\vec{v} * \vec{w} = \sum_\mu v_\mu \cdot w_\mu$

                                                            {
 
    assert(size() == rhs.size());
    
    double sum = 0.;
    for(unsigned int i=0; i<size(); ++i) {
      sum += *(v+i) * rhs[i];
    }
 
    return sum;
  }

operator*=()

const VtVector & MATRIX::VtVector::operator*=

(

const double

rhs

)

$\vec{v} = (v_\mu \cdot \alpha)$

                                                       {
    for(unsigned int i=0; i<size(); ++i) v[i] *= rhs;
    return *this;
  }

operator+()

const VtVector MATRIX::VtVector::operator+

(

const VtVector &

rhs

)

const

$\vec{v} + \vec{w}$

                                                              {
 
#ifndef VtFAST
    assert(size() == rhs.size());
#endif
    
//      VtVector tmp(size());
    
//      for(unsigned int i=0; i<size(); ++i) {
//        tmp[i] = *(v+i) + rhs[i];
//      }
 
    VtVector tmp(*this);
    return tmp += rhs;
  }

operator+=() [1/2]

const VtVector & MATRIX::VtVector::operator+=

(

const double

rhs

)

$\vec{v} = (v_\mu + \alpha)$

                                                       {
    for(unsigned int i=0; i<size(); ++i) v[i] += rhs;
    return *this;
  }

operator+=() [2/2]

const VtVector & MATRIX::VtVector::operator+=

(

const VtVector &

rhs

)

$\vec{v} = (v_\mu + w_\mu)$

                                                          {
 
#ifndef VtFAST
    assert(size() == rhs.size());
#endif
    
    for(unsigned int i=0; i<size(); ++i) v[i] += rhs.v[i];
    return *this;
  }

operator-()

const VtVector MATRIX::VtVector::operator-

(

const VtVector &

rhs

)

const

$\vec{v} - \vec{w}$

                                                              {
 
#ifndef VtFAST
    assert(size() == rhs.size());
#endif
    
//      VtVector tmp(size());
 
//      for(unsigned int i=0; i<size(); ++i) {
//        tmp[i] = *(v+i) - rhs[i];
//      }
 
    VtVector tmp(*this);
    return tmp -= rhs;
  }

operator-=() [1/2]

const VtVector & MATRIX::VtVector::operator-=

(

const double

rhs

)

$\vec{v} = (v_\mu - \alpha)$

                                                       {
    for(unsigned int i=0; i<size(); ++i) v[i] -= rhs;
    return *this;
  }

operator-=() [2/2]

const VtVector & MATRIX::VtVector::operator-=

(

const VtVector &

rhs

)

$\vec{v} = (v_\mu - w_\mu)$

                                                          {
 
#ifndef VtFAST
    assert(size() == rhs.size());
#endif
 
    for(unsigned int i=0; i<size(); ++i) v[i] -= rhs.v[i];
    return *this;
  }

operator/=()

const VtVector & MATRIX::VtVector::operator/=

(

const double

rhs

)

$\vec{v} = (v_\mu / \alpha)$

                                                       {
    for(unsigned int i=0; i<size(); ++i) v[i] /= rhs;
    return *this;
  }

operator=()

const VtVector & MATRIX::VtVector::operator=

(

const VtVector &

rhs

)

$\vec{v} = \vec{w}$

                                                         {
    if(this == &rhs) return *this;
 
#ifndef VtFAST
    assert(size() == rhs.size());
#endif
 
    v_size = rhs.size();
 
    memcpy(v, rhs.v, size() * sizeof(double)); 
 
    return *this;
  }

operator[]() [1/2]

double& MATRIX::VtVector::operator[]

(

const unsigned int

row

)

operator[]() [2/2]

double MATRIX::VtVector::operator[]

(

unsigned int

row

)

const

place_at()

void MATRIX::VtVector::place_at	(	const VtVector &	rhs,
		const unsigned int	row
	)

copy a smaller vector at a certain place

                                      {
#ifndef VtFAST
    assert(nrow() >= rhs.nrow()+row);
#endif
 
    for(unsigned int i=0; i<rhs.nrow(); ++i) {
      operator()(i+row) = rhs(i);
    }
 
    return;
  }

print()

void MATRIX::VtVector::print

(

std::ostream &

os

)

const

called by cout

                                           {
    /* Fixed format needs 3 extra characters for field, while scientific needs 7 */
    int width;
    os << std::endl;
    if(os.flags() & std::ios::fixed)
      width = os.precision()+3;
    else
      width = os.precision()+7;
    for(unsigned int row = 0; row < nrow(); ++row) {
      os.width(width);
      os << operator()(row) << std::endl;
    }
    return;
  }

size()

unsigned int MATRIX::VtVector::size

(

)

const

vector dimension

unit()

VtVector MATRIX::VtVector::unit

(

)

const

return a unit vector

                                {
    VtVector tmp(*this);
    tmp /= tmp.mag();
    return tmp;
  }

Member Data Documentation

v

double* MATRIX::VtVector::v

private

v_size

unsigned int MATRIX::VtVector::v_size

private

---

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

• src/libVt++/vt++/include/VtVector.hh
• src/libVt++/vt++/VtVector.C