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...

#include <scalar_unit.hpp>

Inheritance diagram for scifir::scalar_unit:

[legend]

Public Member Functions
	scalar_unit ()
	Default constructor, the value is 0 and the dimensions are empty.

	scalar_unit (const scalar_unit &x)
	Copy constructor, copies the value and the dimensions.

	scalar_unit (scalar_unit &&x)
	Move constructor, moves the value and the dimensions.

	scalar_unit (float new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position=dimension::NUMERATOR)

	scalar_unit (double new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position=dimension::NUMERATOR)

	scalar_unit (long double new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position=dimension::NUMERATOR)

	scalar_unit (int new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position=dimension::NUMERATOR)

	scalar_unit (float new_value, const string &init_dimensions)
	Creates a new scalar_unit with the value and with the dimensions specified in the string.

	scalar_unit (double new_value, const string &init_dimensions)
	Creates a new scalar_unit, the double is casted to a float.

	scalar_unit (long double new_value, const string &init_dimensions)
	Creates a new scalar_unit, the long double is casted to a float.

	scalar_unit (int new_value, const string &init_dimensions)
	Creates a new scalar_unit, the int is casted to a float.

	scalar_unit (float new_value, const vector< dimension > &new_dimensions)
	Creates a new scalar_unit with the value given and copying the dimensions.

	scalar_unit (double new_value, const vector< dimension > &new_dimensions)
	Creates a new scalar_unit, the double is casted to a float, the dimensions are copied.

	scalar_unit (long double new_value, const vector< dimension > &new_dimensions)
	Creates a new scalar_unit, the long double is casted to a float, the dimensions are copied.

	scalar_unit (int new_value, const vector< dimension > &new_dimensions)
	Creates a new scalar_unit, the int is casted to a float, the dimensions are copied.

	scalar_unit (const string &init_scalar)
	Creates a new scalar_unit, the initialization string specifies both the value and the dimensions.

scalar_unit &	operator= (const scalar_unit &x)
	Copy assignment, it assigns a copy of the scalar_unit.

scalar_unit &	operator= (scalar_unit &&x)
	Move assignment, it moves the scalar_unit.

scalar_unit &	operator= (const string &init_scalar)
	Assignment with an initialization string, the value and the dimensions are both specified.

	operator float () const
	Cast the scalar_unit to their float equivalent, it discards the dimensions and copies the value to a float.

bool	operator== (scalar_unit x) const
	Comparison operator, two scalar_unit classes are considered equivalent if they have the same value given the same dimensions.

scalar_unit	operator+ (scalar_unit x) const
	Addition operator, it sums two scalar_unit classes, their dimensions are changed to be equal first. If the basic dimensions are different, it returns an empty scalar_unit class.

scalar_unit	operator- (scalar_unit x) const
	Substraction operator, it substracts one scalar_unit from the other, their dimensions are changed to be equal first. If the basic dimensions are different, it returns an empty scalar_unit class.

scalar_unit	operator* (scalar_unit x) const
	Multiplication operator, it multiplies two scalar_unit classes, their dimensions are also multiplied.

scalar_unit	operator/ (scalar_unit x) const
	Division operator, it divides one scalar_unit class with the other, their dimensions are also divided.

scalar_unit	operator^ (const scalar_unit &x) const
	Power operator, it powers a scalar_unit class with another, if that second scalar_unit class, which is the exponent, as empty dimensions. If the exponent doesn't has empty dimensions it returns an empty scalar_unit class.

void	operator+= (scalar_unit x)
	Addition operator, it adds a scalar_unit class to another, by converting their dimensions to be equal first. If their basic dimensions are different, it doesn't sums to the value.

void	operator-= (scalar_unit x)
	Substraction operator, it substracts a scalar_unit class to another, by converting their dimensions to be equal first. If their basic dimensions are different, it doesn't substracts to the value.

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scalar_unit	operator+ (T y) const
	Addition operator, it sums the numeric type to the value, independent of the dimensions.

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scalar_unit	operator- (T y) const
	Substraction operator, it substracts the numeric type to the value, independent of the dimensions.

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scalar_unit	operator* (T y) const
	Multiplication operator, it multiplies the numeric type with the value, independent of the dimensions.

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
scalar_unit	operator/ (T y) const
	Division operator, it divides the value with the numeric type, independent of the dimensions.

template<typename T , typename = typename enable_if<is_integer_number<T>::value>::type>
scalar_unit	operator^ (T y) const
	Power operator, it powers the value with the numeric type, independent of the dimensions.

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
void	operator+= (T y)
	Addition operator, it adds the numeric type to the value, independent of the dimensions.

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
void	operator-= (T y)
	Substraction operator, it substracts the numeric type to the value, independent of the dimensions.

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
void	operator*= (T y)
	Multiplication operator, it multiplies the numeric type to the value, independent of the dimensions.

template<typename T , typename = typename enable_if<scifir::is_number<T>::value>::type>
void	operator/= (T y)
	Division operator, it divides the numeric type to the value, independent of the dimensions.

scalar_unit &	operator++ ()
	Increment operator, it increases the value by one.

scalar_unit &	operator++ (int)
	Increment operator, it increases the value by one.

scalar_unit &	operator-- ()
	Decrement operator, it decreases the value by one.

scalar_unit &	operator-- (int)
	Decrement operator, it decreases the value by one.

void	change_dimensions (const string &init_dimensions)
	Changes the dimensions to the dimensions specified by the initialization string of dimensions.

void	change_dimensions (const scalar_unit &x)
	Changes the dimensions to the same dimensions of the scalar_unit.

bool	has_dimensions (const string &init_dimensions) const
	Checks if the basic dimensions are the same as the initialization string of dimensions.

bool	has_dimensions (const vector< dimension > &x_dimensions) const
	Checks if the basic dimensions are the same as some set of dimensions.

bool	has_dimensions (const scalar_unit &x) const
	Checks if the basic dimensions are the same as other scalar_unit.

bool	has_empty_dimensions () const
	Checks if there aren't base dimensions.

