vector.h File Reference

This file contains the Vector template class and some useful functions around this class. More...

#include <ostream>
#include <stdlib.h>
#include <stdio.h>
#include <complex>
#include <fstream>
#include <math.h>
#include <iostream>
#include "goodies.h"

Go to the source code of this file.

Classes
class	GOAT::maths::Vector< T >
	Template class for threedimensional vectors. More...

Namespaces
namespace	GOAT
	This class is used for the iray class. This class is intended for internal use only. It defines a plane, defined by a central position and two directional vectors.
namespace	GOAT::maths

Macros
#define	complex_I
#define	cone   Vector<std::complex<double> > (1.0,1.0,1.0)
	complex valued vector with all components set to 1
#define	czero   Vector<std::complex<double> > (0.0,0.0,0.0)
	complex valued vector with all components set to 0
#define	dzero   Vector<double> (0.0,0.0,0.0)
	double valued vector with all components set to 0
#define	ex   Vector<double> (1.0,0.0,0.0)
	unit vector in the x-direction
#define	ey   Vector<double> (0.0,1.0,0.0)
	unit vector in the y-direction
#define	ez   Vector<double> (0.0,0.0,1.0)
	unit vector in the z-direction

Functions
double	GOAT::maths::abs (const Vector< double > &r)
	Fehlermeldung ausgeben.
double	GOAT::maths::abs (const Vector< int > &r)
	Calculates the absolute value of an integer vector.
double	GOAT::maths::abs (const Vector< long long int > &r)
	Calculates the absolute value of an integer vector.
double	GOAT::maths::abs (const Vector< std::complex< double > > &r)
	Calculates the absolute value of a complex vector \( (abs(\vec{r})=\sqrt{\vec{r} \cdot \vec{r} }) \).
double	GOAT::maths::abs2 (const Vector< double > &r)
	Calculates the squared absolute value of double vector.
double	GOAT::maths::abs2 (const Vector< std::complex< double > > &r)
	Calculates the squared absolute value of double vector \( (abs2(\vec{r})=\vec{r} \cdot \vec{r} ) \).
double	GOAT::maths::abs2 (double x)
	Squared absolute value of x.
double	GOAT::maths::abs2 (std::complex< double > x)
	Absolute value of the complex number x \( abs(x)=\sqrt{x \cdot x} \).
double	GOAT::maths::arctan (double y, double x)
Vector< double >	GOAT::maths::arg (Vector< std::complex< double > > &r)
std::complex< double >	GOAT::maths::asin (std::complex< double > z)
template<class T>
Vector< T >	GOAT::maths::cart2sphere (const Vector< T > &x)
	Transformation from cartesian coordinates to spherical coordinates.
Vector< double >	GOAT::maths::cart2sphere (double x, double y, double z)
	Converts a vector, described by its cartesian components, into a vector in spherical coordinates ( \((r, \vartheta, \varphi) \))
Vector< double >	GOAT::maths::ceil (const Vector< double > &r)
Vector< std::complex< double > >	GOAT::maths::conj (const Vector< std::complex< double > > &r)
	Conjugate complex of the vector r.
double *	GOAT::maths::conv2double (int numV, Vector< std::complex< double > > *r)
	This function returns an array with all components of the Vector-array r.
Vector< std::complex< double > > *	GOAT::maths::conv2vector (int num, double *r)
	This function converts a list of doubles into a list of complex vectors.
Vector< std::complex< double > >	GOAT::maths::convd2c (const Vector< double > &r)
Vector< std::complex< double > >	GOAT::maths::convd2c (const Vector< std::complex< double > > &r)
Vector< double >	GOAT::maths::emax (Vector< double > &P1, Vector< double > &P2)
Vector< double >	GOAT::maths::ephi (double theta, double phi)
	returns a normalized vector in phi-direction on a unit sphere with spherical coordinates /p theta and /p phi
Vector< double >	GOAT::maths::er (double theta, double phi)
	returns a normalized vector in r-direction on a unit sphere with spherical coordinates /p theta and /p phi
void	GOAT::maths::errmsg (char *S)
Vector< double >	GOAT::maths::etheta (double theta, double phi)
	returns a normalized vector in theta-direction on a unit sphere with spherical coordinates /p theta and /p phi
Vector< double >	GOAT::maths::floor (const Vector< double > &r)
	rounding up, Component-by-component
void	GOAT::maths::getKSystem (const Vector< double > &n, const Vector< double > &k, Vector< double > &e1, Vector< double > &e2, Vector< double > &e3)
	Calculates the three direction vectors of a coordinate system formed by the surface normal n and the propagation vector k.
