scifir::time_duration Class Reference

#include <base_units.hpp>

Inheritance diagram for scifir::time_duration:

Collaboration diagram for scifir::time_duration:

Public Member Functions
	time_duration ()
	time_duration (const scalar_unit &)
	time_duration (scalar_unit &&)
	time_duration (float new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position=dimension::NUMERATOR)
	time_duration (double new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position=dimension::NUMERATOR)
	time_duration (long double new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position=dimension::NUMERATOR)
	time_duration (int new_value, dimension::type new_dimension, prefix::type new_prefix, dimension::position new_position=dimension::NUMERATOR)
	time_duration (float new_value, const string &init_dimensions)
	time_duration (double new_value, const string &init_dimensions)
	time_duration (long double new_value, const string &init_dimensions)
	time_duration (int new_value, const string &init_dimensions)
	time_duration (float new_value, const vector< dimension > &new_dimensions)
	time_duration (double new_value, const vector< dimension > &new_dimensions)
	time_duration (long double new_value, const vector< dimension > &new_dimensions)
	time_duration (int new_value, const vector< dimension > &new_dimensions)
	time_duration (const string &init_time)
	operator std::chrono::seconds () const
int	get_years () const
int	get_months () const
int	get_weeks () const
int	get_days () const
int	get_hours () const
int	get_minutes () const
int	get_seconds () const
string	get_finish_date () const
string	display_as_time () const
string	display_years () const
string	display_months () const
string	display_weeks () const
string	display_days () const
string	display_hours () const
string	display_minutes () const
string	display_seconds () const
template<typename T1 , typename T2 >
scifir::time_duration &	operator+= (chrono::duration< T1, T2 > x)
template<typename T1 , typename T2 >
scifir::time_duration &	operator-= (chrono::duration< T1, T2 > x)
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.
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.
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>
void	operator-= (T y)
	Substraction operator, it substracts the numeric type to the value, independent of the dimensions.
Public Member Functions inherited from scifir::scalar_unit
	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

Static Public Attributes
static const string	dimensions_match = "s"
static const vector< dimension >	real_dimensions = create_base_dimensions("s")

Additional Inherited Members
Protected Member Functions inherited from scifir::scalar_unit
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 inherited from scifir::scalar_unit
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

Definition at line 18 of file base_units.hpp.

Constructor & Destructor Documentation

time_duration() [1/16]

scifir::time_duration::time_duration

(

)

Definition at line 24 of file base_units.cpp.

                                 : scalar_unit()
    {
        scalar_unit::dimensions = time_duration::real_dimensions;
    }

time_duration() [2/16]

scifir::time_duration::time_duration

(

const scalar_unit &

x

)

Definition at line 29 of file base_units.cpp.

    {
        if (x.has_dimensions(time_duration::real_dimensions))
        {
            value = x.get_value();
            dimensions = x.get_dimensions();
        }
    }

time_duration() [3/16]

scifir::time_duration::time_duration

(

scalar_unit &&

x

)

Definition at line 38 of file base_units.cpp.

    {
        if (x.has_dimensions(time_duration::real_dimensions))
        {
            value = std::move(x.get_value());
            dimensions = std::move(x.get_dimensions());
        }
    }

time_duration() [4/16]

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

explicit

Definition at line 47 of file base_units.cpp.

                                                                                                                                    : scalar_unit(new_value,new_dimension,new_prefix,new_position)
    {}

time_duration() [5/16]

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

explicit

Definition at line 50 of file base_units.cpp.

                                                                                                                                     : scalar_unit(new_value,new_dimension,new_prefix,new_position)
    {}

time_duration() [6/16]

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

explicit

Definition at line 53 of file base_units.cpp.

                                                                                                                                          : scalar_unit(new_value,new_dimension,new_prefix,new_position)
    {}

time_duration() [7/16]

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

explicit

Definition at line 56 of file base_units.cpp.

                                                                                                                                  : scalar_unit(new_value,new_dimension,new_prefix,new_position)
    {}

time_duration() [8/16]

scifir::time_duration::time_duration ( float  new_value, const string &  init_dimensions  )

explicit

Definition at line 59 of file base_units.cpp.

                                                                               : scalar_unit(new_value,init_dimensions)
    {}

time_duration() [9/16]

scifir::time_duration::time_duration ( double  new_value, const string &  init_dimensions  )

explicit

Definition at line 62 of file base_units.cpp.

                                                                                : scalar_unit(new_value,init_dimensions)
    {}

time_duration() [10/16]

scifir::time_duration::time_duration ( long double  new_value, const string &  init_dimensions  )

explicit

Definition at line 65 of file base_units.cpp.

                                                                                     : scalar_unit(new_value,init_dimensions)
    {}

time_duration() [11/16]

scifir::time_duration::time_duration ( int  new_value, const string &  init_dimensions  )

explicit