bool	is_dimensionless () const
	Returns true if there aren't dimensions or if all dimensions are dimensionless.

bool	has_simple_dimensions () const
	Returns true if there's only a simple dimension.

bool	has_single_dimensions () const
	Returns true if there's only one dimension, which can be simple or composite.

bool	has_composite_dimensions () const
	Returns true is there's more than one simple dimension.

string	display_dimensions () const
	Generates an string of the dimensions of the scalar_unit, with the same format as the initialization string of dimensions.

dimension::type	get_single_dimension_type () const
	Returns the dimension::type if there's only one dimension, returns dimension::NONE if there's more than one dimension or if the dimensions are empty.

vector< dimension >	get_base_dimensions () const
	Generates a set of the base dimensions of the dimensions of the scalar_unit.

const vector< dimension > &	get_dimensions () const
	Read-only getter of the dimensions.

const float &	get_value () const
	Read-only getter of the value.

string	display (int number_of_decimals=2, bool with_brackets=false, bool use_close_prefix=false) const
	Generates a string representation of the scalar_unit, with the value and the dimensions. The dimensions can be enclosed by brackets, and the value can be set to have the closest prefix.

string	base_display (int number_of_decimals=2, bool with_brackets=false, bool use_close_prefix=false) const
	Generates a string representation of the scalar_unit, with its dimensions converted to their base counterpart.

string	custom_display (const string &init_dimensions, int number_of_decimals=2, bool with_brackets=false) const
	Generates a string representation of the scalar_unit, with the dimensions changed to any set of dimensions, specified by an initialization string of dimensions.

string	to_latex (const string &init_dimensions, int number_of_decimals=2, bool with_brackets=false) const

Protected Member Functions
void	add_dimension (const dimension &new_dimension)
	Internal function. It adds a dimension, changing the value according to the conversion factor of the added dimension and the prefix.

void	remove_dimension (const dimension &old_dimension)
	Internal function. It removes a dimension, changing the value according to the conversion factor of the removed dimension and the prefix.

void	initialize_from_string (string init_scalar, const vector< dimension > &real_dimensions)
	Internal function. It sets the value and the dimensions of the scalar_unit to the value and dimensions specified by the initialization string of scalar_unit.

void	check_dimensions (const vector< dimension > &real_dimensions)

Protected Attributes
vector< dimension >	dimensions
	Dimensions of the scalar_unit. They can be simple dimensions, composite dimensions or special names.

float	value
	Value of the scalar_unit. It changes automatically when the dimensions change.

Detailed Description

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".

scalar_unit is a class that allows to have a scalar unit, which is composed of a value and one or more dimensions. All dimensions of the SI system of units are supported, and also all of its special names. The special names can be converted to its equivalent dimensions, too. scalar_unit classes have operators with all numeric types, and have operators with themselves. They can be displayed by its dimensions, its base dimensions, or any custom combination of dimensions. When they change dimensions, like, for example, from meters to kilometers, their numeric value is changed accordingly. POSSIBLE FEATURES At the present scalar_unit classes use a vector<dimension> to allow to have any number of dimensions, which can be simple, composite or special names. In order to size less, it's possible for some scalar_unit classes to have only one dimension, instead of a vector, that saves memory. With that approach, the dimension needs only 3 bytes. The possibility to switch between a single dimension and a vector<dimension> doesn't yet exists in C++, and so this important feature has been postposed.

Definition at line 201 of file scalar_unit.hpp.

Constructor & Destructor Documentation

◆ scalar_unit() [1/16]

scalar_unit::scalar_unit ( )

Default constructor, the value is 0 and the dimensions are empty.

Definition at line 23 of file scalar_unit.cpp.

23 : dimensions(),value(0.0f)

24 {}

scifir::scalar_unit::dimensions

vector< dimension > dimensions

Dimensions of the scalar_unit. They can be simple dimensions, composite dimensions or special names.

Definition scalar_unit.hpp:338

scifir::scalar_unit::value

float value

Value of the scalar_unit. It changes automatically when the dimensions change.

Definition scalar_unit.hpp:339

◆ scalar_unit() [2/16]

scalar_unit::scalar_unit ( const scalar_unit & x )

Copy constructor, copies the value and the dimensions.

Parameters

x	scalar_unit to be copied.

Definition at line 26 of file scalar_unit.cpp.

26 : dimensions(x.get_dimensions()),value(x.get_value())

27 {}

◆ scalar_unit() [3/16]

scalar_unit::scalar_unit ( scalar_unit && x )

Move constructor, moves the value and the dimensions.

Parameters

x	scalar_unit to be moved.

Definition at line 29 of file scalar_unit.cpp.

29 : dimensions(std::move(x.get_dimensions())),value(std::move(x.get_value()))

30 {}

◆ scalar_unit() [4/16]

scifir::scalar_unit::scalar_unit	(	float	new_value,
		dimension::type	new_dimension,
		prefix::type	new_prefix,
		dimension::position	new_position = `dimension::NUMERATOR`
	)

explicit

Definition at line 32 of file scalar_unit.cpp.

32 : dimensions({ dimension(new_dimension,new_prefix,new_position) }),value(new_value)

33 {}

◆ scalar_unit() [5/16]

scifir::scalar_unit::scalar_unit	(	double	new_value,
		dimension::type	new_dimension,
		prefix::type	new_prefix,
		dimension::position	new_position = `dimension::NUMERATOR`
	)

explicit

Definition at line 35 of file scalar_unit.cpp.

35 : dimensions({ dimension(new_dimension,new_prefix,new_position) }),value(float(new_value))

36 {}

◆ scalar_unit() [6/16]

scifir::scalar_unit::scalar_unit	(	long double	new_value,
		dimension::type	new_dimension,
		prefix::type	new_prefix,
		dimension::position	new_position = `dimension::NUMERATOR`
	)

explicit

Definition at line 38 of file scalar_unit.cpp.

38 : dimensions({ dimension(new_dimension,new_prefix,new_position) }),value(float(new_value))