Vector< std::complex< double > >	GOAT::maths::grad2d (double(*f(Vector< std::complex< double > >)), Vector< std::complex< double > > r, double d)
	calculates the gradient of a given function at a certain position
Vector< int >	GOAT::maths::iceil (const Vector< double > &r)
Vector< int >	GOAT::maths::ifloor (const Vector< double > &r)
	rounding up, component-by-component rounding
std::complex< double >	GOAT::maths::ihoch (int l)
Vector< double >	GOAT::maths::imag (Vector< std::complex< double > > r)
	returns a vector with the imaginary parts of the components of the complex vector r
bool	GOAT::maths::isnan (Vector< double > v)
	returns true if one of the components of v is NaN
bool	GOAT::maths::isnan (Vector< std::complex< double > > v)
	returns true if one of the components of v is NaN
Vector< std::complex< double > >	GOAT::maths::makeReal (const Vector< std::complex< double > > &r)
Vector< double >	GOAT::maths::nanV (const char *tagp)
Vector< double >	GOAT::maths::norm (const Vector< double > &r)
Vector< std::complex< double > >	GOAT::maths::norm (const Vector< std::complex< double > > &r)
std::complex< double >	GOAT::maths::operator* (int y, std::complex< double > x)
std::complex< double >	GOAT::maths::operator* (long long int y, std::complex< double > x)
std::complex< double >	GOAT::maths::operator* (std::complex< double > x, int y)
std::complex< double >	GOAT::maths::operator* (std::complex< double > x, long long int y)
std::complex< double >	GOAT::maths::operator+ (int y, std::complex< double > x)
std::complex< double >	GOAT::maths::operator+ (long long int y, std::complex< double > x)
std::complex< double >	GOAT::maths::operator+ (std::complex< double > x, int y)
std::complex< double >	GOAT::maths::operator+ (std::complex< double > x, long long int y)
std::complex< double >	GOAT::maths::operator- (int y, std::complex< double > x)
std::complex< double >	GOAT::maths::operator- (long long int y, std::complex< double > x)
std::complex< double >	GOAT::maths::operator- (std::complex< double > x, int y)
std::complex< double >	GOAT::maths::operator- (std::complex< double > x, long long int y)
std::complex< double >	GOAT::maths::operator/ (int y, std::complex< double > x)
std::complex< double >	GOAT::maths::operator/ (long long int y, std::complex< double > x)
std::complex< double >	GOAT::maths::operator/ (std::complex< double > x, int y)
std::complex< double >	GOAT::maths::operator/ (std::complex< double > x, long long int y)
std::ostream &	GOAT::maths::operator<< (std::ostream &is, const Vector< double > &r)
std::ostream &	GOAT::maths::operator<< (std::ostream &is, const Vector< int > &r)
std::ostream &	GOAT::maths::operator<< (std::ostream &is, const Vector< std::complex< double > > &r)
std::istream &	GOAT::maths::operator>> (std::istream &is, Vector< double > &r)
std::istream &	GOAT::maths::operator>> (std::istream &is, Vector< int > &r)
std::istream &	GOAT::maths::operator>> (std::istream &is, Vector< std::complex< double > > &r)
	input operator, reads complex vector from file
Vector< double >	GOAT::maths::real (Vector< std::complex< double > > r)
	returns a vector with the real parts of the components of the complex vector r
Vector< double >	GOAT::maths::rotate (const Vector< double > &r, double dtheta, double dphi)
void	GOAT::maths::rotate (Vector< double > &r, double phi)
double	GOAT::maths::sDreieck (Vector< double >, Vector< double >, Vector< double >)
double	GOAT::maths::sign (double x)
template<class T>
Vector< T >	GOAT::maths::sphere2cart (const Vector< T > &P)
	Transforms vector from spherical coordinates into cartesian coordinates.
Vector< double >	GOAT::maths::sphere2cart (double r, double theta, double phi)
	Converts a vector, described by its spherical components ( \((r, \vartheta, \varphi) \)), into a vector in cartesian coordinates.
void	GOAT::maths::sphereunitv (Vector< double > &P, Vector< double > &er, Vector< double > &etheta, Vector< double > &ephi)
double	GOAT::maths::sViereck (Vector< double >, Vector< double >, Vector< double >, Vector< double >)
std::complex< double >	GOAT::maths::tan (std::complex< double > z)
char *	GOAT::maths::toString (char *S, Vector< double > P)
	Converts a double vector into a string.
