Vector Class Reference

Standard class for every vector in Carmen. More...

#include <Vector.h>

Public Member Functions
	Vector ()
	Generates a 1D vector equal to zero. More...
	Vector (const int n)
	Generates a vector of dimension n, each component being equal to zero. More...
	Vector (const real x, const real y)
	Generates the 2D vector (x,y). More...
	Vector (const real x, const real y, const real z)
	Generates the 3D vector (x,y,z). More...
	Vector (const Vector &V)
	.Generates a copy of the vector V. More...
	~Vector ()
	Destructor of Vector Class. More...
void	setValue (const int n, const real a)
	Sets the component n to value a. More...
void	setZero ()
	Sets all the components to zero. More...
void	setDimension (const int n)
	Sets the dimension of the vector to n and reset values to zero. More...
real	value (const int n) const
	Returns the value of the component n. More...
int	dimension () const
	Returns the dimension of the vector. More...
bool	operator== (const Vector &V) const
	Compares the current vector to a vector V and returns true if they are equal. More...
void	operator= (const Vector &V)
	Set the current vector to the dimension and the value of V. More...
void	operator+= (const Vector &V)
	Adds V to the current vector. More...
Vector	operator+ (const Vector &V) const
	Returns the addition of the current vector and V. More...
void	operator-= (const Vector &V)
	Subtracts V to the current vector. More...
Vector	operator- (const Vector &V) const
	Returns the difference between the current vector and V. More...
Vector	operator- () const
	Returns the opposite of the current vector. More...
void	operator*= (const real a)
	Multiplies the current vector by a real a. More...
Vector	operator* (const real a) const
	Returns the product of the current vector and a real a. More...
void	operator/= (const real a)
	Divides the current vector by a real a. More...
Vector	operator/ (const real a) const
	Returns the division of the current vector by a real a. More...
real	operator* (const Vector &V) const
	Returns the dot product of the current vector and V. More...
Vector	operator| (const Vector &V) const
	Returns the term-by-term product of the current vector and V. More...
Vector	operator^ (const Vector &V) const
	Returns the vectorial product of the current vector and V. More...
bool	isNaN () const
	Returns true if one of the components of the current vector is not a number. More...

Public Attributes
int	Columns
real	U [9]

Detailed Description

Standard class for every vector in Carmen.

It contains the following data:

• the dimension of the vector Columns ;
  
• the array of reals *U.

Constructor & Destructor Documentation

Vector::Vector

(

)

Generates a 1D vector equal to zero.

Example :

#include "Vector.h"

Vector V;

{
    Columns = 1;
    *U = 0.;
}

Vector::Vector

(

const int

n

)

Generates a vector of dimension n, each component being equal to zero.

Example :

#include "Vector.h"

Vector V(4);

Parameters

n

{
    Columns = n;

    // If the size of the vector is 0, do not allocate memory
    if (Columns == 0) return;

    if (Columns==9) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
      *(U+6)=0.;
      *(U+7)=0.;
      *(U+8)=0.;
    }
    else if (Columns==8) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
      *(U+6)=0.;
      *(U+7)=0.;
    }
    else if (Columns==7) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
      *(U+6)=0.;
    }
    else if (Columns==6) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
    }
    else if (Columns==5) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
    }
    else if (Columns==4) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
    }
    else if (Columns==3) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
    }
    else if (Columns==2) {
      *U=0.;
      *(U+1)=0.;
    }
    else if (Columns==1) {
      *U=0.;
    }
}

Vector::Vector	(	const real	x,
		const real	y
	)

Generates the 2D vector (x,y).

Example :

#include "Vector.h"

Vector V(0.,1.);

Parameters

x	Real value
y	Real value

{
    Columns = 2;
    *U        = x;
    *(U+1)    = y;
}

Vector::Vector	(	const real	x,
		const real	y,
		const real	z
	)

Generates the 3D vector (x,y,z).

Example :

#include "Vector.h"

Vector V(0.,1.,0.);

Parameters

x	Real value
y	Real value
z	Real value

{
    Columns = 3;
    *U        = x;
    *(U+1)    = y;
    *(U+2)    = z;
}

Vector::Vector

(

const Vector &

V

)

.Generates a copy of the vector V.

Example :

#include "Vector.h"

Vector V(0.,1.,0.);
Vector W(V);

Parameters

V

Vector

{
    Columns = V.dimension();
    if (Columns==9) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
      *(U+5) = V.value(6);
      *(U+6) = V.value(7);
      *(U+7) = V.value(8);
      *(U+8) = V.value(9);
    }
    else if (Columns==8) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
      *(U+5) = V.value(6);
      *(U+6) = V.value(7);
      *(U+7) = V.value(8);
    }
    else if (Columns==7) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
      *(U+5) = V.value(6);
      *(U+6) = V.value(7);
    }
    else if (Columns==6) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
      *(U+5) = V.value(6);
    }
    else if (Columns==5) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
    }
    else if (Columns==4) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
    }
    else if (Columns==3) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
    }
    else if (Columns==2) {
      *U = V.value(1);
      *(U+1) = V.value(2);
    }
    else if (Columns==1) {
      *U = V.value(1);
    }
}