39 {}

◆ scalar_unit() [7/16]

scifir::scalar_unit::scalar_unit	(	int	new_value,
		dimension::type	new_dimension,
		prefix::type	new_prefix,
		dimension::position	new_position = `dimension::NUMERATOR`
	)

explicit

Definition at line 41 of file scalar_unit.cpp.

41 : dimensions({ dimension(new_dimension,new_prefix,new_position) }),value(float(new_value))

42 {}

◆ scalar_unit() [8/16]

scalar_unit::scalar_unit	(	float	new_value,
		const string &	init_dimensions
	)

explicit

Creates a new scalar_unit with the value and with the dimensions specified in the string.

Definition at line 44 of file scalar_unit.cpp.

44 : dimensions(create_dimensions(init_dimensions)),value(new_value)

45 {}

scifir::create_dimensions

vector< dimension > create_dimensions(string init_dimensions)

Creates the dimensions from an initialization string of dimensions.

Definition dimension.cpp:1921

◆ scalar_unit() [9/16]

scalar_unit::scalar_unit	(	double	new_value,
		const string &	init_dimensions
	)

explicit

Creates a new scalar_unit, the double is casted to a float.

Definition at line 47 of file scalar_unit.cpp.

47 : dimensions(create_dimensions(init_dimensions)),value(float(new_value))

48 {}

◆ scalar_unit() [10/16]

scalar_unit::scalar_unit	(	long double	new_value,
		const string &	init_dimensions
	)

explicit

Creates a new scalar_unit, the long double is casted to a float.

Definition at line 50 of file scalar_unit.cpp.

50 : dimensions(create_dimensions(init_dimensions)),value(float(new_value))

51 {}

◆ scalar_unit() [11/16]

scalar_unit::scalar_unit	(	int	new_value,
		const string &	init_dimensions
	)

explicit

Creates a new scalar_unit, the int is casted to a float.

Definition at line 53 of file scalar_unit.cpp.

53 : dimensions(create_dimensions(init_dimensions)),value(float(new_value))

54 {}

◆ scalar_unit() [12/16]

scalar_unit::scalar_unit	(	float	new_value,
		const vector< dimension > &	new_dimensions
	)

explicit

Creates a new scalar_unit with the value given and copying the dimensions.

Definition at line 56 of file scalar_unit.cpp.

56 : dimensions(new_dimensions),value(new_value)

57 {}

◆ scalar_unit() [13/16]

scalar_unit::scalar_unit	(	double	new_value,
		const vector< dimension > &	new_dimensions
	)

explicit

Creates a new scalar_unit, the double is casted to a float, the dimensions are copied.

Definition at line 59 of file scalar_unit.cpp.

59 : dimensions(new_dimensions),value(float(new_value))

60 {}

◆ scalar_unit() [14/16]

scalar_unit::scalar_unit	(	long double	new_value,
		const vector< dimension > &	new_dimensions
	)

explicit

Creates a new scalar_unit, the long double is casted to a float, the dimensions are copied.

Definition at line 62 of file scalar_unit.cpp.

62 : dimensions(new_dimensions),value(float(new_value))

63 {}

◆ scalar_unit() [15/16]

scalar_unit::scalar_unit	(	int	new_value,
		const vector< dimension > &	new_dimensions
	)

explicit

Creates a new scalar_unit, the int is casted to a float, the dimensions are copied.

Definition at line 65 of file scalar_unit.cpp.

65 : dimensions(new_dimensions),value(float(new_value))

66 {}

◆ scalar_unit() [16/16]

scalar_unit::scalar_unit ( const string & init_scalar )

explicit

Creates a new scalar_unit, the initialization string specifies both the value and the dimensions.

Definition at line 68 of file scalar_unit.cpp.

                                                      : scalar_unit()
    {
        initialize_from_string(init_scalar,vector<dimension>());
    }

Member Function Documentation

◆ add_dimension()

void scalar_unit::add_dimension ( const dimension & new_dimension )

protected

Internal function. It adds a dimension, changing the value according to the conversion factor of the added dimension and the prefix.

Definition at line 664 of file scalar_unit.cpp.

    {
        if (new_dimension.dimension_position == dimension::NUMERATOR)
        {
            value /= float(new_dimension.get_conversion_factor());
            value /= float(new_dimension.prefix_math());
        }
        else if (new_dimension.dimension_position == dimension::DENOMINATOR)
        {
            value *= float(new_dimension.get_conversion_factor());
            value *= float(new_dimension.prefix_math());
        }
    }

◆ base_display()

string scalar_unit::base_display	(	int	number_of_decimals = `2`,
		bool	with_brackets = `false`,
		bool	use_close_prefix = `false`
	)		const

Generates a string representation of the scalar_unit, with its dimensions converted to their base counterpart.

Definition at line 475 of file scalar_unit.cpp.

    {
        ostringstream output;
        long double x_value = get_value();
        vector<dimension> base_dimensions = create_base_dimensions(dimensions,x_value);
        if (base_dimensions.size() == 1 and use_close_prefix == true)
        {
            int value_scale = int(log10(get_value()));
            prefix display_prefix = closest_prefix(base_dimensions[0].prefix,value_scale);
            x_value *= base_dimensions[0].prefix_math();
            x_value /= base_dimensions[0].prefix_math(display_prefix);
            vector<dimension> x_dimensions = base_dimensions;
            x_dimensions[0].prefix = display_prefix;
            output << display_float(float(x_value),number_of_decimals) << " " << to_string(base_dimensions,with_brackets);
        }
        else
        {
            output << display_float(float(x_value),number_of_decimals) << " " << to_string(base_dimensions,with_brackets);
        }
        return output.str();
    }

◆ change_dimensions() [1/2]

void scalar_unit::change_dimensions ( const scalar_unit & x )

Changes the dimensions to the same dimensions of the scalar_unit.

