vector_unit_3d.hpp File Reference

#include "./scalar_unit.hpp"
#include "./vector_unit_2d.hpp"
#include "./vector_unit_nd.hpp"
#include "../meca_number/angle.hpp"
#include "../util/is_number.hpp"
#include "../coordinates/direction.hpp"
#include "boost/algorithm/string.hpp"
#include <cmath>
#include <functional>
#include <iostream>
#include <list>
#include <sstream>
#include <string>
#include <vector>

Include dependency graph for vector_unit_3d.hpp:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
class	scifir::vector_unit_3d
	Class that creates a vector unit in 3D. The vector is in spherical coordinates with a value and dimensions of the scalar_unit, and an angle theta and another angle phi for his direction. All base and derived vectorial unit classes in 3D inherit from vector_unit_3d, and add the suffix **_3d** in their name. Initialization string example: "1 N 20θ 30Φ". 'θ' is the Unicode Character U+03B8. 'Φ' is the Unicode Character U+03A6. More...

Namespaces
namespace	scifir
	The namespace scifir contains all scifir-units, excepting the string literals, which are outside.

Macros
#define	VECTOR_UNIT_3D_HPP_BEGIN(name)
#define	VECTOR_UNIT_3D_HPP_END()
#define	VECTOR_UNIT_3D_HPP(name)
#define	VECTOR_UNIT_3D_CPP(name, init_real_dimensions)
#define	VECTOR_UNIT_HPP(name)
#define	VECTOR_UNIT_CPP(name, init_real_dimensions)

Functions
string	scifir::to_string (const vector_unit_3d &x)
	It generates a string representation of vector_unit_3d.
scalar_unit	scifir::norm (const vector_unit_3d &x)
	It returns the value of the vector in spherical coordinates, r.
vector_unit_3d	scifir::sqrt (const vector_unit_3d &x)
	It squares the vector, creating a vector_unit_3d with the value squared and always the same theta and the same phi. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.
vector_unit_3d	scifir::sqrt_nth (const vector_unit_3d &x, int index)
	It takes the root of the vector with the index given, creating a vector_unit_3d with the value rooted to that index and always maintains the same theta and the same phi. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.
scalar_unit	scifir::dot_product (const vector_unit_3d &x, const vector_unit_3d &y)
	Creates a scalar_unit as the dot product of the two vectors x and y.
vector_unit_3d	scifir::cross_product (const vector_unit_3d &x, const vector_unit_3d &y)
	Creates a vector_unit_3d as the cross product of the two vectors x and y.
angle	scifir::angle_between (const vector_unit_3d &x, const vector_unit_3d &y)
	Returns the angle between two vectors x and y inside a 3D space.
bool	scifir::same_direction (const vector_unit_3d &x, const vector_unit_3d &y)
	Checks if two vectors x and y have the same direction.
bool	scifir::parallel (const vector_unit_3d &x, const vector_unit_3d &y)
	Checks if two vectors x and y are parallel, which means that their direction is the same or the exact opposite.
bool	scifir::orthogonal (const vector_unit_3d &x, const vector_unit_3d &y)
	Checks if two vectors x and y are orthogonal, that's, if they have 90 degrees between them.
scifir::vector_unit_3d	operator* (const scifir::scalar_unit &x, const scifir::vector_unit_3d &y)
	It creates a new vector_unit_3d scaling a vector_unit_3d by the scalar_unit x.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scifir::vector_unit_3d	operator+ (const T y, const scifir::vector_unit_3d &x)
	It creates a new vector as the addition of the numeric type x to the value. Theta and phi are not changed.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scifir::vector_unit_3d	operator- (const T y, const scifir::vector_unit_3d &x)
	It creates a new vector as the substraction of the numeric type x with the value. Theta and phi are not changed.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scifir::vector_unit_3d	operator* (const T y, const scifir::vector_unit_3d &x)
	It creates a new vector as the multiplication of the numeric type x to the value. Theta and phi are not changed.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scifir::vector_unit_3d	operator/ (const T y, const scifir::vector_unit_3d &x)
	It creates a new vector as the division of the numeric type x with the value. Theta and phi are not changed.
