scalar_unit.hpp File Reference

#include "./dimension.hpp"
#include "./prefix.hpp"
#include "../util/is_number.hpp"
#include <cmath>
#include <map>
#include <string>
#include <iostream>
#include <sstream>
#include <string_view>
#include <vector>

Include dependency graph for scalar_unit.hpp:

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

Go to the source code of this file.

Classes
class	scifir::scalar_unit
	Class that allows to create scalar units, which are composed of a value (as a float) and dimensions. The dimensions can be of any number, and be simple dimensions, composite dimensions and/or special names of dimensions. All base and derived scalar unit classes inherit from scalar_unit. Initialization string example: "1 N". More...

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

Macros
#define	SCALAR_UNIT_HPP_BEGIN(name)
#define	SCALAR_UNIT_HPP_END()
#define	SCALAR_UNIT_HPP(name)
#define	SCALAR_UNIT_CPP(name, init_real_dimensions)

Functions
string	scifir::to_string (const scalar_unit &x)
	Generates a string representation of the scalar_unit, it uses the display of the scalar_unit with 2 decimals, without brackets and without a close prefix.
bool	scifir::is_scalar_unit (const string &init_scalar)
	Checks if an string is an initialization string of a scalar_unit.
float	scifir::abs (const scalar_unit &x)
	Returns the absolute value of the scalar_unit, without dimensions.
scalar_unit	scifir::pow (const scalar_unit &x, int exponent)
	Exponentiates a scalar_unit to some numeric type, the dimensions are also exponentiated.
scalar_unit	scifir::sqrt (const scalar_unit &x)
	Square root of a scalar_unit, it squares the dimensions too.
scalar_unit	scifir::sqrt_nth (const scalar_unit &x, int index)
	Nth root of a scalar_unit to any numeric value, it squares the dimensions too.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scifir::scalar_unit	operator+ (const T &y, const scifir::scalar_unit &x)
	Sums a numeric type y with an scalar_unit x, returns that result as a new scalar_unit with the same dimensions of x.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scifir::scalar_unit	operator- (const T &y, const scifir::scalar_unit &x)
	Substracts a scalar_unit x to a numeric type y, returns that result as a new scalar_unit with the same dimensions of x.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scifir::scalar_unit	operator* (const T &y, const scifir::scalar_unit &x)
	Multiplies a numeric type y with an scalar_unit x, returns that result as a new scalar_unit with the same dimensions of x.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scifir::scalar_unit	operator/ (const T &y, const scifir::scalar_unit &x)
	Divides a numeric type y with an scalar_unit x, returns that result as a new scalar_unit with the same dimensions of x.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
float	operator^ (const T &x, const scifir::scalar_unit &y)
	Exponentiates a numeric type x with a scalar_unit y, only if that scalar_unit as empty dimensions, returns a float as the result of the calculation.
bool	operator!= (const scifir::scalar_unit &x, scifir::scalar_unit y)
	Returns true if two scalar_unit classes doesn't have the same value when changed to same dimensions. If their basic dimensions are different, it returns false.
bool	operator< (const scifir::scalar_unit &x, const scifir::scalar_unit &y)
	Returns true if x has a lower value than y, compared with the same dimensions. If their dimensions are not equal, they are changed to be equal in order to do the comparison.
bool	operator> (const scifir::scalar_unit &x, const scifir::scalar_unit &y)
	Returns true if x has a greather value than y, compared with the same dimensions. If their dimensions are not equal, they are changed to be equal in order to do the comparison.
bool	operator<= (const scifir::scalar_unit &x, const scifir::scalar_unit &y)
	Returns true if x has a lower or equal value than y, compared with the same dimensions. If their dimensions are not equal, they are changed to be equal in order to do the comparison.
bool	operator>= (const scifir::scalar_unit &x, const scifir::scalar_unit &y)
	Returns true if x has a greather or equal value than y, compared with the same dimensions. If their dimensions are not equal, they are changed to be equal in order to do the comparison.
bool	operator== (const scifir::scalar_unit &x, const string &init_scalar)
	Returns true if x is equal to the scalar_unit initialized with the string being compared. The display() function is not used, and so the values are compared with all its decimal numbers.
bool	operator!= (const scifir::scalar_unit &x, const string &init_scalar)
	Returns true if x is not equal to the scalar_unit initialized with the string being compared. The display() function is not used, and so the values are compared with all its decimal numbers.
bool	operator< (const scifir::scalar_unit &x, const string &init_scalar)
	Returns true if x is lower than the scalar_unit initialized with the string being compared.