Vector::~Vector

(

)

Destructor of Vector Class.

Deallocate memory of the vector.

{
    // If the size of the vector is equal to zero, do not deallocate memory
    if (Columns == 0) return;
}

Member Function Documentation

int Vector::dimension ( ) const

inline

Returns the dimension of the vector.

Returns

int

{
    return Columns;
}

Here is the caller graph for this function:

bool Vector::isNaN

(

)

const

Returns true if one of the components of the current vector is not a number.

Returns

bool

{
    int n;

  for (n = 1; n <= Columns; n++)

//On some machines should be math::isnan
#if defined SP_SMP
   if (::isnan(value(n)) )
#else
   if ( isnan(value(n)) )
#endif
    return true;

    return false;
}

Vector Vector::operator*

(

const real

a

)

const

Returns the product of the current vector and a real a.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
Vector W;
real x = 2.;
...
W = V*x;


The operation W = x*V can also be done. See operator*(const real a, const Vector& V).

Parameters

a	Real value

Returns

Vector

{
    Vector result(Columns);

    if (Columns==9) {
      result.setValue(1, value(1) *a);
      result.setValue(2, value(2) *a);
      result.setValue(3, value(3) *a);
      result.setValue(4, value(4) *a);
      result.setValue(5, value(5) *a);
      result.setValue(6, value(6) *a);
      result.setValue(7, value(7) *a);
      result.setValue(8, value(8) *a);
      result.setValue(9, value(9) *a);
    }
    else if (Columns==8) {
      result.setValue(1, value(1) *a);
      result.setValue(2, value(2) *a);
      result.setValue(3, value(3) *a);
      result.setValue(4, value(4) *a);
      result.setValue(5, value(5) *a);
      result.setValue(6, value(6) *a);
      result.setValue(7, value(7) *a);
      result.setValue(8, value(8) *a);
    }
    else if (Columns==7) {
      result.setValue(1, value(1) *a);
      result.setValue(2, value(2) *a);
      result.setValue(3, value(3) *a);
      result.setValue(4, value(4) *a);
      result.setValue(5, value(5) *a);
      result.setValue(6, value(6) *a);
      result.setValue(7, value(7) *a);
    }
    else if (Columns==6) {
      result.setValue(1, value(1) *a);
      result.setValue(2, value(2) *a);
      result.setValue(3, value(3) *a);
      result.setValue(4, value(4) *a);
      result.setValue(5, value(5) *a);
      result.setValue(6, value(6) *a);
    }
    else if (Columns==5) {
      result.setValue(1, value(1) *a);
      result.setValue(2, value(2) *a);
      result.setValue(3, value(3) *a);
      result.setValue(4, value(4) *a);
      result.setValue(5, value(5) *a);
    }
    else if (Columns==4) {
      result.setValue(1, value(1) *a);
      result.setValue(2, value(2) *a);
      result.setValue(3, value(3) *a);
      result.setValue(4, value(4) *a);
    }
    else if (Columns==3) {
      result.setValue(1, value(1) *a);
      result.setValue(2, value(2) *a);
      result.setValue(3, value(3) *a);
    }
    else if (Columns==2) {
      result.setValue(1, value(1) *a);
      result.setValue(2, value(2) *a);
    }
    else if (Columns==1) {
      result.setValue(1, value(1) *a);
    }
    return result;
}

real Vector::operator*

(

const Vector &

V

)

const

Returns the dot product of the current vector and V.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
Vector W(1., 2., 1.);
real x;
...
x = V*W;


Parameters

V

Vector

Returns

real

{
    real result = 0.;

#ifdef DEBUG
    if ( Columns != V.dimension())
    {
        cout << "Vector.cpp: In method `real Vector::operator*(Vector&)':\n";
        cout << "Vector.cpp: vectors have different dimensions\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    if (Columns==9) {
      result += *U * V.value(1);
      result += *(U+1) * V.value(2);
      result += *(U+2) * V.value(3);
      result += *(U+3) * V.value(4);
      result += *(U+4) * V.value(5);
      result += *(U+5) * V.value(6);
      result += *(U+6) * V.value(7);
      result += *(U+7) * V.value(8);
      result += *(U+8) * V.value(9);
    }
    else if (Columns==8) {
      result += *U * V.value(1);
      result += *(U+1) * V.value(2);
      result += *(U+2) * V.value(3);
      result += *(U+3) * V.value(4);
      result += *(U+4) * V.value(5);
      result += *(U+5) * V.value(6);
      result += *(U+6) * V.value(7);
      result += *(U+7) * V.value(8);
    }
    else if (Columns==7) {
      result += *U * V.value(1);
      result += *(U+1) * V.value(2);
      result += *(U+2) * V.value(3);
      result += *(U+3) * V.value(4);
      result += *(U+4) * V.value(5);
      result += *(U+5) * V.value(6);
      result += *(U+6) * V.value(7);
    }
    else if (Columns==6) {
      result += *U * V.value(1);
      result += *(U+1) * V.value(2);
      result += *(U+2) * V.value(3);
      result += *(U+3) * V.value(4);
      result += *(U+4) * V.value(5);
      result += *(U+5) * V.value(6);
    }
    else if (Columns==5) {
      result += *U * V.value(1);
      result += *(U+1) * V.value(2);
      result += *(U+2) * V.value(3);
      result += *(U+3) * V.value(4);
      result += *(U+4) * V.value(5);
    }
    else if (Columns==4) {
      result += *U * V.value(1);
      result += *(U+1) * V.value(2);
      result += *(U+2) * V.value(3);
      result += *(U+3) * V.value(4);
    }
    else if (Columns==3) {
      result += *U * V.value(1);
      result += *(U+1) * V.value(2);
      result += *(U+2) * V.value(3);
    }
    else if (Columns==2) {
      result += *U * V.value(1);
      result += *(U+1) * V.value(2);
    }
    else if (Columns==1) {
      result += *U * V.value(1);
    }

    return result;

}