bool	operator!= (const scifir::vector_unit_3d &x, const scifir::vector_unit_3d &y)
	Comparison operator. Two vector_unit_3d are not equal if their value, dimensions, theta or phi are different.
bool	operator== (const scifir::vector_unit_3d &x, const string &init_vector_3d)
	Returns true if x is equal to the vector_unit_3d initialized with the string being compared. The vectorial_display() function is not used, and so the values are compared with all its decimal numbers.
bool	operator!= (const scifir::vector_unit_3d &x, const string &init_vector_3d)
	Returns true if x is not equal to the vector_unit_3d initialized with the string being compared. The vectorial_display() function is not used, and so the values are compared with all its decimal numbers.
bool	operator== (const string &init_vector_3d, const scifir::vector_unit_3d &x)
	Returns true if x is equal to the vector_unit_3d initialized with the string being compared. The vectorial_display() function is not used, and so the values are compared with all its decimal numbers.
bool	operator!= (const string &init_vector_3d, const scifir::vector_unit_3d &x)
	Returns true if x is not equal to the vector_unit_3d initialized with the string being compared. The vectorial_display() function is not used, and so the values are compared with all its decimal numbers.
void	operator+= (string &x, const scifir::vector_unit_3d &y)
	Concatenates the string representation of the vector_unit_3d y to the string x.
string	operator+ (const string &x, const scifir::vector_unit_3d &y)
	Creates a new string as the concatenation of the string x with the representation string of the vector_unit_3d y.
string	operator+ (const scifir::vector_unit_3d &y, const string &x)
	Creates a new string as the concatenation of the string x with the representation string of the vector_unit_3d y.
ostream &	operator<< (ostream &os, const scifir::vector_unit_3d &x)
	Adds the string representation of the vector_unit_3d x to an output stream os.
istream &	operator>> (istream &is, scifir::vector_unit_3d &x)
	Allows that an istream initializes by string a vector_unit_3d x.

Macro Definition Documentation

VECTOR_UNIT_3D_CPP

#define VECTOR_UNIT_3D_CPP	(		name,
			init_real_dimensions
	)

Definition at line 116 of file vector_unit_3d.hpp.

                                                                           : vector_unit_3d() {} \
    name##_3d::name##_3d(const name##_3d& x) : vector_unit_3d(x) {} \
    name##_3d::name##_3d(name##_3d&& x) : vector_unit_3d(std::move(x)) {} \
    name##_3d::name##_3d(float new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position) : vector_unit_3d(new_value,new_dimension,new_prefix,new_theta,new_phi,new_position) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(float new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position) : vector_unit_3d(new_value,new_dimension,new_prefix,new_theta,new_phi,new_position) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(double new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position) : vector_unit_3d(new_value,new_dimension,new_prefix,new_theta,new_phi,new_position) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(double new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position) : vector_unit_3d(new_value,new_dimension,new_prefix,new_theta,new_phi,new_position) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(long double new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position) : vector_unit_3d(new_value,new_dimension,new_prefix,new_theta,new_phi,new_position) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(long double new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position) : vector_unit_3d(new_value,new_dimension,new_prefix,new_theta,new_phi,new_position) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(int new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position) : vector_unit_3d(new_value,new_dimension,new_prefix,new_theta,new_position) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(int new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position) : vector_unit_3d(new_value,new_dimension,new_prefix,new_theta,new_phi,new_position) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(float new_value,const string& init_dimensions,float new_theta,float new_phi) : vector_unit_3d(new_value,init_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(float new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi) : vector_unit_3d(new_value,init_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(double new_value,const string& init_dimensions,float new_theta,float new_phi) : vector_unit_3d(new_value,init_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(double new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi) : vector_unit_3d(new_value,init_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(long double new_value,const string& init_dimensions,float new_theta,float new_phi) : vector_unit_3d(new_value,init_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(long double new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi) : vector_unit_3d(new_value,init_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(int new_value,const string& init_dimensions,float new_theta,float new_phi) : vector_unit_3d(new_value,init_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(int new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi) : vector_unit_3d(new_value,init_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(float new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi) : vector_unit_3d(new_value,new_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(float new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi) : vector_unit_3d(new_value,new_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(double new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi) : vector_unit_3d(new_value,new_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(double new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi) : vector_unit_3d(new_value,new_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(long double new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi) : vector_unit_3d(new_value,new_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(long double new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi) : vector_unit_3d(new_value,new_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(int new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi) : vector_unit_3d(new_value,new_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(int new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi) : vector_unit_3d(new_value,new_dimensions,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(const scalar_unit& x,float new_theta,float new_phi) : vector_unit_3d(x,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(const scalar_unit& x,const angle& new_theta,const angle& new_phi) : vector_unit_3d(x,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(const string& init_scalar,float new_theta,float new_phi) : vector_unit_3d(init_scalar,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(const string& init_scalar,const angle& new_theta,const angle& new_phi) : vector_unit_3d(init_scalar,new_theta,new_phi) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(const string& init_vector_3d) : vector_unit_3d() \
    { \
        vector_unit_3d::initialize_from_string(init_vector_3d); \
    } \