Definition at line 287 of file scalar_unit.cpp.

    {
        if(has_dimensions(x.get_dimensions()))
        {
            if (equal_dimensions_and_prefixes(dimensions,x.get_dimensions()))
            {
                return;
            }
            for(const dimension& actual_dimension : dimensions)
            {
                remove_dimension(actual_dimension);
                if(actual_dimension.is_composite_dimension())
                {
                    vector<dimension> base_dimensions = actual_dimension.get_base_dimensions();
                    for(const dimension& base_dimension : base_dimensions)
                    {
                        remove_dimension(base_dimension);
                    }
                }
            }
            if (dimensions.size() == 1 and x.get_dimensions().size() == 1)
            {
                if (dimensions[0].dimension_type == dimension::CELSIUS and dimensions[0].dimension_position == dimension::NUMERATOR and x.get_dimensions()[0].dimension_type == dimension::KELVIN and x.get_dimensions()[0].dimension_position == dimension::NUMERATOR)
                {
                    value += 273.15f;
                }
                else if (dimensions[0].dimension_type == dimension::KELVIN and dimensions[0].dimension_position == dimension::NUMERATOR and x.get_dimensions()[0].dimension_type == dimension::CELSIUS and x.get_dimensions()[0].dimension_position == dimension::NUMERATOR)
                {
                    value -= 273.15f;
                }
            }
            dimensions.clear();
            for(const dimension& new_dimension : x.get_dimensions())
            {
                add_dimension(new_dimension);
                if(new_dimension.is_composite_dimension())
                {
                    vector<dimension> new_base_dimensions = new_dimension.get_base_dimensions();
                    for(const dimension& new_base_dimension : new_base_dimensions)
                    {
                        add_dimension(new_base_dimension);
                    }
                }
            }
            dimensions = x.get_dimensions();
        }
        else
        {
            cerr << "Cannot change to different base dimensions" << endl;
        }
    }

◆ change_dimensions() [2/2]

void scalar_unit::change_dimensions ( const string & init_dimensions )

Changes the dimensions to the dimensions specified by the initialization string of dimensions.

Definition at line 234 of file scalar_unit.cpp.

    {
        vector<dimension> new_dimensions = create_dimensions(init_dimensions);
        if(has_dimensions(new_dimensions))
        {
            if (equal_dimensions_and_prefixes(dimensions,new_dimensions))
            {
                return;
            }
            for(const dimension& actual_dimension : dimensions)
            {
                remove_dimension(actual_dimension);
                if(actual_dimension.is_composite_dimension())
                {
                    vector<dimension> base_dimensions = actual_dimension.get_base_dimensions();
                    for(const dimension& base_dimension : base_dimensions)
                    {
                        remove_dimension(base_dimension);
                    }
                }
            }
            if (dimensions.size() == 1)
            {
                if (dimensions[0].dimension_type == dimension::CELSIUS and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::KELVIN and new_dimensions[0].dimension_position == dimension::NUMERATOR)
                {
                    value += 273.15f;
                }
                else if (dimensions[0].dimension_type == dimension::KELVIN and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::CELSIUS and new_dimensions[0].dimension_position == dimension::NUMERATOR)
                {
                    value -= 273.15f;
                }
            }
            dimensions.clear();
            for(const dimension& new_dimension : new_dimensions)
            {
                add_dimension(new_dimension);
                if(new_dimension.is_composite_dimension())
                {
                    vector<dimension> new_base_dimensions = new_dimension.get_base_dimensions();
                    for(const dimension& new_base_dimension : new_base_dimensions)
                    {
                        add_dimension(new_base_dimension);
                    }
                }
            }
            dimensions = new_dimensions;
        }
        else
        {
            cerr << "Cannot change to different base dimensions" << endl;
        }
    }

◆ check_dimensions()

void scifir::scalar_unit::check_dimensions ( const vector< dimension > & real_dimensions )

protected

Definition at line 731 of file scalar_unit.cpp.

    {
        if (!has_dimensions(real_dimensions))
        {
            value = 0;
            dimensions.clear();
        }
    }

◆ custom_display()

string scalar_unit::custom_display	(	const string &	init_dimensions,
		int	number_of_decimals = `2`,
		bool	with_brackets = `false`
	)		const

Generates a string representation of the scalar_unit, with the dimensions changed to any set of dimensions, specified by an initialization string of dimensions.

Definition at line 497 of file scalar_unit.cpp.

    {
        ostringstream output;
        long double new_value = get_value();
        if (init_dimensions != "sci")
        {
            for(const dimension& x_dimension : dimensions)
            {
                if (x_dimension.dimension_position == dimension::NUMERATOR)
                {
                    new_value *= x_dimension.get_conversion_factor();
                    new_value *= x_dimension.prefix_math();
                }
                else if (x_dimension.dimension_position == dimension::DENOMINATOR)
                {
                    new_value /= x_dimension.get_conversion_factor();
                    new_value /= x_dimension.prefix_math();
                }
            }
            vector<dimension> base_dimensions = create_base_dimensions(dimensions);
            for(const dimension& x_dimension : base_dimensions)
            {
                if (x_dimension.dimension_position == dimension::NUMERATOR)
                {
                    new_value *= x_dimension.prefix_math();
                }
                else if (x_dimension.dimension_position == dimension::DENOMINATOR)
                {
                    new_value /= x_dimension.prefix_math();
                }
            }
            vector<dimension> new_dimensions = create_dimensions(init_dimensions);
            if (dimensions.size() == 1 and new_dimensions.size() == 1)
            {
                if (dimensions[0].dimension_type == dimension::CELSIUS and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::KELVIN and new_dimensions[0].dimension_position == dimension::NUMERATOR)
                {
                    new_value += 273.15l;
                }
                else if (dimensions[0].dimension_type == dimension::KELVIN and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::CELSIUS and new_dimensions[0].dimension_position == dimension::NUMERATOR)
                {
                    new_value -= 273.15l;
                }
            }
            for(const dimension& x_new_dimension : new_dimensions)
            {
                if (x_new_dimension.dimension_position == dimension::NUMERATOR)
                {
                    new_value /= x_new_dimension.get_conversion_factor();
                    new_value /= x_new_dimension.prefix_math();
                }
                else if (x_new_dimension.dimension_position == dimension::DENOMINATOR)
                {
                    new_value *= x_new_dimension.get_conversion_factor();
                    new_value *= x_new_dimension.prefix_math();
                }
            }
            output << display_float(float(new_value),number_of_decimals) << " ";
            if (with_brackets)
            {
                output << "[";
            }
            output << init_dimensions;
            if (with_brackets)
            {
                output << "]";
            }
        }
        else
        {
            for (const dimension& x_dimension : dimensions)
            {
                new_value *= x_dimension.prefix_math();
            }
            vector<dimension> new_dimensions = dimensions;
            for (dimension& x_new_dimension : new_dimensions)
            {
                x_new_dimension.prefix.prefix_type = prefix::NONE;
            }
            int value_scale = int(log10(get_value()));
            output << display_float(float(new_value / std::pow(10,value_scale)),number_of_decimals) << "e" << value_scale << " " << to_string(new_dimensions,with_brackets);
        }
        return output.str();
    }