void Vector::operator*=

(

const real

a

)

Multiplies the current vector by a real a.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
real x = 2.;
...
V *= x;


Parameters

a	Real value

Returns

void

{
    if (Columns==9) {
      *U *= a;
      *(U+1) *= a;
      *(U+2) *= a;
      *(U+3) *= a;
      *(U+4) *= a;
      *(U+5) *= a;
      *(U+6) *= a;
      *(U+7) *= a;
      *(U+8) *= a;
    }
    else if (Columns==8) {
      *U *= a;
      *(U+1) *= a;
      *(U+2) *= a;
      *(U+3) *= a;
      *(U+4) *= a;
      *(U+5) *= a;
      *(U+6) *= a;
      *(U+7) *= a;
    }
    else if (Columns==7) {
      *U *= a;
      *(U+1) *= a;
      *(U+2) *= a;
      *(U+3) *= a;
      *(U+4) *= a;
      *(U+5) *= a;
      *(U+6) *= a;
    }
    else if (Columns==6) {
      *U *= a;
      *(U+1) *= a;
      *(U+2) *= a;
      *(U+3) *= a;
      *(U+4) *= a;
      *(U+5) *= a;
    }
    else if (Columns==5) {
      *U *= a;
      *(U+1) *= a;
      *(U+2) *= a;
      *(U+3) *= a;
      *(U+4) *= a;
    }
    else if (Columns==4) {
      *U *= a;
      *(U+1) *= a;
      *(U+2) *= a;
      *(U+3) *= a;
    }
    else if (Columns==3) {
      *U *= a;
      *(U+1) *= a;
      *(U+2) *= a;
    }
    else if (Columns==2) {
      *U *= a;
      *(U+1) *= a;
    }
    else if (Columns==1) {
      *U *= a;
    }
}

Vector Vector::operator+

(

const Vector &

V

)

const

Returns the addition of the current vector and V.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
Vector W(0.,-1.,2.);
Vector U;
...
U = V + W;

Parameters

V

Vector

Returns

Vector

{
    Vector result(Columns);

#ifdef DEBUG
    if ( Columns != V.dimension())
    {
        cout << "Vector.cpp: In method `Vector& Vector::operator+(Vector&)':\n";
        cout << "Vector.cpp: vectors have different dimensions\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    if (Columns==9) {
      result.setValue(1, value(1) + V.value(1));
      result.setValue(2, value(2) + V.value(2));
      result.setValue(3, value(3) + V.value(3));
      result.setValue(4, value(4) + V.value(4));
      result.setValue(5, value(5) + V.value(5));
      result.setValue(6, value(6) + V.value(6));
      result.setValue(7, value(7) + V.value(7));
      result.setValue(8, value(8) + V.value(8));
      result.setValue(9, value(9) + V.value(9));
    }
    else if (Columns==8) {
      result.setValue(1, value(1) + V.value(1));
      result.setValue(2, value(2) + V.value(2));
      result.setValue(3, value(3) + V.value(3));
      result.setValue(4, value(4) + V.value(4));
      result.setValue(5, value(5) + V.value(5));
      result.setValue(6, value(6) + V.value(6));
      result.setValue(7, value(7) + V.value(7));
      result.setValue(8, value(8) + V.value(8));
    }
    else if (Columns==7) {
      result.setValue(1, value(1) + V.value(1));
      result.setValue(2, value(2) + V.value(2));
      result.setValue(3, value(3) + V.value(3));
      result.setValue(4, value(4) + V.value(4));
      result.setValue(5, value(5) + V.value(5));
      result.setValue(6, value(6) + V.value(6));
      result.setValue(7, value(7) + V.value(7));
    }
    else if (Columns==6) {
      result.setValue(1, value(1) + V.value(1));
      result.setValue(2, value(2) + V.value(2));
      result.setValue(3, value(3) + V.value(3));
      result.setValue(4, value(4) + V.value(4));
      result.setValue(5, value(5) + V.value(5));
      result.setValue(6, value(6) + V.value(6));
    }
    else if (Columns==5) {
      result.setValue(1, value(1) + V.value(1));
      result.setValue(2, value(2) + V.value(2));
      result.setValue(3, value(3) + V.value(3));
      result.setValue(4, value(4) + V.value(4));
      result.setValue(5, value(5) + V.value(5));
    }
    else if (Columns==4) {
      result.setValue(1, value(1) + V.value(1));
      result.setValue(2, value(2) + V.value(2));
      result.setValue(3, value(3) + V.value(3));
      result.setValue(4, value(4) + V.value(4));
    }
    else if (Columns==3) {
      result.setValue(1, value(1) + V.value(1));
      result.setValue(2, value(2) + V.value(2));
      result.setValue(3, value(3) + V.value(3));
    }
    else if (Columns==2) {
      result.setValue(1, value(1) + V.value(1));
      result.setValue(2, value(2) + V.value(2));
    }
    else if (Columns==1) {
      result.setValue(1, value(1) + V.value(1));
    }
    return result;

}