\
    name##_3d::name##_3d(const vector_unit_3d& x) : vector_unit_3d(x) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d::name##_3d(vector_unit_3d&& x) : vector_unit_3d(x) \
    { \
        scalar_unit::check_dimensions(name##_3d::real_dimensions); \
    } \
\
    name##_3d& name##_3d::operator =(const name##_3d& x) \
    { \
        vector_unit_3d::operator =(x); \
        return *this; \
    } \
\
    name##_3d& name##_3d::operator =(name##_3d&& x) \
    { \
        vector_unit_3d::operator =(std::move(x)); \
        return *this; \
    } \
const string name##_3d::dimensions_match = init_real_dimensions; \
const vector<dimension> name##_3d::real_dimensions = create_base_dimensions(init_real_dimensions)

VECTOR_UNIT_3D_HPP

#define VECTOR_UNIT_3D_HPP

(

name

)

Definition at line 69 of file vector_unit_3d.hpp.

                                                 : public vector_unit_3d \
    {   \
        public: \
            name##_3d(); \
            name##_3d(const name##_3d&); \
            name##_3d(name##_3d&&); \
            explicit name##_3d(float new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi,dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(float new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(double new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(double new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(long double new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(long double new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(int new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(int new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(float new_value,const string& init_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(float new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(double new_value,const string& init_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(double new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(long double new_value,const string& init_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(long double new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(int new_value,const string& init_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(int new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(float new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(float new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(double new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(double new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(long double new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(long double new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(int new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(int new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(const scalar_unit& x,float new_theta,float new_phi); \
            explicit name##_3d(const scalar_unit& x,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(const string& init_scalar,float new_theta,float new_phi); \
            explicit name##_3d(const string& init_scalar,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(const string& init_vector_3d); \
            explicit name##_3d(const vector_unit_3d& init_vector_3d); \
            explicit name##_3d(vector_unit_3d&& init_vector_3d); \
            name##_3d& operator =(const name##_3d& x); \
            name##_3d& operator =(name##_3d&& x); \
            using vector_unit_3d::operator =; \
            using vector_unit_3d::operator+=; \
            using vector_unit_3d::operator-=; \
\
            static const string dimensions_match; \
            static const vector<dimension> real_dimensions; \
    }

VECTOR_UNIT_3D_HPP_BEGIN

#define VECTOR_UNIT_3D_HPP_BEGIN

(

name

)

Definition at line 21 of file vector_unit_3d.hpp.

                                                       : public vector_unit_3d \
    {   \
        public: \
            name##_3d(); \
            name##_3d(const name##_3d&); \
            name##_3d(name##_3d&&); \
            explicit name##_3d(float new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi,dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(float new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(double new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(double new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(long double new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(long double new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(int new_value, dimension::type new_dimension, prefix::type new_prefix, float new_theta, float new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(int new_value, dimension::type new_dimension, prefix::type new_prefix, const angle& new_theta, const angle& new_phi, dimension::position new_position = dimension::NUMERATOR); \
            explicit name##_3d(float new_value,const string& init_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(float new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(double new_value,const string& init_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(double new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(long double new_value,const string& init_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(long double new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(int new_value,const string& init_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(int new_value,const string& init_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(float new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(float new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(double new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(double new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(long double new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(long double new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(int new_value,const vector<dimension>& new_dimensions,float new_theta,float new_phi); \
            explicit name##_3d(int new_value,const vector<dimension>& new_dimensions,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(const scalar_unit& x,float new_theta,float new_phi); \
            explicit name##_3d(const scalar_unit& x,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(const string& init_scalar,float new_theta,float new_phi); \
            explicit name##_3d(const string& init_scalar,const angle& new_theta,const angle& new_phi); \
            explicit name##_3d(const string& init_vector_3d); \
            explicit name##_3d(const vector_unit_3d& init_vector_3d); \
            explicit name##_3d(vector_unit_3d&& init_vector_3d); \
            name##_3d& operator =(const name##_3d& x); \
            name##_3d& operator =(name##_3d&& x); \
            using vector_unit_3d::operator =; \
            using vector_unit_3d::operator+=; \
            using vector_unit_3d::operator-=

VECTOR_UNIT_3D_HPP_END

#define VECTOR_UNIT_3D_HPP_END

(

)

Value:

        public: \
        static const string dimensions_match; \
        static const vector<dimension> real_dimensions; \
    }

Definition at line 64 of file vector_unit_3d.hpp.

                                       : \
        static const string dimensions_match; \
        static const vector<dimension> real_dimensions; \
    }