Definition at line 68 of file base_units.cpp.

                                                                             : scalar_unit(new_value,init_dimensions)
    {}

time_duration() [12/16]

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

explicit

Definition at line 71 of file base_units.cpp.

                                                                                         : scalar_unit(new_value,new_dimensions)
    {}

time_duration() [13/16]

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

explicit

Definition at line 74 of file base_units.cpp.

                                                                                          : scalar_unit(new_value,new_dimensions)
    {}

time_duration() [14/16]

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

explicit

Definition at line 77 of file base_units.cpp.

                                                                                               : scalar_unit(new_value,new_dimensions)
    {}

time_duration() [15/16]

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

explicit

Definition at line 80 of file base_units.cpp.

                                                                                       : scalar_unit(new_value,new_dimensions)
    {}

time_duration() [16/16]

scifir::time_duration::time_duration ( const string &  init_time )

explicit

Definition at line 83 of file base_units.cpp.

                                                        : scalar_unit()
    {
        if(!isdigit(init_time[0]))
        {
            return;
        }
        else
        {
            vector<string> init_values;
            boost::split(init_values,init_time,boost::is_any_of(" "));
            value = 0;
            for (unsigned int i = 0; i < init_values.size(); i++)
            {
                int j = 0;
                while(isdigit(init_values[i][j]) || init_values[i][j] == '.' || init_values[i][j] == ' ' || init_values[i][j] == '*' || init_values[i][j] == '^' || init_values[i][j] == 'e' || init_values[i][j] == 'E')
                {
                    if (init_values[i][j] == ' ')
                    {
                        break;
                    }
                    j++;
                }
                string string_value = init_values[i].substr(0, j);
                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");
                }
                stringstream ss(string_value);
                float init_value_float;
                ss >> init_value_float;
                string init_value_dimension = init_values[i].substr(j);
                float init_value_dimension_quantity = 0.0f;
                if (init_value_dimension == "d")
                {
                    init_value_dimension_quantity = 86400.0f;
                }
                else if(init_value_dimension == "h")
                {
                    init_value_dimension_quantity = 3600.0f;
                }
                else if(init_value_dimension == "min")
                {
                    init_value_dimension_quantity = 60.0f;
                }
                else if(init_value_dimension == "s")
                {
                    init_value_dimension_quantity = 1.0f;
                }
                value += init_value_float * init_value_dimension_quantity;
            }
            dimensions = create_dimensions("s");
        }
    }

Member Function Documentation

display_as_time()

string scifir::time_duration::display_as_time

(

)

const

Definition at line 269 of file base_units.cpp.

    {
        ostringstream output;
        scifir::time_duration remaining_time = *this;
        scifir::time_duration one_year ("365d");
        if (*this >= one_year)
        {
            int total_of_years = int(trunc((*this / one_year).get_value()));
            output << total_of_years << "y ";
            remaining_time -= scifir::time_duration(float(total_of_years) * 365,"d");
        }
        scifir::time_duration one_month("30d");
        if (remaining_time >= one_month)
        {
            int total_of_months = int(trunc((remaining_time / one_month).get_value()));
            output << total_of_months << "m ";
            remaining_time -= scifir::time_duration(float(total_of_months) * 30,"d");
        }
        scifir::time_duration one_day("1d");
        if (remaining_time >= one_day)
        {
            int total_of_days = int(trunc((remaining_time / one_day).get_value()));
            output << total_of_days << "d ";
            remaining_time -= scifir::time_duration(float(total_of_days),"d");
        }
        scifir::time_duration one_hour("1h");
        if (remaining_time >= one_hour)
        {
            int total_of_hours = int(trunc((remaining_time / one_hour).get_value()));
            output << total_of_hours << "h ";
            remaining_time -= scifir::time_duration(float(total_of_hours),"h");
        }
        scifir::time_duration one_minute("1min");
        if (remaining_time >= one_minute)
        {
            int total_of_minutes = int(trunc((remaining_time / one_minute).get_value()));
            output << total_of_minutes << "min ";
            remaining_time -= scifir::time_duration(float(total_of_minutes),"min");
        }
        scifir::time_duration one_second("1s");
        if (remaining_time >= one_second)
        {
            remaining_time.change_dimensions("s");
            float total_of_seconds = float(remaining_time.get_value());
            output << total_of_seconds << "s";
        }
        return output.str();
    }

display_days()

string scifir::time_duration::display_days

(

)

const

Definition at line 339 of file base_units.cpp.

    {
        ostringstream out;
        out << get_days() << " d";
        return out.str();
    }

display_hours()

string scifir::time_duration::display_hours

(

)

const

Definition at line 346 of file base_units.cpp.

    {
        ostringstream out;
        out << get_hours() << " h";
        return out.str();
    }

display_minutes()

string scifir::time_duration::display_minutes

(

)

const

Definition at line 353 of file base_units.cpp.

    {
        ostringstream out;
        out << get_minutes() << " min";
        return out.str();
    }