void Vector::operator+=

(

const Vector &

V

)

Adds V to the current vector.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
Vector W(0.,-1.,2.);
...
W += V;


Parameters

V

Vector

Returns

void

{
#ifdef DEBUG
    if ( Columns != V.dimension())
    {
        cout << "Vector.cpp: In method `void Vector::operator+=(Vector&)':\n";
        cout << "Vector.cpp: vectors have different dimensions\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    if (Columns==9) {
      *U += V.value(1);
      *(U+1) += V.value(2);
      *(U+2) += V.value(3);
      *(U+3) += V.value(4);
      *(U+4) += V.value(5);
      *(U+5) += V.value(6);
      *(U+6) += V.value(7);
      *(U+7) += V.value(8);
      *(U+8) += V.value(9);
    }
    else if (Columns==8) {
      *U += V.value(1);
      *(U+1) += V.value(2);
      *(U+2) += V.value(3);
      *(U+3) += V.value(4);
      *(U+4) += V.value(5);
      *(U+5) += V.value(6);
      *(U+6) += V.value(7);
      *(U+7) += V.value(8);
    }
    else if (Columns==7) {
      *U += V.value(1);
      *(U+1) += V.value(2);
      *(U+2) += V.value(3);
      *(U+3) += V.value(4);
      *(U+4) += V.value(5);
      *(U+5) += V.value(6);
      *(U+6) += V.value(7);
    }
    else if (Columns==6) {
      *U += V.value(1);
      *(U+1) += V.value(2);
      *(U+2) += V.value(3);
      *(U+3) += V.value(4);
      *(U+4) += V.value(5);
      *(U+5) += V.value(6);
    }
    else if (Columns==5) {
      *U += V.value(1);
      *(U+1) += V.value(2);
      *(U+2) += V.value(3);
      *(U+3) += V.value(4);
      *(U+4) += V.value(5);
    }
    else if (Columns==4) {
      *U += V.value(1);
      *(U+1) += V.value(2);
      *(U+2) += V.value(3);
      *(U+3) += V.value(4);
    }
    else if (Columns==3) {
      *U += V.value(1);
      *(U+1) += V.value(2);
      *(U+2) += V.value(3);
    }
    else if (Columns==2) {
      *U += V.value(1);
      *(U+1) += V.value(2);
    }
    else if (Columns==1) {
      *U += V.value(1);
    }
}

Vector Vector::operator-

(

const Vector &

V

)

const

Returns the difference between the current vector and V.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
Vector W(0.,-1.,2.);
Vector U;
...
U = V - W;


Parameters

V

Vector

Returns

Vector

{
    Vector result(Columns);

#ifdef DEBUG
    if ( Columns != V.dimension())
    {
        cout << "Vector.cpp: In method `Vector& Vector::operator-(Vector&)':\n";
        cout << "Vector.cpp: vectors have different dimensions\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    if (Columns==9) {
      result.setValue(1, value(1) - V.value(1));
      result.setValue(2, value(2) - V.value(2));
      result.setValue(3, value(3) - V.value(3));
      result.setValue(4, value(4) - V.value(4));
      result.setValue(5, value(5) - V.value(5));
      result.setValue(6, value(6) - V.value(6));
      result.setValue(7, value(7) - V.value(7));
      result.setValue(8, value(8) - V.value(8));
      result.setValue(9, value(9) - V.value(9));
    }
    else if (Columns==8) {
      result.setValue(1, value(1) - V.value(1));
      result.setValue(2, value(2) - V.value(2));
      result.setValue(3, value(3) - V.value(3));
      result.setValue(4, value(4) - V.value(4));
      result.setValue(5, value(5) - V.value(5));
      result.setValue(6, value(6) - V.value(6));
      result.setValue(7, value(7) - V.value(7));
      result.setValue(8, value(8) - V.value(8));
    }
    else if (Columns==7) {
      result.setValue(1, value(1) - V.value(1));
      result.setValue(2, value(2) - V.value(2));
      result.setValue(3, value(3) - V.value(3));
      result.setValue(4, value(4) - V.value(4));
      result.setValue(5, value(5) - V.value(5));
      result.setValue(6, value(6) - V.value(6));
      result.setValue(7, value(7) - V.value(7));
    }
    else if (Columns==6) {
      result.setValue(1, value(1) - V.value(1));
      result.setValue(2, value(2) - V.value(2));
      result.setValue(3, value(3) - V.value(3));
      result.setValue(4, value(4) - V.value(4));
      result.setValue(5, value(5) - V.value(5));
      result.setValue(6, value(6) - V.value(6));
    }
    else if (Columns==5) {
      result.setValue(1, value(1) - V.value(1));
      result.setValue(2, value(2) - V.value(2));
      result.setValue(3, value(3) - V.value(3));
      result.setValue(4, value(4) - V.value(4));
      result.setValue(5, value(5) - V.value(5));
    }
    else if (Columns==4) {
      result.setValue(1, value(1) - V.value(1));
      result.setValue(2, value(2) - V.value(2));
      result.setValue(3, value(3) - V.value(3));
      result.setValue(4, value(4) - V.value(4));
    }
    else if (Columns==3) {
      result.setValue(1, value(1) - V.value(1));
      result.setValue(2, value(2) - V.value(2));
      result.setValue(3, value(3) - V.value(3));
    }
    else if (Columns==2) {
      result.setValue(1, value(1) - V.value(1));
      result.setValue(2, value(2) - V.value(2));
    }
    else if (Columns==1) {
      result.setValue(1, value(1) - V.value(1));
    }
    return result;

}