VECTOR_UNIT_CPP

#define VECTOR_UNIT_CPP	(		name,
			init_real_dimensions
	)

Value:

SCALAR_UNIT_CPP(name,init_real_dimensions); \
VECTOR_UNIT_2D_CPP(name,init_real_dimensions); \
VECTOR_UNIT_3D_CPP(name,init_real_dimensions); \
VECTOR_UNIT_ND_CPP(name,init_real_dimensions)

Definition at line 293 of file vector_unit_3d.hpp.

VECTOR_UNIT_HPP

#define VECTOR_UNIT_HPP

(

name

)

Value:

SCALAR_UNIT_HPP(name); \
VECTOR_UNIT_2D_HPP(name); \
VECTOR_UNIT_3D_HPP(name); \
VECTOR_UNIT_ND_HPP(name)

Definition at line 288 of file vector_unit_3d.hpp.

Function Documentation

operator!=() [1/3]

bool operator!=	(	const scifir::vector_unit_3d &	x,
		const scifir::vector_unit_3d &	y
	)

Comparison operator. Two vector_unit_3d are not equal if their value, dimensions, theta or phi are different.

Definition at line 539 of file vector_unit_3d.cpp.

{
    return !(x == y);
}

operator!=() [2/3]

bool operator!=	(	const scifir::vector_unit_3d &	x,
		const string &	init_vector_3d
	)

Returns true if x is not equal to the vector_unit_3d initialized with the string being compared. The vectorial_display() function is not used, and so the values are compared with all its decimal numbers.

Definition at line 550 of file vector_unit_3d.cpp.

{
    return !(x == init_vector_3d);
}

operator!=() [3/3]

bool operator!=	(	const string &	init_vector_3d,
		const scifir::vector_unit_3d &	x
	)

Returns true if x is not equal to the vector_unit_3d initialized with the string being compared. The vectorial_display() function is not used, and so the values are compared with all its decimal numbers.

Definition at line 561 of file vector_unit_3d.cpp.

{
    return !(init_vector_3d == y);
}

operator*() [1/2]

scifir::vector_unit_3d operator*	(	const scifir::scalar_unit &	x,
		const scifir::vector_unit_3d &	y
	)

It creates a new vector_unit_3d scaling a vector_unit_3d by the scalar_unit x.

Definition at line 532 of file vector_unit_3d.cpp.

{
    long double new_value = x.get_value() * y.get_value();
    vector<scifir::dimension> new_dimensions = multiply_dimensions(x.get_dimensions(), y.get_dimensions(),new_value);
    return scifir::vector_unit_3d(float(new_value), new_dimensions, y.theta, y.phi);
}

operator*() [2/2]

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>

scifir::vector_unit_3d operator*	(	const T	y,
		const scifir::vector_unit_3d &	x
	)

It creates a new vector as the multiplication of the numeric type x to the value. Theta and phi are not changed.