bool	operator> (const scifir::scalar_unit &x, const string &init_scalar)
	Returns true if x is greather than the scalar_unit initialized with the string being compared.
bool	operator<= (const scifir::scalar_unit &x, const string &init_scalar)
	Returns true if x is lower or equal to the scalar_unit initialized with the string being compared.
bool	operator>= (const scifir::scalar_unit &x, const string &init_scalar)
	Returns true if x is greather or equal to the scalar_unit initialized with the string being compared.
bool	operator== (const string &init_scalar, const scifir::scalar_unit &x)
	Returns true if x is equal to the scalar_unit initialized with the string being compared. The display() function is not used, and so the values are compared with all its decimal numbers.
bool	operator!= (const string &init_scalar, const scifir::scalar_unit &x)
	Returns true if x is not equal to the scalar_unit initialized with the string being compared. The display() function is not used, and so the values are compared with all its decimal numbers.
bool	operator< (const string &init_scalar, const scifir::scalar_unit &x)
	Returns true if x is greather than the scalar_unit initialized with the string being compared.
bool	operator> (const string &init_scalar, const scifir::scalar_unit &x)
	Returns true if x is lower than the scalar_unit initialized with the string being compared.
bool	operator<= (const string &init_scalar, const scifir::scalar_unit &x)
	Returns true if x is greather or equal to the scalar_unit initialized with the string being compared.
bool	operator>= (const string &init_scalar, const scifir::scalar_unit &x)
	Returns true if x is lower or equal to the scalar_unit initialized with the string being compared.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator== (const T &x, const scifir::scalar_unit &y)
	Returns true if the value of the scalar_unit is equal to the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator!= (const T &x, const scifir::scalar_unit &y)
	Returns true if the value of the scalar_unit is not equal to the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator< (const T &x, const scifir::scalar_unit &y)
	Returns true if the value of y is greather than the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator> (const T &x, const scifir::scalar_unit &y)
	Returns true if the value of y is lower than the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator<= (const T &x, const scifir::scalar_unit &y)
	Returns true if the value of y is lower or equal than the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator>= (const T &x, const scifir::scalar_unit &y)
	Returns true if the value of y is equal or greather than the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator== (const scifir::scalar_unit &x, const T &y)
	Returns true if the value of the scalar_unit is equal to the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator!= (const scifir::scalar_unit &x, const T &y)
	Returns true if the value of the scalar_unit is not equal to the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator< (const scifir::scalar_unit &x, const T &y)
	Returns true if the value of x is lower than the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator> (const scifir::scalar_unit &x, const T &y)
	Returns true if the value of x is greather than the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator<= (const scifir::scalar_unit &x, const T &y)
	Returns true if the value of x is lower or equal than the numeric type, ignoring the dimensions.
template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
bool	operator>= (const scifir::scalar_unit &x, const T &y)
	Returns true if the value of x is equal or greather than the numeric type, ignoring the dimensions.
void	operator+= (string &x, const scifir::scalar_unit &y)
	Concatenates the string representation of the scalar_unit y to the string x.
string	operator+ (const string &x, const scifir::scalar_unit &y)
	Creates a new string as the concatenation of the string x with the representation string of the scalar_unit y.
string	operator+ (const scifir::scalar_unit &y, const string &x)
	Creates a new string as the concatenation of the string x with the representation string of the scalar_unit y.
ostream &	operator<< (ostream &os, const scifir::scalar_unit &x)
	Adds the string representation of the scalar_unit x to an output stream os.
istream &	operator>> (istream &is, scifir::scalar_unit &x)
	Allows that an istream initializes by string a scalar_unit x.

Macro Definition Documentation

SCALAR_UNIT_CPP

#define SCALAR_UNIT_CPP	(		name,
			init_real_dimensions
	)

Definition at line 81 of file scalar_unit.hpp.

                                                              : scalar_unit() { \
    scalar_unit::dimensions = name::real_dimensions; \
} \
\
    name::name(const name& x) : scalar_unit()  \
    { \
        value = x.get_value(); \
        dimensions = x.get_dimensions(); \
    } \
\
    name::name(name&& x) : scalar_unit() \
    { \
        value = std::move(x.get_value()); \
        dimensions = std::move(x.get_dimensions()); \
    } \