Vector Vector::operator-

(

)

const

Returns the opposite of the current vector.

Example

#include "Vector.h"

Vector V(1.,0.,0.);
Vector W;
...
W = -V;


Returns

Vector

{
    Vector result(Columns);

    if (Columns==9) {
      result.setValue(1,-*U);
      result.setValue(2,-*(U+1));
      result.setValue(3,-*(U+2));
      result.setValue(4,-*(U+3));
      result.setValue(5,-*(U+4));
      result.setValue(6,-*(U+5));
      result.setValue(7,-*(U+6));
      result.setValue(8,-*(U+7));
      result.setValue(9,-*(U+8));
    }
    else if (Columns==8) {
      result.setValue(1,-*U);
      result.setValue(2,-*(U+1));
      result.setValue(3,-*(U+2));
      result.setValue(4,-*(U+3));
      result.setValue(5,-*(U+4));
      result.setValue(6,-*(U+5));
      result.setValue(7,-*(U+6));
      result.setValue(8,-*(U+7));
    }
    else if (Columns==7) {
      result.setValue(1,-*U);
      result.setValue(2,-*(U+1));
      result.setValue(3,-*(U+2));
      result.setValue(4,-*(U+3));
      result.setValue(5,-*(U+4));
      result.setValue(6,-*(U+5));
      result.setValue(7,-*(U+6));
    }
    else if (Columns==6) {
      result.setValue(1,-*U);
      result.setValue(2,-*(U+1));
      result.setValue(3,-*(U+2));
      result.setValue(4,-*(U+3));
      result.setValue(5,-*(U+4));
      result.setValue(6,-*(U+5));
    }
    else if (Columns==5) {
      result.setValue(1,-*U);
      result.setValue(2,-*(U+1));
      result.setValue(3,-*(U+2));
      result.setValue(4,-*(U+3));
      result.setValue(5,-*(U+4));
    }
    else if (Columns==4) {
      result.setValue(1,-*U);
      result.setValue(2,-*(U+1));
      result.setValue(3,-*(U+2));
      result.setValue(4,-*(U+3));
    }
    else if (Columns==3) {
      result.setValue(1,-*U);
      result.setValue(2,-*(U+1));
      result.setValue(3,-*(U+2));
    }
    else if (Columns==2) {
      result.setValue(1,-*U);
      result.setValue(2,-*(U+1));
    }
    else if (Columns==1) {
      result.setValue(1,-*U);
    }
    return result;
}

void Vector::operator-=

(

const Vector &

V

)

Subtracts V to the current vector.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
Vector W(0.,-1.,2.);
...
W -= V;


Parameters

V

Vector

Returns

void