◆ display()

string scalar_unit::display	(	int	number_of_decimals = `2`,
		bool	with_brackets = `false`,
		bool	use_close_prefix = `false`
	)		const

Generates a string representation of the scalar_unit, with the value and the dimensions. The dimensions can be enclosed by brackets, and the value can be set to have the closest prefix.

Definition at line 446 of file scalar_unit.cpp.

    {
        ostringstream output;
        if (dimensions.size() == 1 and use_close_prefix == true)
        {
            prefix display_prefix;
            if (get_value() != 0)
            {
                int value_scale = int(log10(get_value()));
                display_prefix = closest_prefix(dimensions[0].prefix,value_scale);
            }
            else
            {
                display_prefix = dimensions[0].prefix;
            }
            long double x_value = get_value();
            x_value *= dimensions[0].prefix_math();
            x_value /= dimensions[0].prefix_math(display_prefix);
            vector<dimension> x_dimensions = dimensions;
            x_dimensions[0].prefix = display_prefix;
            output << display_float(float(x_value),number_of_decimals) << " " << to_string(x_dimensions,with_brackets);
        }
        else
        {
            output << display_float(get_value(),number_of_decimals) << " " << to_string(dimensions,with_brackets);
        }
        return output.str();
    }

◆ display_dimensions()

string scalar_unit::display_dimensions ( ) const

Generates an string of the dimensions of the scalar_unit, with the same format as the initialization string of dimensions.

Definition at line 419 of file scalar_unit.cpp.

    {
        return to_string(dimensions);
    }

◆ get_base_dimensions()

vector< dimension > scalar_unit::get_base_dimensions ( ) const

Generates a set of the base dimensions of the dimensions of the scalar_unit.

Definition at line 441 of file scalar_unit.cpp.

    {
        return create_base_dimensions(dimensions);
    }

◆ get_dimensions()

const vector< dimension > & scalar_unit::get_dimensions ( ) const

inline

Read-only getter of the dimensions.

Definition at line 321 of file scalar_unit.hpp.

            {
                return dimensions;
            }

◆ get_single_dimension_type()

dimension::type scalar_unit::get_single_dimension_type ( ) const

Returns the dimension::type if there's only one dimension, returns dimension::NONE if there's more than one dimension or if the dimensions are empty.

Definition at line 429 of file scalar_unit.cpp.

    {
        if (dimensions.size() == 1)
        {
            return dimensions[0].dimension_type;
        }
        else
        {
            return dimension::NONE;
        }
    }

◆ get_value()

const float & scalar_unit::get_value ( ) const

inline

Read-only getter of the value.

Definition at line 326 of file scalar_unit.hpp.

            {
                return value;
            }

◆ has_composite_dimensions()

bool scalar_unit::has_composite_dimensions ( ) const

Returns true is there's more than one simple dimension.

Definition at line 403 of file scalar_unit.cpp.

    {
        if (dimensions.size() == 0)
        {
            return false;
        }
        else if (dimensions.size() == 1)
        {
            return dimensions[0].is_composite_dimension();
        }
        else
        {
            return true;
        }
    }

◆ has_dimensions() [1/3]

bool scalar_unit::has_dimensions ( const scalar_unit & x ) const

Checks if the basic dimensions are the same as other scalar_unit.

Definition at line 350 of file scalar_unit.cpp.

    {
        return equal_dimensions(dimensions,x.get_dimensions());
    }

◆ has_dimensions() [2/3]

bool scalar_unit::has_dimensions ( const string & init_dimensions ) const

Checks if the basic dimensions are the same as the initialization string of dimensions.

Definition at line 339 of file scalar_unit.cpp.

    {
        vector<dimension> structure_dimensions = create_dimensions(init_dimensions);
        return has_dimensions(structure_dimensions);
    }

◆ has_dimensions() [3/3]

bool scalar_unit::has_dimensions ( const vector< dimension > & x_dimensions ) const

Checks if the basic dimensions are the same as some set of dimensions.

Definition at line 345 of file scalar_unit.cpp.

    {
        return equal_dimensions(dimensions,x_dimensions);
    }

◆ has_empty_dimensions()

bool scalar_unit::has_empty_dimensions ( ) const

Checks if there aren't base dimensions.