\
    name::name(float new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position) : scalar_unit(new_value,new_dimension,new_prefix,new_position) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(double new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position) : scalar_unit(new_value,new_dimension,new_prefix,new_position) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(long double new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position) : scalar_unit(new_value,new_dimension,new_prefix,new_position) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(int new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position) : scalar_unit(new_value,new_dimension,new_prefix,new_position) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(float new_value, const string& init_dimensions) : scalar_unit(new_value,init_dimensions) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(double new_value, const string& init_dimensions) : scalar_unit(new_value,init_dimensions) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(long double new_value, const string& init_dimensions) : scalar_unit(new_value,init_dimensions) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(int new_value, const string& init_dimensions) : scalar_unit(new_value,init_dimensions) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(float new_value, const vector<dimension>& new_dimensions) : scalar_unit(new_value,new_dimensions) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(double new_value, const vector<dimension>& new_dimensions) : scalar_unit(new_value,new_dimensions) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(long double new_value, const vector<dimension>& new_dimensions) : scalar_unit(new_value,new_dimensions) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(int new_value, const vector<dimension>& new_dimensions) : scalar_unit(new_value,new_dimensions) \
    { \
        scalar_unit::check_dimensions(name::real_dimensions); \
    } \
\
    name::name(const string& init_scalar) : scalar_unit() \
    { \
        initialize_from_string(init_scalar,name::real_dimensions); \
    } \
\
    name::name(const scalar_unit& x) : scalar_unit()  \
    { \
        if (x.has_dimensions(name::real_dimensions)) \
        { \
            value = x.get_value(); \
            dimensions = x.get_dimensions(); \
        } \
    } \
\
    name::name(scalar_unit&& x) : scalar_unit()  \
    { \
        if (x.has_dimensions(name::real_dimensions)) \
        { \
            value = std::move(x.get_value()); \
            dimensions = std::move(x.get_dimensions()); \
        } \
    } \
\
    name& name::operator =(const name& x) \
    { \
        value = x.get_value(); \
        dimensions = x.get_dimensions(); \
        return *this; \
    } \
\
    name& name::operator =(name&& x) \
    { \
        value = std::move(x.get_value()); \
        dimensions = std::move(x.get_dimensions()); \
        return *this; \
    } \
\
const string name::dimensions_match = init_real_dimensions; \
const vector<dimension> name::real_dimensions = create_base_dimensions(init_real_dimensions)

SCALAR_UNIT_HPP

#define SCALAR_UNIT_HPP

(

name

)

Value:

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

Definition at line 50 of file scalar_unit.hpp.

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

SCALAR_UNIT_HPP_BEGIN

#define SCALAR_UNIT_HPP_BEGIN

(

name

)

Value:

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

Definition at line 16 of file scalar_unit.hpp.

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

SCALAR_UNIT_HPP_END

#define SCALAR_UNIT_HPP_END

(

)

Value:

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

Definition at line 43 of file scalar_unit.hpp.

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

Function Documentation

operator!=() [1/5]

bool operator!=	(	const scifir::scalar_unit &	x,
		const string &	init_scalar
	)

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

Definition at line 1021 of file scalar_unit.cpp.

{
    return !(x == init_scalar);
}

operator!=() [2/5]

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

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

Returns true if the value of the scalar_unit is not equal to the numeric type, ignoring the dimensions.

Definition at line 641 of file scalar_unit.hpp.

{
    return !(x == y);
}

operator!=() [3/5]

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

Returns true if two scalar_unit classes doesn't have the same value when changed to same dimensions. If their basic dimensions are different, it returns false.

Definition at line 964 of file scalar_unit.cpp.

{
    return !(x == y);
}

operator!=() [4/5]

bool operator!=	(	const string &	init_scalar,
		const scifir::scalar_unit &	x
	)

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

Definition at line 1053 of file scalar_unit.cpp.

{
    return (x != init_scalar);
}

operator!=() [5/5]

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

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

Returns true if the value of the scalar_unit is not equal to the numeric type, ignoring the dimensions.

Definition at line 605 of file scalar_unit.hpp.

{
    return !(x == y);
}

operator*()

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

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

Multiplies a numeric type y with an scalar_unit x, returns that result as a new scalar_unit with the same dimensions of x.

Definition at line 551 of file scalar_unit.hpp.

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

operator+() [1/3]

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

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

Definition at line 1095 of file scalar_unit.cpp.

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

operator+() [2/3]

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

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

Definition at line 1087 of file scalar_unit.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::scalar_unit operator+	(	const T &	y,
		const scifir::scalar_unit &	x
	)

Sums a numeric type y with an scalar_unit x, returns that result as a new scalar_unit with the same dimensions of x.

Definition at line 535 of file scalar_unit.hpp.

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

operator+=()

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

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

Definition at line 1080 of file scalar_unit.cpp.

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

operator-()

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

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