{
#ifdef DEBUG
    if ( Columns != V.dimension())
    {
        cout << "Vector.cpp: In method `void Vector::operator-=(Vector&)':\n";
        cout << "Vector.cpp: vectors have different dimensions\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    if (Columns==9) {
      *U -= V.value(1);
      *(U+1) -= V.value(2);
      *(U+2) -= V.value(3);
      *(U+3) -= V.value(4);
      *(U+4) -= V.value(5);
      *(U+5) -= V.value(6);
      *(U+6) -= V.value(7);
      *(U+7) -= V.value(8);
      *(U+8) -= V.value(9);
    }
    else if (Columns==8) {
      *U -= V.value(1);
      *(U+1) -= V.value(2);
      *(U+2) -= V.value(3);
      *(U+3) -= V.value(4);
      *(U+4) -= V.value(5);
      *(U+5) -= V.value(6);
      *(U+6) -= V.value(7);
      *(U+7) -= V.value(8);
    }
    else if (Columns==7) {
      *U -= V.value(1);
      *(U+1) -= V.value(2);
      *(U+2) -= V.value(3);
      *(U+3) -= V.value(4);
      *(U+4) -= V.value(5);
      *(U+5) -= V.value(6);
      *(U+6) -= V.value(7);
    }
    else if (Columns==6) {
      *U -= V.value(1);
      *(U+1) -= V.value(2);
      *(U+2) -= V.value(3);
      *(U+3) -= V.value(4);
      *(U+4) -= V.value(5);
      *(U+5) -= V.value(6);
    }
    else if (Columns==5) {
      *U -= V.value(1);
      *(U+1) -= V.value(2);
      *(U+2) -= V.value(3);
      *(U+3) -= V.value(4);
      *(U+4) -= V.value(5);
    }
    else if (Columns==4) {
      *U -= V.value(1);
      *(U+1) -= V.value(2);
      *(U+2) -= V.value(3);
      *(U+3) -= V.value(4);
    }
    else if (Columns==3) {
      *U -= V.value(1);
      *(U+1) -= V.value(2);
      *(U+2) -= V.value(3);
    }
    else if (Columns==2) {
      *U -= V.value(1);
      *(U+1) -= V.value(2);
    }
    else if (Columns==1) {
      *U -= V.value(1);
    }
}

Vector Vector::operator/

(

const real

a

)

const

Returns the division of the current vector by a real a.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
Vector W;
real x = 2.;
...
W = V / x;


Parameters

a	Real value

Returns

Vector

{
    Vector result(Columns);

#ifdef DEBUG
    if ( a == 0.)
    {
        cout << "Vector.cpp: In method `void Vector::operator/(real)':\n";
        cout << "Vector.cpp: division by zero\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    if (Columns==9) {
      result.setValue(1, value(1) /a);
      result.setValue(2, value(2) /a);
      result.setValue(3, value(3) /a);
      result.setValue(4, value(4) /a);
      result.setValue(5, value(5) /a);
      result.setValue(6, value(6) /a);
      result.setValue(7, value(7) /a);
      result.setValue(8, value(8) /a);
      result.setValue(9, value(9) /a);
    }
    else if (Columns==8) {
      result.setValue(1, value(1) /a);
      result.setValue(2, value(2) /a);
      result.setValue(3, value(3) /a);
      result.setValue(4, value(4) /a);
      result.setValue(5, value(5) /a);
      result.setValue(6, value(6) /a);
      result.setValue(7, value(7) /a);
      result.setValue(8, value(8) /a);
    }
    else if (Columns==7) {
      result.setValue(1, value(1) /a);
      result.setValue(2, value(2) /a);
      result.setValue(3, value(3) /a);
      result.setValue(4, value(4) /a);
      result.setValue(5, value(5) /a);
      result.setValue(6, value(6) /a);
      result.setValue(7, value(7) /a);
    }
    else if (Columns==6) {
      result.setValue(1, value(1) /a);
      result.setValue(2, value(2) /a);
      result.setValue(3, value(3) /a);
      result.setValue(4, value(4) /a);
      result.setValue(5, value(5) /a);
      result.setValue(6, value(6) /a);
    }
    else if (Columns==5) {
      result.setValue(1, value(1) /a);
      result.setValue(2, value(2) /a);
      result.setValue(3, value(3) /a);
      result.setValue(4, value(4) /a);
      result.setValue(5, value(5) /a);
    }
    else if (Columns==4) {
      result.setValue(1, value(1) /a);
      result.setValue(2, value(2) /a);
      result.setValue(3, value(3) /a);
      result.setValue(4, value(4) /a);
    }
    else if (Columns==3) {
      result.setValue(1, value(1) /a);
      result.setValue(2, value(2) /a);
      result.setValue(3, value(3) /a);
    }
    else if (Columns==2) {
      result.setValue(1, value(1) /a);
      result.setValue(2, value(2) /a);
    }
    else if (Columns==1) {
      result.setValue(1, value(1) /a);
    }
    return result;
}

void Vector::operator/=

(

const real

a

)

Divides the current vector by a real a.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
real x = 2.;
...
V /= x;


Parameters

a	Real value

Returns

void