display_months()

string scifir::time_duration::display_months

(

)

const

Definition at line 325 of file base_units.cpp.

    {
        ostringstream out;
        out << get_months() << " months";
        return out.str();
    }

display_seconds()

string scifir::time_duration::display_seconds

(

)

const

Definition at line 360 of file base_units.cpp.

    {
        ostringstream out;
        out << get_seconds() << " s";
        return out.str();
    }

display_weeks()

string scifir::time_duration::display_weeks

(

)

const

Definition at line 332 of file base_units.cpp.

    {
        ostringstream out;
        out << get_weeks() << " weeks";
        return out.str();
    }

display_years()

string scifir::time_duration::display_years

(

)

const

Definition at line 318 of file base_units.cpp.

    {
        ostringstream out;
        out << get_years() << " y";
        return out.str();
    }

get_days()

int scifir::time_duration::get_days

(

)

const

Definition at line 193 of file base_units.cpp.

    {
        scifir::time_duration one_day("1d");
        if (*this >= one_day)
        {
            return int(trunc((*this / one_day).get_value()));
        }
        else
        {
            return 0;
        }
    }

get_finish_date()

string scifir::time_duration::get_finish_date

(

)

const

get_hours()

int scifir::time_duration::get_hours

(

)

const

Definition at line 206 of file base_units.cpp.

    {
        scifir::time_duration one_hour("1h");
        if (*this >= one_hour)
        {
            return int(trunc((*this / one_hour).get_value()));
        }
        else
        {
            return 0;
        }
    }

get_minutes()

int scifir::time_duration::get_minutes

(

)

const

Definition at line 219 of file base_units.cpp.

    {
        scifir::time_duration one_minute = scifir::time_duration("1min");
        if (*this >= one_minute)
        {
            return int(trunc((*this / one_minute).get_value()));
        }
        else
        {
            return 0;
        }
    }

get_months()

int scifir::time_duration::get_months

(

)

const

Definition at line 167 of file base_units.cpp.

    {
        scifir::time_duration one_month("30d");
        if (*this >= one_month)
        {
            return int(trunc((*this / one_month).get_value()));
        }
        else
        {
            return 0;
        }
    }

get_seconds()

int scifir::time_duration::get_seconds

(

)

const

Definition at line 232 of file base_units.cpp.

    {
        scifir::time_duration one_second("1s");
        if (*this >= one_second)
        {
            return int(trunc((*this / one_second).get_value()));
        }
        else
        {
            return 0;
        }
    }

get_weeks()

int scifir::time_duration::get_weeks

(

)

const

Definition at line 180 of file base_units.cpp.

    {
        scifir::time_duration one_week("7d");
        if (*this >= one_week)
        {
            return int(trunc((*this / one_week).get_value()));
        }
        else
        {
            return 0;
        }
    }

get_years()

int scifir::time_duration::get_years

(

)

const

Definition at line 154 of file base_units.cpp.

    {
        scifir::time_duration one_year ("365d");
        if (*this >= one_year)
        {
            return int(trunc((*this / one_year).get_value()));
        }
        else
        {
            return 0;
        }
    }

operator std::chrono::seconds()

scifir::time_duration::operator std::chrono::seconds ( ) const

explicit

Definition at line 147 of file base_units.cpp.

    {
        scifir::time_duration a = *this;
        a.change_dimensions("s");
        return std::chrono::seconds(int(a.get_value()));
    }

operator+=() [1/3]

template<typename T1 , typename T2 >

scifir::time_duration & scifir::time_duration::operator+= ( chrono::duration< T1, T2 >  x )

inline

Definition at line 60 of file base_units.hpp.

            {
                 chrono::seconds d = chrono::duration_cast<chrono::seconds>(x);
                 scifir::time_duration x_second = scifir::time_duration((long double)d.count(),"s");
                 scalar_unit::operator+=(x_second);
                 return *this;
            }

operator+=() [2/3]

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 234 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+=() [3/3]

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/3]

template<typename T1 , typename T2 >

scifir::time_duration & scifir::time_duration::operator-= ( chrono::duration< T1, T2 >  x )

inline

Definition at line 69 of file base_units.hpp.

            {
                 chrono::seconds d = chrono::duration_cast<chrono::seconds>(x);
                 scifir::time_duration x_second = scifir::time_duration((long double)d.count(),"s");
                 scalar_unit::operator-=(x_second);
                 return *this;
            }

operator-=() [2/3]

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 235 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-=() [3/3]

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;
            }

Member Data Documentation

dimensions_match

const string scifir::time_duration::dimensions_match = "s"

static

Definition at line 82 of file base_units.hpp.

real_dimensions

const vector< dimension > scifir::time_duration::real_dimensions = create_base_dimensions("s")

static

Definition at line 83 of file base_units.hpp.

---

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

• units/base_units.hpp
• units/base_units.cpp