Definition at line 504 of file vector_unit_3d.hpp.

{
    scifir::vector_unit_3d z = x;
    z *= y;
    return z;
}

operator+() [1/3]

string operator+	(	const scifir::vector_unit_3d &	y,
		const string &	x
	)

Creates a new string as the concatenation of the string x with the representation string of the vector_unit_3d y.

Definition at line 581 of file vector_unit_3d.cpp.

{
    ostringstream output;
    output << y;
    output << x;
    return output.str();
}

operator+() [2/3]

string operator+	(	const string &	x,
		const scifir::vector_unit_3d &	y
	)

Creates a new string as the concatenation of the string x with the representation string of the vector_unit_3d y.

Definition at line 573 of file vector_unit_3d.cpp.

{
    ostringstream output;
    output << x;
    output << y;
    return output.str();
}

operator+() [3/3]

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>

scifir::vector_unit_3d operator+	(	const T	y,
		const scifir::vector_unit_3d &	x
	)

It creates a new vector as the addition of the numeric type x to the value. Theta and phi are not changed.

Definition at line 490 of file vector_unit_3d.hpp.

{
    scifir::vector_unit_3d z = x;
    z += y;
    return z;
}

operator+=()

void operator+=	(	string &	x,
		const scifir::vector_unit_3d &	y
	)

Concatenates the string representation of the vector_unit_3d y to the string x.

Definition at line 566 of file vector_unit_3d.cpp.

{
    ostringstream output;
    output << y;
    x += output.str();
}

operator-()

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>

scifir::vector_unit_3d operator-	(	const T	y,
		const scifir::vector_unit_3d &	x
	)

It creates a new vector as the substraction of the numeric type x with the value. Theta and phi are not changed.

Definition at line 498 of file vector_unit_3d.hpp.

{
    return scifir::vector_unit_3d(y - x.get_value(),x.get_dimensions(),x.theta,x.phi);
}

operator/()

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>

scifir::vector_unit_3d operator/	(	const T	y,
		const scifir::vector_unit_3d &	x
	)

It creates a new vector as the division of the numeric type x with the value. Theta and phi are not changed.

Definition at line 512 of file vector_unit_3d.hpp.

{
    vector<scifir::dimension> new_dimensions = x.get_dimensions();
    for (scifir::dimension& new_dimension : new_dimensions)
    {
        new_dimension.invert();
    }
    return scifir::vector_unit_3d(y / x.get_value(),new_dimensions,x.theta,x.phi);
}

operator<<()

ostream & operator<<	(	ostream &	os,
		const scifir::vector_unit_3d &	x
	)

Adds the string representation of the vector_unit_3d x to an output stream os.

Definition at line 589 of file vector_unit_3d.cpp.

{
    return os << to_string(x);
}

operator==() [1/2]

bool operator==	(	const scifir::vector_unit_3d &	x,
		const string &	init_vector_3d
	)

Returns true if x is equal to the vector_unit_3d initialized with the string being compared. The vectorial_display() function is not used, and so the values are compared with all its decimal numbers.

Definition at line 544 of file vector_unit_3d.cpp.

{
    scifir::vector_unit_3d y(init_vector_3d);
    return (x == y);
}

operator==() [2/2]

bool operator==	(	const string &	init_vector_3d,
		const scifir::vector_unit_3d &	x
	)

Returns true if x is equal to the vector_unit_3d initialized with the string being compared. The vectorial_display() function is not used, and so the values are compared with all its decimal numbers.

Definition at line 555 of file vector_unit_3d.cpp.

{
    scifir::vector_unit_3d x(init_vector_3d);
    return (x == y);
}

operator>>()

istream & operator>>	(	istream &	is,
		scifir::vector_unit_3d &	x
	)

Allows that an istream initializes by string a vector_unit_3d x.

#endif // SCIFIR_UNITS_UNITS_VECTOR_UNIT_3D_HPP_INCLUDED

Definition at line 594 of file vector_unit_3d.cpp.

{
    char a[256];
    is.getline(a, 256);
    string b(a);
    boost::trim(b);
    x = scifir::vector_unit_3d(b);
    return is;
}