{
#ifdef DEBUG
    if ( a == 0.)
    {
        cout << "Vector.cpp: In method `void Vector::operator/=(real)':\n";
        cout << "Vector.cpp: division by zero\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    if (Columns==9) {
      *U /= a;
      *(U+1) /= a;
      *(U+2) /= a;
      *(U+3) /= a;
      *(U+4) /= a;
      *(U+5) /= a;
      *(U+6) /= a;
      *(U+7) /= a;
      *(U+8) /= a;
    }
    else if (Columns==8) {
      *U /= a;
      *(U+1) /= a;
      *(U+2) /= a;
      *(U+3) /= a;
      *(U+4) /= a;
      *(U+5) /= a;
      *(U+6) /= a;
      *(U+7) /= a;
    }
    else if (Columns==7) {
      *U /= a;
      *(U+1) /= a;
      *(U+2) /= a;
      *(U+3) /= a;
      *(U+4) /= a;
      *(U+5) /= a;
      *(U+6) /= a;
    }
    else if (Columns==6) {
      *U /= a;
      *(U+1) /= a;
      *(U+2) /= a;
      *(U+3) /= a;
      *(U+4) /= a;
      *(U+5) /= a;
    }
    else if (Columns==5) {
      *U /= a;
      *(U+1) /= a;
      *(U+2) /= a;
      *(U+3) /= a;
      *(U+4) /= a;
    }
    else if (Columns==4) {
      *U /= a;
      *(U+1) /= a;
      *(U+2) /= a;
      *(U+3) /= a;
    }
    else if (Columns==3) {
      *U /= a;
      *(U+1) /= a;
      *(U+2) /= a;
    }
    else if (Columns==2) {
      *U /= a;
      *(U+1) /= a;
    }
    else if (Columns==1) {
      *U /= a;
    }
}

void Vector::operator=

(

const Vector &

V

)

Set the current vector to the dimension and the value of V.

Example :

#include "Vector.h"

Vector V(1.,0.,0.);
Vector W;
...
W = V;


Parameters

V

Vector

Returns

void

{
    if (V.dimension() != Columns)
    {
      Columns = V.dimension();
    }

    if (Columns==9) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
      *(U+5) = V.value(6);
      *(U+6) = V.value(7);
      *(U+7) = V.value(8);
      *(U+8) = V.value(9);
    }
    else if (Columns==8) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
      *(U+5) = V.value(6);
      *(U+6) = V.value(7);
      *(U+7) = V.value(8);
    }
    else if (Columns==7) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
      *(U+5) = V.value(6);
      *(U+6) = V.value(7);
    }
    else if (Columns==6) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
      *(U+5) = V.value(6);
    }
    else if (Columns==5) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
      *(U+4) = V.value(5);
    }
    else if (Columns==4) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
      *(U+3) = V.value(4);
    }
    else if (Columns==3) {
      *U = V.value(1);
      *(U+1) = V.value(2);
      *(U+2) = V.value(3);
    }
    else if (Columns==2) {
      *U = V.value(1);
      *(U+1) = V.value(2);
    }
    else if (Columns==1) {
      *U = V.value(1);
    }
}

bool Vector::operator==

(

const Vector &

V

)

const

Compares the current vector to a vector V and returns true if they are equal.

Example :

#include "Vector.h"

Vector V(2);
Vector W(2);
real x;
...
if (V == W)
x = V.value(1);


Parameters

V

Vector

Returns

bool

{
#ifdef DEBUG
    if ( Columns != V.dimension())
    {
        cout << "Vector.cpp: In method `bool Vector::operator==(Vector&)':\n";
        cout << "Vector.cpp: vectors have different dimensions\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    if (Columns==9) {
      if ( *U != V.value(1) ) return false;
      if ( *(U+1) != V.value(2) ) return false;
      if ( *(U+2) != V.value(3) ) return false;
      if ( *(U+3) != V.value(4) ) return false;
      if ( *(U+4) != V.value(5) ) return false;
      if ( *(U+5) != V.value(6) ) return false;
      if ( *(U+6) != V.value(7) ) return false;
      if ( *(U+7) != V.value(8) ) return false;
      if ( *(U+8) != V.value(9) ) return false;
    }
    else if (Columns==8) {
      if ( *U != V.value(1) ) return false;
      if ( *(U+1) != V.value(2) ) return false;
      if ( *(U+2) != V.value(3) ) return false;
      if ( *(U+3) != V.value(4) ) return false;
      if ( *(U+4) != V.value(5) ) return false;
      if ( *(U+5) != V.value(6) ) return false;
      if ( *(U+6) != V.value(7) ) return false;
      if ( *(U+7) != V.value(8) ) return false;
    }
    else if (Columns==7) {
      if ( *U != V.value(1) ) return false;
      if ( *(U+1) != V.value(2) ) return false;
      if ( *(U+2) != V.value(3) ) return false;
      if ( *(U+3) != V.value(4) ) return false;
      if ( *(U+4) != V.value(5) ) return false;
      if ( *(U+5) != V.value(6) ) return false;
      if ( *(U+6) != V.value(7) ) return false;
    }
    else if (Columns==6) {
      if ( *U != V.value(1) ) return false;
      if ( *(U+1) != V.value(2) ) return false;
      if ( *(U+2) != V.value(3) ) return false;
      if ( *(U+3) != V.value(4) ) return false;
      if ( *(U+4) != V.value(5) ) return false;
      if ( *(U+5) != V.value(6) ) return false;
    }
    else if (Columns==5) {
      if ( *U != V.value(1) ) return false;
      if ( *(U+1) != V.value(2) ) return false;
      if ( *(U+2) != V.value(3) ) return false;
      if ( *(U+3) != V.value(4) ) return false;
      if ( *(U+4) != V.value(5) ) return false;
    }
    else if (Columns==4) {
      if ( *U != V.value(1) ) return false;
      if ( *(U+1) != V.value(2) ) return false;
      if ( *(U+2) != V.value(3) ) return false;
      if ( *(U+3) != V.value(4) ) return false;
    }
    else if (Columns==3) {
      if ( *U != V.value(1) ) return false;
      if ( *(U+1) != V.value(2) ) return false;
      if ( *(U+2) != V.value(3) ) return false;
    }
    else if (Columns==2) {
      if ( *U != V.value(1) ) return false;
      if ( *(U+1) != V.value(2) ) return false;
    }
    else if (Columns==1) {
      if ( *U != V.value(1) ) return false;
    }
    return true;

}