Substracts a scalar_unit x to a numeric type y, returns that result as a new scalar_unit with the same dimensions of x.

Definition at line 543 of file scalar_unit.hpp.

{
    scifir::scalar_unit z = scifir::scalar_unit((long double)y,x.get_dimensions());
    z -= x;
    return z;
}

operator/()

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

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

Divides a numeric type y with an scalar_unit x, returns that result as a new scalar_unit with the same dimensions of x.

Definition at line 559 of file scalar_unit.hpp.

{
    scifir::scalar_unit z = scifir::scalar_unit((long double)y,vector<scifir::dimension>());
    return z / x;
}

operator<() [1/5]

bool operator<	(	const scifir::scalar_unit &	x,
		const scifir::scalar_unit &	y
	)

Returns true if x has a lower value than y, compared with the same dimensions. If their dimensions are not equal, they are changed to be equal in order to do the comparison.

Definition at line 969 of file scalar_unit.cpp.

{
    if(!x.has_dimensions(y))
    {
        return false;
    }
    scifir::scalar_unit z = x;
    z.change_dimensions(y);
    if(z.get_value() < y.get_value())
    {
        return true;
    }
    else
    {
        return false;
    }
}

operator<() [2/5]

bool operator<	(	const scifir::scalar_unit &	x,
		const string &	init_scalar
	)

Returns true if x is lower than the scalar_unit initialized with the string being compared.

Definition at line 1026 of file scalar_unit.cpp.

{
    scifir::scalar_unit y(init_scalar);
    return (x < y);
}

operator<() [3/5]

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

bool operator<	(	const scifir::scalar_unit &	x,
		const T &	y
	)

Returns true if the value of x is lower than the numeric type, ignoring the dimensions.

Definition at line 647 of file scalar_unit.hpp.

{
    return (x.get_value() < y);
}

operator<() [4/5]

bool operator<	(	const string &	init_scalar,
		const scifir::scalar_unit &	x
	)

Returns true if x is greather than the scalar_unit initialized with the string being compared.

Definition at line 1058 of file scalar_unit.cpp.

{
    scifir::scalar_unit y(init_scalar);
    return (y < x);
}

operator<() [5/5]

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

bool operator<	(	const T &	x,
		const scifir::scalar_unit &	y
	)

Returns true if the value of y is greather than the numeric type, ignoring the dimensions.

Definition at line 611 of file scalar_unit.hpp.

{
    return (x < y.get_value());
}

operator<<()

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

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

Definition at line 1103 of file scalar_unit.cpp.

{
    return os << to_string(x);
}

operator<=() [1/5]

bool operator<=	(	const scifir::scalar_unit &	x,
		const scifir::scalar_unit &	y
	)

Returns true if x has a lower or equal value than y, compared with the same dimensions. If their dimensions are not equal, they are changed to be equal in order to do the comparison.

Definition at line 1005 of file scalar_unit.cpp.

{
    return !(x > y);
}

operator<=() [2/5]

bool operator<=	(	const scifir::scalar_unit &	x,
		const string &	init_scalar
	)

Returns true if x is lower or equal to the scalar_unit initialized with the string being compared.

Definition at line 1038 of file scalar_unit.cpp.

{
    return !(x > init_scalar);
}

operator<=() [3/5]

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

bool operator<=	(	const scifir::scalar_unit &	x,
		const T &	y
	)

Returns true if the value of x is lower or equal than the numeric type, ignoring the dimensions.

Definition at line 659 of file scalar_unit.hpp.

{
    return (x.get_value() <= y);
}

operator<=() [4/5]

bool operator<=	(	const string &	init_scalar,
		const scifir::scalar_unit &	x
	)

Returns true if x is greather or equal to the scalar_unit initialized with the string being compared.

Definition at line 1070 of file scalar_unit.cpp.

{
    return !(init_scalar > x);
}

operator<=() [5/5]

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

bool operator<=	(	const T &	x,
		const scifir::scalar_unit &	y
	)

Returns true if the value of y is lower or equal than the numeric type, ignoring the dimensions.

Definition at line 623 of file scalar_unit.hpp.

{
    return (x <= y.get_value());
}

operator==() [1/4]

bool operator==	(	const scifir::scalar_unit &	x,
		const string &	init_scalar
	)

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

Definition at line 1015 of file scalar_unit.cpp.

{
    scifir::scalar_unit y(init_scalar);
    return (x == y);
}

operator==() [2/4]

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

bool operator==	(	const scifir::scalar_unit &	x,
		const T &	y
	)

Returns true if the value of the scalar_unit is equal to the numeric type, ignoring the dimensions.