char *	GOAT::maths::toString (char *S, Vector< std::complex< double > > P)
	Converts a complex vector into a string.
Vector< std::complex< double > >	GOAT::maths::vdc (const Vector< double > &r)
Standard operators for vectors
Standard operators for vectors with mixed types
Vector< std::complex< double > >	GOAT::maths::operator% (const Vector< double > &a, const Vector< int > &b)
Vector< std::complex< double > >	GOAT::maths::operator% (const Vector< double > &a, const Vector< std::complex< double > > &b)
Vector< std::complex< double > >	GOAT::maths::operator% (const Vector< int > &a, const Vector< double > &b)
Vector< std::complex< double > >	GOAT::maths::operator% (const Vector< int > &a, const Vector< std::complex< double > > &b)
Vector< std::complex< double > >	GOAT::maths::operator% (const Vector< std::complex< double > > &a, const Vector< double > &b)
Vector< std::complex< double > >	GOAT::maths::operator% (const Vector< std::complex< double > > &a, const Vector< int > &b)
double	GOAT::maths::operator* (const Vector< double > &a, const Vector< int > &b)
std::complex< double >	GOAT::maths::operator* (const Vector< double > &a, const Vector< std::complex< double > > &b)
Vector< double >	GOAT::maths::operator* (const Vector< double > &r, int x)
Vector< double >	GOAT::maths::operator* (const Vector< double > &r, long long int x)
Vector< std::complex< double > >	GOAT::maths::operator* (const Vector< double > &r, std::complex< double > x)
	multiplication between a double valued vector and a complex valued scalar
double	GOAT::maths::operator* (const Vector< int > &a, const Vector< double > &b)
std::complex< double >	GOAT::maths::operator* (const Vector< int > &a, const Vector< std::complex< double > > &b)
Vector< double >	GOAT::maths::operator* (const Vector< int > &r, double x)
Vector< std::complex< double > >	GOAT::maths::operator* (const Vector< int > &r, std::complex< double > x)
Vector< double >	GOAT::maths::operator* (const Vector< long long int > &r, double x)
Vector< std::complex< double > >	GOAT::maths::operator* (const Vector< long long int > &r, std::complex< double > x)
std::complex< double >	GOAT::maths::operator* (const Vector< std::complex< double > > &a, const Vector< double > &b)
std::complex< double >	GOAT::maths::operator* (const Vector< std::complex< double > > &a, const Vector< int > &b)
Vector< double >	GOAT::maths::operator* (double x, const Vector< int > &r)
Vector< double >	GOAT::maths::operator* (double x, const Vector< long long int > &r)
Vector< double >	GOAT::maths::operator* (int x, const Vector< double > &r)
Vector< double >	GOAT::maths::operator* (long long int x, const Vector< double > &r)
Vector< std::complex< double > >	GOAT::maths::operator* (std::complex< double > x, const Vector< double > &r)
	multiplication between a complex valued scalar and a double valued vector