Vector Vector::operator^

(

const Vector &

V

)

const

Returns the vectorial product of the current vector and V.

Parameters

V

Vector

Returns

Vector

{
    Vector result(3);

#ifdef DEBUG
    if ( Columns != V.dimension())
    {
        cout << "Vector.cpp: In method `real Vector::operator^(Vector&)':\n";
        cout << "Vector.cpp: vectors have different dimensions\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    if (Columns > 1)
    {
        result.setValue(3, value(1)*V.value(2)-value(2)*V.value(1));
        if (Columns > 2)
        {
            result.setValue(1, value(2)*V.value(3)-value(3)*V.value(2));
            result.setValue(2, value(3)*V.value(1)-value(1)*V.value(3));
        }
    }

    return result;

}

Vector Vector::operator|

(

const Vector &

V

)

const

Returns the term-by-term product of the current vector and V.

Parameters

V

Vector

Returns

Vector

{
    int n;
    Vector result(Columns);

#ifdef DEBUG
    if ( Columns != V.dimension())
    {
        cout << "Vector.cpp: In method `real Vector::operator|(Vector&)':\n";
        cout << "Vector.cpp: vectors have different dimensions\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    for (n=1; n<=Columns; n++)
        result.setValue(n, value(n) * V.value(n));

    return result;

}

void Vector::setDimension

(

const int

n

)

Sets the dimension of the vector to n and reset values to zero.

Example :

#include "Vector.h"

Vector V;
...
V.setDimension(3);


Parameters

n

Dimension

Returns

void

{
    Columns = n;
    if (Columns==9) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
      *(U+6)=0.;
      *(U+7)=0.;
      *(U+8)=0.;
    }
    else if (Columns==8) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
      *(U+6)=0.;
      *(U+7)=0.;
    }
    else if (Columns==7) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
      *(U+6)=0.;
    }
    else if (Columns==6) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
    }
    else if (Columns==5) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
    }
    else if (Columns==4) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
    }
    else if (Columns==3) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
    }
    else if (Columns==2) {
      *U=0.;
      *(U+1)=0.;
    }
    else if (Columns==1) {
      *U=0.;
    }
}

Here is the caller graph for this function:

void Vector::setValue ( const int  n, const real  a  )

inline

Sets the component n to value a.

Example :

#include "Vector.h"

Vector V(2);
real x = 3.;
real y = 1.;
V.setValue(1,x);
V.setValue(2,y);

Parameters

n	Variable number
a	Real value

Returns

void

{

#ifdef DEBUG
    if ( n <= 0 || n > Columns)
    {
        cout << "Vector.cpp: In method `void Vector::setValue(int, real)':\n";
        cout << "Vector.cpp: first argument out of range\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

        *(U+n-1) = a;
}

Here is the caller graph for this function:

void Vector::setZero

(

)

Sets all the components to zero.

Returns

void

{
    if (Columns==9) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
      *(U+6)=0.;
      *(U+7)=0.;
      *(U+8)=0.;
    }
    else if (Columns==8) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
      *(U+6)=0.;
      *(U+7)=0.;
    }
    else if (Columns==7) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
      *(U+6)=0.;
    }
    else if (Columns==6) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
      *(U+5)=0.;
    }
    else if (Columns==5) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
      *(U+4)=0.;
    }
    else if (Columns==4) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
      *(U+3)=0.;
    }
    else if (Columns==3) {
      *U=0.;
      *(U+1)=0.;
      *(U+2)=0.;
    }
    else if (Columns==2) {
      *U=0.;
      *(U+1)=0.;
    }
    else if (Columns==1) {
      *U=0.;
    }
}

Here is the caller graph for this function:

real Vector::value ( const int  n ) const

inline

Returns the value of the component n.

Example :

#include "Vector.h"

Vector V(2);
real x;
real y;
...
x = V.value(1);
y = V.value(2);


Parameters

n

Integer

Returns

real

{

#ifdef DEBUG

    if ( n <= 0 || n > Columns)
    {
        cout << "Vector.cpp: In method `void Vector::value(int)':\n";
        cout << "Vector.cpp: argument out of range\n";
        cout << "carmen: *** [Vector.o] Execution error\n";
        cout << "carmen: abort execution.\n";
        exit(1);
    }
#endif

    return *(U+n-1);
}

Member Data Documentation

int Vector::Columns

Number of columns

real Vector::U[9]

Components

---

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

• Vector.h
• Vector.cpp