Definition at line 635 of file scalar_unit.hpp.

{
    return (x.get_value() == y);
}

operator==() [3/4]

bool operator==	(	const string &	init_scalar,
		const scifir::scalar_unit &	x
	)

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

Definition at line 1048 of file scalar_unit.cpp.

{
    return (x == init_scalar);
}

operator==() [4/4]

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

bool operator==	(	const T &	x,
		const scifir::scalar_unit &	y
	)

Returns true if the value of the scalar_unit is equal to the numeric type, ignoring the dimensions.

Definition at line 599 of file scalar_unit.hpp.

{
    return (x == y.get_value());
}

operator>() [1/5]

bool operator>	(	const scifir::scalar_unit &	x,
		const scifir::scalar_unit &	y
	)

Returns true if x has a greather value than y, compared with the same dimensions. If their dimensions are not equal, they are changed to be equal in order to do the comparison.

Definition at line 987 of file scalar_unit.cpp.

{
    if(!x.has_dimensions(y))
    {
        return false;
    }
    scifir::scalar_unit z = x;
    z.change_dimensions(y);
    if(z.get_value() > y.get_value())
    {
        return true;
    }
    else
    {
        return false;
    }
}

operator>() [2/5]

bool operator>	(	const scifir::scalar_unit &	x,
		const string &	init_scalar
	)

Returns true if x is greather than the scalar_unit initialized with the string being compared.

Definition at line 1032 of file scalar_unit.cpp.

{
    scifir::scalar_unit y(init_scalar);
    return (x > y);
}

operator>() [3/5]

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

bool operator>	(	const scifir::scalar_unit &	x,
		const T &	y
	)

Returns true if the value of x is greather than the numeric type, ignoring the dimensions.

Definition at line 653 of file scalar_unit.hpp.

{
    return (x.get_value() > y);
}

operator>() [4/5]

bool operator>	(	const string &	init_scalar,
		const scifir::scalar_unit &	x
	)

Returns true if x is lower than the scalar_unit initialized with the string being compared.

Definition at line 1064 of file scalar_unit.cpp.

{
    scifir::scalar_unit y(init_scalar);
    return (y > x);
}

operator>() [5/5]

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

bool operator>	(	const T &	x,
		const scifir::scalar_unit &	y
	)

Returns true if the value of y is lower than the numeric type, ignoring the dimensions.

Definition at line 617 of file scalar_unit.hpp.

{
    return (x > y.get_value());
}

operator>=() [1/5]

bool operator>=	(	const scifir::scalar_unit &	x,
		const scifir::scalar_unit &	y
	)

Returns true if x has a greather or equal value than y, compared with the same dimensions. If their dimensions are not equal, they are changed to be equal in order to do the comparison.

Definition at line 1010 of file scalar_unit.cpp.

{
    return !(x < y);
}

operator>=() [2/5]

bool operator>=	(	const scifir::scalar_unit &	x,
		const string &	init_scalar
	)

Returns true if x is greather or equal to the scalar_unit initialized with the string being compared.

Definition at line 1043 of file scalar_unit.cpp.

{
    return !(x < init_scalar);
}

operator>=() [3/5]

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

bool operator>=	(	const scifir::scalar_unit &	x,
		const T &	y
	)

Returns true if the value of x is equal or greather than the numeric type, ignoring the dimensions.

Definition at line 665 of file scalar_unit.hpp.

{
    return (x.get_value() >= y);
}

operator>=() [4/5]

bool operator>=	(	const string &	init_scalar,
		const scifir::scalar_unit &	x
	)

Returns true if x is lower or equal to the scalar_unit initialized with the string being compared.

Definition at line 1075 of file scalar_unit.cpp.

{
    return !(init_scalar < x);
}

operator>=() [5/5]

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

bool operator>=	(	const T &	x,
		const scifir::scalar_unit &	y
	)

Returns true if the value of y is equal or greather than the numeric type, ignoring the dimensions.

Definition at line 629 of file scalar_unit.hpp.

{
    return (x >= y.get_value());
}

operator>>()

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

Allows that an istream initializes by string a scalar_unit x.

Definition at line 1108 of file scalar_unit.cpp.

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

operator^()

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

float operator^	(	const T &	x,
		const scifir::scalar_unit &	y
	)

Exponentiates a numeric type x with a scalar_unit y, only if that scalar_unit as empty dimensions, returns a float as the result of the calculation.

Definition at line 566 of file scalar_unit.hpp.

{
    if(y.has_empty_dimensions())
    {
        return std::pow(x, y.get_value());
    }
    else
    {
        return 0;
    }
}