Vector< std::complex< double > >	GOAT::maths::operator* (std::complex< double > x, const Vector< int > &r)
Vector< std::complex< double > >	GOAT::maths::operator* (std::complex< double > x, const Vector< long long int > &r)
Vector< double >	GOAT::maths::operator+ (const Vector< double > &r1, const Vector< int > &r2)
Vector< double >	GOAT::maths::operator+ (const Vector< double > &r1, const Vector< long long int > &r2)
Vector< std::complex< double > >	GOAT::maths::operator+ (const Vector< double > &r1, const Vector< std::complex< double > > &r2)
Vector< double >	GOAT::maths::operator+ (const Vector< int > &r1, const Vector< double > &r2)
Vector< std::complex< double > >	GOAT::maths::operator+ (const Vector< int > &r1, const Vector< std::complex< double > > &r2)
Vector< double >	GOAT::maths::operator+ (const Vector< long long int > &r1, const Vector< double > &r2)
Vector< std::complex< double > >	GOAT::maths::operator+ (const Vector< long long int > &r1, const Vector< std::complex< double > > &r2)
Vector< std::complex< double > >	GOAT::maths::operator+ (const Vector< std::complex< double > > &r1, const Vector< double > &r2)
Vector< std::complex< double > >	GOAT::maths::operator+ (const Vector< std::complex< double > > &r1, const Vector< int > &r2)
Vector< std::complex< double > >	GOAT::maths::operator+ (const Vector< std::complex< double > > &r1, const Vector< long long int > &r2)
Vector< double >	GOAT::maths::operator- (const Vector< double > &r1, const Vector< int > &r2)
Vector< double >	GOAT::maths::operator- (const Vector< double > &r1, const Vector< long long int > &r2)
Vector< std::complex< double > >	GOAT::maths::operator- (const Vector< double > &r1, const Vector< std::complex< double > > &r2)
Vector< double >	GOAT::maths::operator- (const Vector< int > &r1, const Vector< double > &r2)
Vector< long long int >	GOAT::maths::operator- (const Vector< int > &r1, const Vector< long long int > &r2)
Vector< std::complex< double > >	GOAT::maths::operator- (const Vector< int > &r1, const Vector< std::complex< double > > &r2)
Vector< double >	GOAT::maths::operator- (const Vector< long long int > &r1, const Vector< double > &r2)
Vector< long long int >	GOAT::maths::operator- (const Vector< long long int > &r1, const Vector< int > &r2)
Vector< std::complex< double > >	GOAT::maths::operator- (const Vector< long long int > &r1, const Vector< std::complex< double > > &r2)
Vector< std::complex< double > >	GOAT::maths::operator- (const Vector< std::complex< double > > &r1, const Vector< double > &r2)
Vector< std::complex< double > >	GOAT::maths::operator- (const Vector< std::complex< double > > &r1, const Vector< int > &r2)
Vector< std::complex< double > >	GOAT::maths::operator- (const Vector< std::complex< double > > &r1, const Vector< long long int > &r2)
Vector< double >	GOAT::maths::operator/ (const Vector< double > &r, int x)
Vector< double >	GOAT::maths::operator/ (const Vector< double > &r, long long int x)
Vector< std::complex< double > >	GOAT::maths::operator/ (const Vector< double > &r, std::complex< double > x)
Vector< double >	GOAT::maths::operator/ (const Vector< int > &r, double x)
Vector< std::complex< double > >	GOAT::maths::operator/ (const Vector< int > &r, std::complex< double > x)
Vector< double >	GOAT::maths::operator/ (const Vector< long long int > &r, double x)
Vector< std::complex< double > >	GOAT::maths::operator/ (const Vector< long long int > &r, std::complex< double > x)
Vector< std::complex< double > >	GOAT::maths::operator/ (const Vector< std::complex< double > > &r, double x)
Vector< std::complex< double > >	GOAT::maths::operator/ (const Vector< std::complex< double > > &r, int x)
Vector< std::complex< double > >	GOAT::maths::operator/ (const Vector< std::complex< double > > &r, long long int x)
element-wise multiplication
Element-wise multiplication of two vectors with different types
Vector< double >	GOAT::maths::emult (const Vector< double > &r1, const Vector< int > &r2)
Vector< double >	GOAT::maths::emult (const Vector< double > &r1, const Vector< long long int > &r2)
Vector< double >	GOAT::maths::emult (const Vector< int > &r1, const Vector< double > &r2)
Vector< double >	GOAT::maths::emult (const Vector< long long int > &r1, const Vector< double > &r2)

Variables
const std::complex< double >	I = std::complex<double>(0.0, 1.0)
	imaginary unit
const Vector< double >	GOAT::maths::one =Vector<double>(1.0, 1.0, 1.0)
	double valued vector with all components set to 1

Detailed Description

This file contains the Vector template class and some useful functions around this class.

Author

Thomas Weigel

Date

July 2021

Definition in file vector.h.

Macro Definition Documentation

complex_I

#define complex_I

Definition at line 718 of file vector.h.

cone

#define cone   Vector<std::complex<double> > (1.0,1.0,1.0)

complex valued vector with all components set to 1

Definition at line 659 of file vector.h.

czero

#define czero   Vector<std::complex<double> > (0.0,0.0,0.0)

complex valued vector with all components set to 0

Definition at line 658 of file vector.h.

dzero

#define dzero   Vector<double> (0.0,0.0,0.0)

double valued vector with all components set to 0

Definition at line 655 of file vector.h.

ex

#define ex   Vector<double> (1.0,0.0,0.0)

unit vector in the x-direction

Definition at line 652 of file vector.h.

ey

#define ey   Vector<double> (0.0,1.0,0.0)

unit vector in the y-direction

Definition at line 653 of file vector.h.

ez

#define ez   Vector<double> (0.0,0.0,1.0)

unit vector in the z-direction

Definition at line 654 of file vector.h.

Variable Documentation

I

const std::complex<double> I = std::complex<double>(0.0, 1.0)

imaginary unit

Definition at line 719 of file vector.h.