Definition at line 355 of file scalar_unit.cpp.

    {
        if(dimensions.size() == 0)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

◆ has_simple_dimensions()

bool scalar_unit::has_simple_dimensions ( ) const

Returns true if there's only a simple dimension.

Definition at line 386 of file scalar_unit.cpp.

    {
        if (dimensions.size() == 1)
        {
            return dimensions[0].is_simple_dimension();
        }
        else
        {
            return false;
        }
    }

◆ has_single_dimensions()

bool scalar_unit::has_single_dimensions ( ) const

Returns true if there's only one dimension, which can be simple or composite.

Definition at line 398 of file scalar_unit.cpp.

    {
        return (dimensions.size() == 1);
    }

◆ initialize_from_string()

void scalar_unit::initialize_from_string	(	string	init_scalar,
		const vector< dimension > &	real_dimensions
	)

protected

Internal function. It sets the value and the dimensions of the scalar_unit to the value and dimensions specified by the initialization string of scalar_unit.

Definition at line 692 of file scalar_unit.cpp.

    {
        if(!isdigit(init_scalar[0]))
        {
            return;
        }
        else
        {
            int i = 0;
            while(isdigit(init_scalar[i]) || init_scalar[i] == '.' || init_scalar[i] == ' ' || init_scalar[i] == '*' || init_scalar[i] == '^' || init_scalar[i] == 'e' || init_scalar[i] == 'E')
            {
                if (init_scalar[i] == ' ')
                {
                    break;
                }
                i++;
            }
            string string_value = init_scalar.substr(0, i);
            boost::algorithm::erase_all(string_value, " ");
            size_t search_e = string_value.find("E");
            if (search_e != string::npos)
            {
                string_value.replace(search_e,1,"e");
            }
            size_t search_10 = string_value.find("*10^");
            if (search_10 != string::npos)
            {
                string_value.replace(search_10,4,"e");
            }
            const vector<dimension> new_dimensions = create_dimensions(init_scalar.substr(i));
            if (real_dimensions.size() == 0 or equal_dimensions(new_dimensions,real_dimensions))
            {
                stringstream ss(string_value);
                ss >> value;
                dimensions = new_dimensions;
            }
        }
    }

◆ is_dimensionless()

bool scalar_unit::is_dimensionless ( ) const

Returns true if there aren't dimensions or if all dimensions are dimensionless.

Definition at line 367 of file scalar_unit.cpp.

    {
        if (has_empty_dimensions())
        {
            return true;
        }
        else
        {
            for (const dimension& x : dimensions)
            {
                if (!x.is_dimensionless())
                {
                    return false;
                }
            }
            return true;
        }
    }

◆ operator float()

scalar_unit::operator float ( ) const

explicit

Cast the scalar_unit to their float equivalent, it discards the dimensions and copies the value to a float.

Definition at line 107 of file scalar_unit.cpp.

    {
        return value;
    }

◆ operator*() [1/2]

scalar_unit scalar_unit::operator* ( scalar_unit x ) const

Multiplication operator, it multiplies two scalar_unit classes, their dimensions are also multiplied.

Definition at line 157 of file scalar_unit.cpp.

    {
        long double new_value = value;
        new_value *= x.get_value();
        vector<dimension> new_dimensions = multiply_dimensions(get_dimensions(),x.get_dimensions(),new_value);
        return scalar_unit(new_value, new_dimensions);
    }

◆ operator*() [2/2]

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

scalar_unit scalar_unit::operator* ( T y ) const

inline

Multiplication operator, it multiplies the numeric type with the value, independent of the dimensions.

Definition at line 254 of file scalar_unit.hpp.

            {
                scalar_unit x = *this;
                x *= y;
                return x;
            }

◆ operator*=()

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

void scalar_unit::operator*= ( T y )

inline

Multiplication operator, it multiplies the numeric type to the value, independent of the dimensions.

Definition at line 288 of file scalar_unit.hpp.

            {
                value *= y;
            }

◆ operator+() [1/2]

scalar_unit scalar_unit::operator+ ( scalar_unit x ) const

Addition operator, it sums two scalar_unit classes, their dimensions are changed to be equal first. If the basic dimensions are different, it returns an empty scalar_unit class.

Definition at line 125 of file scalar_unit.cpp.

    {
        if(has_dimensions(x))
        {
            x.change_dimensions(*this);
            scalar_unit a = *this;
            a += x.get_value();
            return a;
        }
        else
        {
            cerr << "Cannot sum different dimensions" << endl;
            return scalar_unit();
        }
    }

◆ operator+() [2/2]

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

scalar_unit scalar_unit::operator+ ( T y ) const

inline

Addition operator, it sums the numeric type to the value, independent of the dimensions.

Definition at line 238 of file scalar_unit.hpp.

            {
                scalar_unit x = *this;
                x += y;
                return x;
            }

◆ operator++() [1/2]

scalar_unit & scalar_unit::operator++ ( )

Increment operator, it increases the value by one.

Definition at line 208 of file scalar_unit.cpp.

    {
        value++;
        return *this;
    }

◆ operator++() [2/2]

scalar_unit & scalar_unit::operator++ ( int )

Increment operator, it increases the value by one.

Definition at line 214 of file scalar_unit.cpp.

    {
        scalar_unit& tmp(*this);
        operator ++();
        return tmp;
    }

◆ operator+=() [1/2]

void scalar_unit::operator+= ( scalar_unit x )

Addition operator, it adds a scalar_unit class to another, by converting their dimensions to be equal first. If their basic dimensions are different, it doesn't sums to the value.

Definition at line 186 of file scalar_unit.cpp.

    {
        if(!has_dimensions(x))
        {
            cerr << "Cannot sum different dimensions" << endl;
            return;
        }
        x.change_dimensions(*this);
        value += x.get_value();
    }

◆ operator+=() [2/2]

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

void scalar_unit::operator+= ( T y )

inline

Addition operator, it adds the numeric type to the value, independent of the dimensions.

Definition at line 276 of file scalar_unit.hpp.

            {
                value += y;
            }

◆ operator-() [1/2]

scalar_unit scalar_unit::operator- ( scalar_unit x ) const

Substraction operator, it substracts one scalar_unit from the other, their dimensions are changed to be equal first. If the basic dimensions are different, it returns an empty scalar_unit class.

Definition at line 141 of file scalar_unit.cpp.

    {
        if(has_dimensions(x))
        {
            x.change_dimensions(*this);
            scalar_unit a = *this;
            a -= x.get_value();
            return a;
        }
        else
        {
            cerr << "Cannot substract different dimensions" << endl;
            return scalar_unit();
        }
    }

◆ operator-() [2/2]

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

scalar_unit scalar_unit::operator- ( T y ) const

inline

Substraction operator, it substracts the numeric type to the value, independent of the dimensions.

Definition at line 246 of file scalar_unit.hpp.

            {
                scalar_unit x = *this;
                x -= y;
                return x;
            }

◆ operator--() [1/2]

scalar_unit & scalar_unit::operator-- ( )

Decrement operator, it decreases the value by one.

Definition at line 221 of file scalar_unit.cpp.

    {
        value--;
        return *this;
    }

◆ operator--() [2/2]

scalar_unit & scalar_unit::operator-- ( int )

Decrement operator, it decreases the value by one.

Definition at line 227 of file scalar_unit.cpp.

    {
        scalar_unit& tmp(*this);
        operator --();
        return tmp;
    }

◆ operator-=() [1/2]

void scalar_unit::operator-= ( scalar_unit x )

Substraction operator, it substracts a scalar_unit class to another, by converting their dimensions to be equal first. If their basic dimensions are different, it doesn't substracts to the value.

Definition at line 197 of file scalar_unit.cpp.

    {
        if(!has_dimensions(x))
        {
            cerr << "Cannot substract different dimensions" << endl;
            return;
        }
        x.change_dimensions(*this);
        value -= x.get_value();
    }

◆ operator-=() [2/2]

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

void scalar_unit::operator-= ( T y )

inline

Substraction operator, it substracts the numeric type to the value, independent of the dimensions.

Definition at line 282 of file scalar_unit.hpp.

            {
                value -= y;
            }

◆ operator/() [1/2]

scalar_unit scalar_unit::operator/ ( scalar_unit x ) const

Division operator, it divides one scalar_unit class with the other, their dimensions are also divided.

Definition at line 165 of file scalar_unit.cpp.

    {
        long double new_value = value;
        new_value /= x.get_value();
        vector<dimension> new_dimensions = divide_dimensions(get_dimensions(),x.get_dimensions(),new_value);
        return scalar_unit(new_value, new_dimensions);
    }

◆ operator/() [2/2]

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

scalar_unit scalar_unit::operator/ ( T y ) const

inline

Division operator, it divides the value with the numeric type, independent of the dimensions.

Definition at line 262 of file scalar_unit.hpp.

            {
                scalar_unit x = *this;
                x /= y;
                return x;
            }

◆ operator/=()

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

void scalar_unit::operator/= ( T y )

inline

Division operator, it divides the numeric type to the value, independent of the dimensions.

Definition at line 294 of file scalar_unit.hpp.

            {
                value /= y;
            }

◆ operator=() [1/3]

scalar_unit & scalar_unit::operator= ( const scalar_unit & x )

Copy assignment, it assigns a copy of the scalar_unit.

Definition at line 73 of file scalar_unit.cpp.

    {
        if (has_dimensions(x))
        {
            dimensions = x.get_dimensions();
            value = x.get_value();
        }
        else
        {
            cerr << "Cannot initialize to different dimensions" << endl;
        }
        return *this;
    }

◆ operator=() [2/3]

scalar_unit & scalar_unit::operator= ( const string & init_scalar )

Assignment with an initialization string, the value and the dimensions are both specified.

Definition at line 101 of file scalar_unit.cpp.

    {
        initialize_from_string(init_scalar,vector<dimension>());
        return *this;
    }

◆ operator=() [3/3]

scalar_unit & scalar_unit::operator= ( scalar_unit && x )

Move assignment, it moves the scalar_unit.

Definition at line 87 of file scalar_unit.cpp.

    {
        if (has_dimensions(x))
        {
            dimensions = std::move(x.get_dimensions());
            value = std::move(x.get_value());
        }
        else
        {
            cerr << "Cannot initialize to different dimensions" << endl;
        }
        return *this;
    }

◆ operator==()

bool scalar_unit::operator== ( scalar_unit x ) const

Comparison operator, two scalar_unit classes are considered equivalent if they have the same value given the same dimensions.

Definition at line 112 of file scalar_unit.cpp.

    {
        x.change_dimensions(*this);
        if(get_value() == x.get_value() and has_dimensions(x))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

◆ operator^() [1/2]

scalar_unit scalar_unit::operator^ ( const scalar_unit & x ) const

Power operator, it powers a scalar_unit class with another, if that second scalar_unit class, which is the exponent, as empty dimensions. If the exponent doesn't has empty dimensions it returns an empty scalar_unit class.

Definition at line 173 of file scalar_unit.cpp.

    {
        if(x.has_empty_dimensions())
        {
            return scalar_unit(std::pow(value,x.get_value()),power_dimensions(get_dimensions(),int(x.get_value())));
        }
        else
        {
            cerr << "Exponent with dimensions doesn't exist" << endl;
            return scalar_unit();
        }
    }

◆ operator^() [2/2]

template<typename T , typename = typename enable_if<is_integer_number<T>::value>::type>

scalar_unit scalar_unit::operator^ ( T y ) const

inline

Power operator, it powers the value with the numeric type, independent of the dimensions.

Definition at line 270 of file scalar_unit.hpp.

            {
                return scalar_unit(std::pow(get_value(),y),power_dimensions(get_dimensions(),y));
            }

◆ remove_dimension()

void scalar_unit::remove_dimension ( const dimension & old_dimension )

protected

Internal function. It removes a dimension, changing the value according to the conversion factor of the removed dimension and the prefix.

Definition at line 678 of file scalar_unit.cpp.

    {
        if (old_dimension.dimension_position == dimension::NUMERATOR)
        {
            value *= float(old_dimension.get_conversion_factor());
            value *= float(old_dimension.prefix_math());
        }
        else if (old_dimension.dimension_position == dimension::DENOMINATOR)
        {
            value /= float(old_dimension.get_conversion_factor());
            value /= float(old_dimension.prefix_math());
        }
    }

◆ to_latex()

string scifir::scalar_unit::to_latex	(	const string &	init_dimensions,
		int	number_of_decimals = `2`,
		bool	with_brackets = `false`
	)		const

Definition at line 581 of file scalar_unit.cpp.

    {
        ostringstream output;
        long double new_value = get_value();
        if (init_dimensions != "sci")
        {
            vector<dimension> new_dimensions;
            if (init_dimensions != "")
            {
                for(const dimension& x_dimension : dimensions)
                {
                    if (x_dimension.dimension_position == dimension::NUMERATOR)
                    {
                        new_value *= x_dimension.get_conversion_factor();
                        new_value *= x_dimension.prefix_math();
                    }
                    else if (x_dimension.dimension_position == dimension::DENOMINATOR)
                    {
                        new_value /= x_dimension.get_conversion_factor();
                        new_value /= x_dimension.prefix_math();
                    }
                }
                vector<dimension> base_dimensions = create_base_dimensions(dimensions);
                for(const dimension& x_dimension : base_dimensions)
                {
                    if (x_dimension.dimension_position == dimension::NUMERATOR)
                    {
                        new_value *= x_dimension.prefix_math();
                    }
                    else if (x_dimension.dimension_position == dimension::DENOMINATOR)
                    {
                        new_value /= x_dimension.prefix_math();
                    }
                }
                new_dimensions = create_dimensions(init_dimensions);
                if (dimensions.size() == 1 and new_dimensions.size() == 1)
                {
                    if (dimensions[0].dimension_type == dimension::CELSIUS and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::KELVIN and new_dimensions[0].dimension_position == dimension::NUMERATOR)
                    {
                        new_value += 273.15l;
                    }
                    else if (dimensions[0].dimension_type == dimension::KELVIN and dimensions[0].dimension_position == dimension::NUMERATOR and new_dimensions[0].dimension_type == dimension::CELSIUS and new_dimensions[0].dimension_position == dimension::NUMERATOR)
                    {
                        new_value -= 273.15l;
                    }
                }
                for(const dimension& x_new_dimension : new_dimensions)
                {
                    if (x_new_dimension.dimension_position == dimension::NUMERATOR)
                    {
                        new_value /= x_new_dimension.get_conversion_factor();
                        new_value /= x_new_dimension.prefix_math();
                    }
                    else if (x_new_dimension.dimension_position == dimension::DENOMINATOR)
                    {
                        new_value *= x_new_dimension.get_conversion_factor();
                        new_value *= x_new_dimension.prefix_math();
                    }
                }
            }
            else
            {
                new_dimensions = dimensions;
            }
            output << display_float(float(new_value),number_of_decimals) << " " << scifir::to_latex(new_dimensions,with_brackets);
        }
        else
        {
            for (const dimension& x_dimension : dimensions)
            {
                new_value *= x_dimension.prefix_math();
            }
            vector<dimension> new_dimensions = dimensions;
            for (dimension& x_new_dimension : new_dimensions)
            {
                x_new_dimension.prefix.prefix_type = prefix::NONE;
            }
            int value_scale = int(log10(get_value()));
            output << display_float(float(new_value / std::pow(10,value_scale)),number_of_decimals) << "e" << value_scale << " " << scifir::to_latex(new_dimensions,with_brackets);
        }
        return output.str();
    }

Member Data Documentation

◆ dimensions

scalar_unit::dimensions

protected

Dimensions of the scalar_unit. They can be simple dimensions, composite dimensions or special names.

Definition at line 338 of file scalar_unit.hpp.

◆ value

scalar_unit::value

protected

Value of the scalar_unit. It changes automatically when the dimensions change.

Definition at line 339 of file scalar_unit.hpp.

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

units/scalar_unit.hpp
units/scalar_unit.cpp
docs/dox/units/scalar_unit.dox

Public Member Functions

Protected Member Functions

Protected Attributes

Detailed Description

Constructor & Destructor Documentation

◆ scalar_unit() [1/16]

◆ scalar_unit() [2/16]

◆ scalar_unit() [3/16]

◆ scalar_unit() [4/16]

◆ scalar_unit() [5/16]

◆ scalar_unit() [6/16]

◆ scalar_unit() [7/16]

◆ scalar_unit() [8/16]

◆ scalar_unit() [9/16]

◆ scalar_unit() [10/16]

◆ scalar_unit() [11/16]

◆ scalar_unit() [12/16]

◆ scalar_unit() [13/16]

◆ scalar_unit() [14/16]

◆ scalar_unit() [15/16]

◆ scalar_unit() [16/16]

Member Function Documentation

◆ add_dimension()

◆ base_display()

◆ change_dimensions() [1/2]

◆ change_dimensions() [2/2]

◆ check_dimensions()

◆ custom_display()

◆ display()

◆ display_dimensions()

◆ get_base_dimensions()

◆ get_dimensions()

◆ get_single_dimension_type()

◆ get_value()

◆ has_composite_dimensions()

◆ has_dimensions() [1/3]

◆ has_dimensions() [2/3]

◆ has_dimensions() [3/3]

◆ has_empty_dimensions()

◆ has_simple_dimensions()

◆ has_single_dimensions()

◆ initialize_from_string()

◆ is_dimensionless()

◆ operator float()

◆ operator*() [1/2]

◆ operator*() [2/2]

◆ operator*=()

◆ operator+() [1/2]

◆ operator+() [2/2]

◆ operator++() [1/2]

◆ operator++() [2/2]

◆ operator+=() [1/2]

◆ operator+=() [2/2]

◆ operator-() [1/2]

◆ operator-() [2/2]

◆ operator--() [1/2]

◆ operator--() [2/2]

◆ operator-=() [1/2]

◆ operator-=() [2/2]

◆ operator/() [1/2]

◆ operator/() [2/2]

◆ operator/=()

◆ operator=() [1/3]

◆ operator=() [2/3]

◆ operator=() [3/3]

◆ operator==()

◆ operator^() [1/2]

◆ operator^() [2/2]

◆ remove_dimension()

◆ to_latex()

Member Data Documentation

◆ dimensions

◆ value