scifir Namespace Reference

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

Classes
class	address
class	aid
	Class that stores astronomical ids, not as an integer but with an string as identifier. Initialization string example: "(P) universe:milky-way:solar-system:earth". More...
class	angle
	Class that allows to work with angles. Each angle sizes 4 bytes. Initialization string example: "20°". More...
class	color
class	complex_number
class	conversion
class	coordinates_1d
class	coordinates_1d< float >
class	coordinates_2d
class	coordinates_2d< float >
class	coordinates_2dr
class	coordinates_2dr< float >
class	coordinates_3d
	Class that represents the position in 3D spaces. The space can be a length or, for the case of imaginary spaces, any custom dimension. The most interesting feature is the fact that all the coordinates systems in 3D are present at the same time, it's possible to use cartesian, cylindrical or spherical coordinates as needed for the same instance of coordinates, it's not needed to select just one of those systems. The geographical coordinates aren't yet finished. More...
class	coordinates_3d< float >
	Specialization of coordinates_3d, with the same behaviour and functions, that is specialized for float types. It can be used when it's needed to save memory, because a float uses less memory than a scalar_unit. More...
class	coordinates_3dr
class	coordinates_3dr< float >
class	coordinates_nd
class	coordinates_nd< float >
class	coordinates_ndr
class	coordinates_ndr< float >
class	dimension
	Class that represents dimensions of the SI system of units. Each dimension sizes 6 bytes, 1 byte for the dimension type, 1 byte for the prefix, 1 byte for the position (which can be the NUMERATOR or the DENOMINATOR), and 3 bytes for the custom dimension (in case it's used one). A base dimension is a dimension that doesn't has more base dimensions, a derived dimension has always base dimensions from which it's defined. More...
class	direction
struct	is_integer_number
struct	is_number
class	lab_number
class	latitude
class	longitude
class	matrix
class	percentage
	Class that allows to handle percentages and do calculations with it easy. It supports normal percentages (with %), ppm, ppb, ppt and ppq. The types ppb, ppt and ppq are currently not supported because the float type in percentage class can't store so lower values. More...
class	pixel
class	prefix
	Class that represents prefixes of the SI system of units. Each prefix sizes 1 byte. The prefix micro is added to a dimension with the symbol µ. More...
class	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...
class	size_2d
	Class that allows to store and calculate size in 2D, with width and height. The template parameter T allows to select any scalar_unit or numeric type to be the type of width and height (they always have the same type in the same instance). The width and height can be any scalar_unit, usually length, but imaginary spaces with custom dimensions are also allowed. Initialization string example: "1 m * 2 m". More...
class	size_2d< float >
	Specialization class of size_2d<T> that allows to store and calculate size in 2D, with width and height as float types. Initialization string example: "1 * 2". More...
class	size_3d
	Class that allows to store and calculate size in 3D, with width, height and depth. The template parameter T allows to select any scalar_unit or numeric type to be the type of the width, the height and the depth (they always have the same type in the same instance). The width, height and depth can be any scalar_unit, usually length, but imaginary spaces with custom dimensions are also allowed. Initialization string example: "1 m * 2 m * 4 m". More...
class	size_3d< float >
	Specialization class of size_3d<T> that allows to store and calculate size in 3D, with width, height and depth as float types. Initialization string example: "1 * 2 * 4". More...
class	size_nd
class	size_nd< float >
class	time_duration
class	vector_unit_2d
	Class that creates a vector unit in 2D. The vector is in polar coordinates with a value and dimensions of the scalar_unit, and an angle theta for his direction. All base and derived vectorial unit classes in 2D inherit from vector_unit_2d, and add the suffix **_2d** in their name. Initialization string example: "1 N 20θ". 'θ' is the Unicode Character U+03B8. More...
class	vector_unit_3d
	Class that creates a vector unit in 3D. The vector is in spherical coordinates with a value and dimensions of the scalar_unit, and an angle theta and another angle phi for his direction. All base and derived vectorial unit classes in 3D inherit from vector_unit_3d, and add the suffix **_3d** in their name. Initialization string example: "1 N 20θ 30Φ". 'θ' is the Unicode Character U+03B8. 'Φ' is the Unicode Character U+03A6. More...
class	vector_unit_nd
	Class that creates a vector in ND, which means a variable number of dimensions. A vector_unit_nd can change to be in 1D, in 2D or in 3D, but it cannot be in more than one dimension at the same time. The member-variables of vector_unit_nd are the value and the vector<dimension> of scalar_unit, and a vector<angle> angles. The number of angles is equal to the number of dimensions vector unit has - 1. In 1D vector_unit_nd doesn't has angles, in 2D vector_unit_nd is in polar coordinates and has 1 angle, and in 3D vector_unit_nd is in spherical coordinates and has 2 angles. All base and derived vectorial unit classes in ND inherit from vector_unit_nd, and add the suffix **_nd** in their name. Initialization string example: "1 N 20° 30° 40°". '°' is the Unicode Character U+00B0. More...
class	zid
	Class that allows to store information about a zone, including the astronomical object inside which the zone is. The zone can be in any astronomical object, not only the Earth is supported. Initialization string example: "(P) universe:milky-way:solar-system:earth (Z) chile:region-metropolitana:santiago:providencia". More...

Typedefs
typedef length	wavelength

Enumerations
enum class	astronomical_body : int8_t {   NONE , MILKY_WAY , ANDROMEDA , SOLAR_SYSTEM ,   SUN , MOON , MERCURY , VENUS ,   EARTH , MARS , JUPITER , SATURN ,   URANUS , NEPTUNE , CERES , ORCUS ,   PLUTO , HAUMEA , QUAOAR , MAKEMAKE ,   GONGGONG , ERIS , SEDNA , IO ,   EUROPA , GANYMEDE , CALLISTO , MIMAS ,   ENCELADUS , TETHYS , DIONE , RHEA ,   TITAN , IAPETUS , MIRANDA , ARIEL ,   UMBRIEL , TITANIA , OBERON , TRITON ,   CHARON , DYSNOMIA }
	Contains predefined astronomical bodies to be set automatically in the aid class. All of them are important astronomical bodies, unimportant astronomical bodies aren't included. More...
enum class	cardinale_point { NORTH , SOUTH , EAST , WEST }

Functions
string	to_string (const aid &x)
	Creates a string representation of aid, it's for aid equivalent to the display() function of aid.
string	to_string (const aid::type &x)
	Converts a value of the enum aid::type to its string representation, which can be a single or a pair of letters. The value UNIVERSE returns U. The value GALAXY returns G. The value SOLAR_SYSTEM returns SS. The value PLANET returns P. The value STAR returns ST. The value ASTEROID returns A. The value MOON returns MN. The value METEOR returns MT. The value NONE returns an empty string.
aid::type	create_astronomical_type (const string &astronomical_type_abbreviation)
	Creates an instance of an aid::type with the given string, which is the reverse as the to_string() function of aid::type.
string	to_string (const coordinates_1d< float > &x)
float	distance (const coordinates_1d< float > &x, const coordinates_1d< float > &y)
template<typename T >
string	to_string (const coordinates_1d< T > &x)
template<typename T , typename U >
T	distance (const coordinates_1d< T > &x, const coordinates_1d< U > &y)
string	to_string (const coordinates_2d< float > &x)
float	distance (const coordinates_2d< float > &x, const coordinates_2d< float > &y)
template<typename T >
string	to_string (const coordinates_2d< T > &x)
template<typename T , typename U >
T	distance (const coordinates_2d< T > &x, const coordinates_2d< U > &y)
scalar_unit	cartesian_2d_to_polar_p (const scalar_unit &x, scalar_unit y)
angle	cartesian_2d_to_polar_theta (const scalar_unit &x, scalar_unit y)
scalar_unit	polar_to_cartesian_2d_x (const scalar_unit &p, const angle &theta)
scalar_unit	polar_to_cartesian_2d_y (const scalar_unit &p, const angle &theta)
float	cartesian_2d_to_polar_p (float x, float y)
angle	cartesian_2d_to_polar_theta (float x, float y)
float	polar_to_cartesian_2d_x (float p, const angle &theta)
float	polar_to_cartesian_2d_y (float p, const angle &theta)
string	to_string (const coordinates_2dr< float > &x)
float	distance (const coordinates_2dr< float > &x, const coordinates_2dr< float > &y)
float	distance (const coordinates_2dr< float > &x, const coordinates_2d< float > &y)
float	distance (const coordinates_2d< float > &x, const coordinates_2dr< float > &y)
template<typename T >
string	to_string (const coordinates_2dr< T > &x)
template<typename T , typename U >
T	distance (const coordinates_2dr< T > &x, const coordinates_2dr< U > &y)
template<typename T , typename U >
T	distance (const coordinates_2dr< T > &x, const coordinates_2d< U > &y)
template<typename T , typename U >
T	distance (const coordinates_2d< T > &x, const coordinates_2dr< U > &y)
string	to_string (cardinale_point x)
string	to_string (const coordinates_3d< float > &x)
	Returns the string representation of coordinates_3d<float>.
cardinale_point	create_cardinale_point (const string &x)
float	distance (const coordinates_3d< float > &x, const coordinates_3d< float > &y)
	Calculates the distance between two coordinates_3d<float>.
latitude	ECEF_to_LLA_latitude (const scalar_unit &x, scalar_unit y, const scalar_unit &z)
longitude	ECEF_to_LLA_longitude (const scalar_unit &x, scalar_unit y, const scalar_unit &z)
scalar_unit	ECEF_to_LLA_altitude (const scalar_unit &x, scalar_unit y, const scalar_unit &z)
scalar_unit	LLA_to_ECEF_x (const latitude &latitude, const longitude &longitude, scalar_unit altitude)
scalar_unit	LLA_to_ECEF_y (const latitude &latitude, const longitude &longitude, scalar_unit altitude)
scalar_unit	LLA_to_ECEF_z (const latitude &latitude, const longitude &longitude, scalar_unit altitude)
latitude	ECEF_to_LLA_latitude (float x, float y, float z)
longitude	ECEF_to_LLA_longitude (float x, float y, float z)
float	ECEF_to_LLA_altitude (float x, float y, float z)
template<typename T >
string	to_string (const coordinates_3d< T > &x)
	Returns the string representation of coordinates_3d.
template<typename T , typename U >
T	distance (const coordinates_3d< T > &x, const coordinates_3d< U > &y)
	Calculates the distance between two coordinates_3d.
scalar_unit	cartesian_3d_to_cylindrical_p (const scalar_unit &x, scalar_unit y, const scalar_unit &z)
	Returns the p coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.
angle	cartesian_3d_to_cylindrical_theta (const scalar_unit &x, scalar_unit y, const scalar_unit &z)
	Returns the theta coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.
scalar_unit	cartesian_3d_to_cylindrical_z (const scalar_unit &x, const scalar_unit &y, const scalar_unit &z)
	Returns the z coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.
scalar_unit	cartesian_3d_to_spherical_r (const scalar_unit &x, scalar_unit y, scalar_unit z)
	Returns the r coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.
angle	cartesian_3d_to_spherical_theta (const scalar_unit &x, scalar_unit y, const scalar_unit &z)
	Returns the theta coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.
angle	cartesian_3d_to_spherical_phi (const scalar_unit &x, scalar_unit y, scalar_unit z)
	Returns the phi coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.
scalar_unit	spherical_to_cartesian_3d_x (const scalar_unit &r, const angle &theta, const angle &phi)
	Returns the x coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.
scalar_unit	spherical_to_cartesian_3d_y (const scalar_unit &r, const angle &theta, const angle &phi)
	Returns the y coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.
scalar_unit	spherical_to_cartesian_3d_z (const scalar_unit &r, const angle &theta, const angle &phi)
	Returns the z coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.
scalar_unit	spherical_to_cylindrical_p (const scalar_unit &r, const angle &theta, const angle &phi)
	Returns the p coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.
angle	spherical_to_cylindrical_theta (const scalar_unit &r, const angle &theta, const angle &phi)
	Returns the theta coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.
scalar_unit	spherical_to_cylindrical_z (const scalar_unit &r, const angle &theta, const angle &phi)
	Returns the z coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.
scalar_unit	cylindrical_to_cartesian_3d_x (const scalar_unit &p, const angle &theta, const scalar_unit &z)
	Returns the x coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.
scalar_unit	cylindrical_to_cartesian_3d_y (const scalar_unit &p, const angle &theta, const scalar_unit &z)
	Returns the y coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.
scalar_unit	cylindrical_to_cartesian_3d_z (const scalar_unit &p, const angle &theta, const scalar_unit &z)
	Returns the z coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.
scalar_unit	cylindrical_to_spherical_r (const scalar_unit &p, const angle &theta, scalar_unit z)
	Returns the r coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.
angle	cylindrical_to_spherical_theta (const scalar_unit &p, const angle &theta, const scalar_unit &z)
	Returns the theta coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.
angle	cylindrical_to_spherical_phi (const scalar_unit &p, const angle &theta, scalar_unit z)
	Returns the phi coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.
float	cartesian_3d_to_cylindrical_p (float x, float y, float z)
	Returns the p coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.
angle	cartesian_3d_to_cylindrical_theta (float x, float y, float z)
	Returns the theta coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.
float	cartesian_3d_to_cylindrical_z (float x, float y, float z)
	Returns the z coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.
float	cartesian_3d_to_spherical_r (float x, float y, float z)
	Returns the r coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.
angle	cartesian_3d_to_spherical_theta (float x, float y, float z)
	Returns the theta coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.
angle	cartesian_3d_to_spherical_phi (float x, float y, float z)
	Returns the phi coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.
float	spherical_to_cartesian_3d_x (float r, const angle &theta, const angle &phi)
	Returns the x coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.
float	spherical_to_cartesian_3d_y (float r, const angle &theta, const angle &phi)
	Returns the y coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.
float	spherical_to_cartesian_3d_z (float r, const angle &theta, const angle &phi)
	Returns the z coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.
float	spherical_to_cylindrical_p (float r, const angle &theta, const angle &phi)
	Returns the p coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.
angle	spherical_to_cylindrical_theta (float r, const angle &theta, const angle &phi)
	Returns the theta coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.
float	spherical_to_cylindrical_z (float r, const angle &theta, const angle &phi)
	Returns the z coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.
float	cylindrical_to_cartesian_3d_x (float p, const angle &theta, float z)
	Returns the x coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.
float	cylindrical_to_cartesian_3d_y (float p, const angle &theta, float z)
	Returns the y coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.
float	cylindrical_to_cartesian_3d_z (float p, const angle &theta, float z)
	Returns the z coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.
float	cylindrical_to_spherical_r (float p, const angle &theta, float z)
	Returns the r coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.
angle	cylindrical_to_spherical_theta (float p, const angle &theta, float z)
	Returns the theta coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.
angle	cylindrical_to_spherical_phi (float p, const angle &theta, float z)
	Returns the phi coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.
string	to_string (const coordinates_3dr< float > &x)
float	distance (const coordinates_3dr< float > &x, const coordinates_3dr< float > &y)
float	distance (const coordinates_3dr< float > &x, const coordinates_3d< float > &y)
float	distance (const coordinates_3d< float > &x, const coordinates_3dr< float > &y)
template<typename T >
string	to_string (const coordinates_3dr< T > &x)
template<typename T , typename U >
T	distance (const coordinates_3dr< T > &x, const coordinates_3dr< U > &y)
template<typename T , typename U >
T	distance (const coordinates_3dr< T > &x, const coordinates_3d< U > &y)
template<typename T , typename U >
T	distance (const coordinates_3d< T > &x, const coordinates_3dr< U > &y)
string	to_string (const coordinates_nd< float > &x)
float	distance (const coordinates_nd< float > &x, const coordinates_nd< float > &y)
template<typename T >
string	to_string (const coordinates_nd< T > &x)
template<typename T , typename U >
T	distance (const coordinates_nd< T > &x, const coordinates_nd< U > &y)
string	to_string (const coordinates_ndr< float > &x)
float	distance (const coordinates_ndr< float > &x, const coordinates_ndr< float > &y)
float	distance (const coordinates_ndr< float > &x, const coordinates_nd< float > &y)
float	distance (const coordinates_nd< float > &x, const coordinates_ndr< float > &y)
template<typename T >
string	to_string (const coordinates_ndr< T > &x)
template<typename T , typename U >
T	distance (const coordinates_ndr< T > &x, const coordinates_ndr< U > &y)
template<typename T , typename U >
T	distance (const coordinates_ndr< T > &x, const coordinates_nd< U > &y)
template<typename T , typename U >
T	distance (const coordinates_nd< T > &x, const coordinates_ndr< U > &y)
direction::name	create_direction (const string &x)
direction::name	invert (direction::name x)
string	to_string (direction::name x)
string	to_string (const direction &x)
bool	is_latitude (const string &init_latitude)
bool	is_longitude (const string &init_longitude)
string	to_string (const zid &x)
	Returns a string representation of zid, same as display().
string	to_string (const zid::type &x)
	Converts a value of the enum zid::type to its string representation, which is a single letter. The value COUNTRY returns C. The value REGION returns R. The value SETTLEMENT returns S. The value ZONE returns Z.
zid::type	create_zone_type (const string &zone_type_abbreviation)
	Creates an instance of a zid::type with the given string, which is the reverse as the to_string() function of zid::type.
string	to_string (const angle &x)
	Converts an angle to their string representation.
bool	is_angle (const string &init_angle)
	Checks if some string is an initialization string of an angle.
bool	parallel (const angle &x, const angle &y)
	Checks if two angles in a 2D correspond to parallel lines (or parallel vectors).
bool	orthogonal (const angle &x, const angle &y)
	Checks if two angles in a 2D correspond to orthogonal lines (or orthogonal vectors).
angle	sqrt (const angle &x)
	Calculates the square root of the angle x and returns that new angle.
angle	sqrt_nth (const angle &x, int index)
	Calculates the nth root of the angle x and returns that new angle.
float	sin (const angle &x)
	Calculates the sin of angle x. It uses the sin() function of the standard library of C++, the difference is that angle is in degrees, not in radians.
float	cos (const angle &x)
	Calculates the cos of angle x. It uses the cos() function of the standard library of C++, the difference is that angle is in degrees, not in radians.
float	tan (const angle &x)
	Calculates the tan of angle x. It uses the tan() function of the standard library of C++, the difference is that angle is in degrees, not in radians.
angle	asin (float x)
	Calculates the asin of some value x and returns the result as angle in degrees.
angle	acos (float x)
	Calculates the acos of some value x and returns the result as angle in degrees.
angle	atan (float x)
	Calculates the atan of some value x and returns the result as angle in degrees.
angle	atan2 (float y, float x)
float	sinh (const angle &x)
	Calculates the sinh of angle x. It uses the sinh() function of the standard library of C++, the difference is that angle is in degrees, not in radians.
float	cosh (const angle &x)
	Calculates the cosh of angle x. It uses the cosh() function of the standard library of C++, the difference is that angle is in degrees, not in radians.
float	tanh (const angle &x)
	Calculates the tanh of angle x. It uses the tanh() function of the standard library of C++, the difference is that angle is in degrees, not in radians.
angle	asinh (float x)
	Calculates the asinh of some value x and returns the result as angle in degrees.
angle	acosh (float x)
	Calculates the acosh of some value x and returns the result as angle in degrees.
angle	atanh (float x)
	Calculates the atanh of some value x and returns the result as angle in degrees.
float	radian_to_degree (float x)
	Converts a radian to degree.
float	gradian_to_degree (float x)
float	turn_to_degree (float x)
float	degree_to_radian (float x)
	Converts a degree to a radian.
float	gradian_to_radian (float x)
float	turn_to_radian (float x)
float	degree_to_gradian (float x)
float	radian_to_gradian (float x)
float	turn_to_gradian (float x)
float	degree_to_turn (float x)
float	radian_to_turn (float x)
float	gradian_to_turn (float x)
float	asin_degree (float x)
	Calculates the asin receiving x in degrees. It uses the asin() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.
float	acos_degree (float x)
	Calculates the acos receiving x in degrees. It uses the acos() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.
float	atan_degree (float x)
	Calculates the atan receiving x in degrees. It uses the atan() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.
float	asinh_degree (float x)
	Calculates the asinh receiving x in degrees. It uses the asinh() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.
float	acosh_degree (float x)
	Calculates the acosh receiving x in degrees. It uses the acosh() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.
float	atanh_degree (float x)
	Calculates the atanh receiving x in degrees. It uses the atanh() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.
bool	is_complex (const string &init_complex_number)
template<typename T >
string	to_string (const complex_number< T > &x)
template<typename T >
T	abs (const complex_number< T > &x)
template<typename T >
complex_number< scalar_unit >	sqrt (const complex_number< T > &x)
bool	is_lab_number (const string &init_lab_number)
template<typename T >
string	to_string (const lab_number< T > &x)
string	to_string (const percentage &x)
	Returns a string representation of percentage x.
bool	is_percentage (const string &init_percentage)
	Checks if a string is an initialization string of percentage.
	VECTOR_UNIT_CPP (specific_angular_momentum,"m2/s")
	VECTOR_UNIT_HPP (specific_angular_momentum)
	SCALAR_UNIT_CPP (brain_memory,"memo")
	SCALAR_UNIT_HPP (brain_memory)
	SCALAR_UNIT_CPP (density,"g/m3")
	SCALAR_UNIT_CPP (viscosity,"m2/s")
	SCALAR_UNIT_CPP (specific_volume,"m3/g")
	SCALAR_UNIT_CPP (specific_heat_capacity,"J/K*kg")
	SCALAR_UNIT_CPP (specific_entropy,"m2/s2*K")
	SCALAR_UNIT_CPP (specific_energy,"m2/s2")
	SCALAR_UNIT_CPP (molar_volume,"m3/mol")
	SCALAR_UNIT_CPP (molar_mass,"g/mol")
	SCALAR_UNIT_CPP (molar_heat_capacity,"m2*g/s2*K*mol")
	SCALAR_UNIT_CPP (molar_enthalpy,"m2*g/s2*mol")
	SCALAR_UNIT_CPP (molar_entropy,"m2*g/s2*K*mol")
	SCALAR_UNIT_CPP (molar_energy,"m2*g/s2*mol")
	SCALAR_UNIT_CPP (molar_conductivity,"s3*A2/g*mol")
	SCALAR_UNIT_CPP (energy_density,"g/m*s2")
	SCALAR_UNIT_CPP (catalytic_efficiency,"m3/s*mol")
	SCALAR_UNIT_CPP (molarity,"M")
	SCALAR_UNIT_CPP (molality,"mol/g")
	SCALAR_UNIT_CPP (linear_mass_density,"g/m")
	SCALAR_UNIT_CPP (area_density,"g/m2")
	SCALAR_UNIT_CPP (dynamic_viscosity,"g/m*s")
	SCALAR_UNIT_CPP (mass_flow_rate,"g/s")
	SCALAR_UNIT_CPP (catalytic_activity,"kat")
	SCALAR_UNIT_CPP (amount_of_effect,"IU")
	SCALAR_UNIT_HPP (density)
	SCALAR_UNIT_HPP (viscosity)
	SCALAR_UNIT_HPP (specific_volume)
	SCALAR_UNIT_HPP (specific_heat_capacity)
	SCALAR_UNIT_HPP (specific_entropy)
	SCALAR_UNIT_HPP (specific_energy)
	SCALAR_UNIT_HPP (molar_volume)
	SCALAR_UNIT_HPP (molar_mass)
	SCALAR_UNIT_HPP (molar_heat_capacity)
	SCALAR_UNIT_HPP (molar_enthalpy)
	SCALAR_UNIT_HPP (molar_entropy)
	SCALAR_UNIT_HPP (molar_energy)
	SCALAR_UNIT_HPP (molar_conductivity)
	SCALAR_UNIT_HPP (energy_density)
	SCALAR_UNIT_HPP (catalytic_efficiency)
	SCALAR_UNIT_HPP (molarity)
	SCALAR_UNIT_HPP (molality)
	SCALAR_UNIT_HPP (linear_mass_density)
	SCALAR_UNIT_HPP (area_density)
	SCALAR_UNIT_HPP (dynamic_viscosity)
	SCALAR_UNIT_HPP (mass_flow_rate)
	SCALAR_UNIT_HPP (catalytic_activity)
	SCALAR_UNIT_HPP (amount_of_effect)
	SCALAR_UNIT_CPP (electrical_conductivity,"S/m")
	SCALAR_UNIT_CPP (resistance,"Ω")
	SCALAR_UNIT_CPP (electric_conductance,"S")
	SCALAR_UNIT_CPP (capacitance,"F")
	SCALAR_UNIT_CPP (permittivity,"F/m")
	SCALAR_UNIT_CPP (resistivity,"Ω*m")
	SCALAR_UNIT_CPP (linear_charge_density,"C/m")
	SCALAR_UNIT_CPP (surface_charge_density,"C/m2")
	SCALAR_UNIT_CPP (volume_charge_density,"C/m3")
	SCALAR_UNIT_CPP (frequency_drift,"1/s2")
	SCALAR_UNIT_HPP (electrical_conductivity)
	SCALAR_UNIT_HPP (resistance)
	SCALAR_UNIT_HPP (electric_conductance)
	SCALAR_UNIT_HPP (capacitance)
	SCALAR_UNIT_HPP (permittivity)
	SCALAR_UNIT_HPP (resistivity)
	SCALAR_UNIT_HPP (linear_charge_density)
	SCALAR_UNIT_HPP (surface_charge_density)
	SCALAR_UNIT_HPP (volume_charge_density)
	SCALAR_UNIT_HPP (frequency_drift)
	SCALAR_UNIT_CPP (transfer_speed,"B/s")
	SCALAR_UNIT_HPP (transfer_speed)
	VECTOR_UNIT_2D_CPP (displacement,"m")
	VECTOR_UNIT_3D_CPP (displacement,"m")
	VECTOR_UNIT_ND_CPP (displacement,"m")
	VECTOR_UNIT_CPP (velocity,"m/s")
	VECTOR_UNIT_CPP (acceleration,"m/s2")
	VECTOR_UNIT_CPP (momentum,"kg*m/s")
	VECTOR_UNIT_CPP (jerk,"m/s3")
	VECTOR_UNIT_CPP (snap,"m/s4")
	VECTOR_UNIT_CPP (angular_velocity,"rad/s")
	VECTOR_UNIT_CPP (angular_acceleration,"rad/s2")
	VECTOR_UNIT_CPP (angular_momentum,"m2*kg/s")
	VECTOR_UNIT_CPP (impulse,"m*kg/s")
	VECTOR_UNIT_CPP (force,"N")
	VECTOR_UNIT_CPP (torque,"kg*m2/s2")
	VECTOR_UNIT_CPP (pressure,"Pa")
	VECTOR_UNIT_CPP (surface_tension,"kg/s2")
	SCALAR_UNIT_CPP (stiffness,"kg/s2")
	SCALAR_UNIT_CPP (moment_of_inertia,"m2*kg")
	VECTOR_UNIT_CPP (yank,"N/s")
	SCALAR_UNIT_CPP (electric_current,"A")
	SCALAR_UNIT_CPP (voltage,"V")
	VECTOR_UNIT_CPP (electric_displacement_field,"C/m2")
	SCALAR_UNIT_CPP (electric_charge_density,"C/m3")
	SCALAR_UNIT_CPP (electric_current_density,"A/m2")
	VECTOR_UNIT_CPP (electric_field_strength,"V/m")
	SCALAR_UNIT_CPP (electron_mobility,"m2/V*s")
	SCALAR_UNIT_CPP (inductance,"H")
	SCALAR_UNIT_CPP (volumetric_flow,"m3/s")
	SCALAR_UNIT_CPP (diffusion_coefficient,"m2/s")
	SCALAR_UNIT_CPP (compressibility,"m*s2/kg")
	SCALAR_UNIT_CPP (polarization_density,"C/m2")
	SCALAR_UNIT_CPP (magnetic_permeability,"H/m")
	SCALAR_UNIT_CPP (magnetization,"A/m")
	SCALAR_UNIT_CPP (magnetic_flux,"Wb")
	VECTOR_UNIT_CPP (magnetic_flux_density,"T")
	VECTOR_UNIT_CPP (magnetic_moment,"Wb*m")
	SCALAR_UNIT_CPP (magnetic_reluctance,"1/H")
	VECTOR_UNIT_CPP (magnetic_vector_potential,"Wb/m")
	SCALAR_UNIT_CPP (magnetic_rigidity,"T*m")
	VECTOR_UNIT_CPP (magnetomotive_force,"A*rad")
	SCALAR_UNIT_CPP (magnetic_susceptibility,"m/H")
	SCALAR_UNIT_CPP (optical_power,"1/m")
	SCALAR_UNIT_CPP (illuminance,"lx")
	SCALAR_UNIT_CPP (luminous_flux,"lm")
	SCALAR_UNIT_CPP (luminous_energy,"lm*s")
	SCALAR_UNIT_CPP (luminous_exposure,"lx*s")
	SCALAR_UNIT_CPP (luminous_efficacy,"lm/W")
	SCALAR_UNIT_CPP (ionizing_radiation,"Gy")
	SCALAR_UNIT_CPP (absorbed_dose,"Gy/s")
	SCALAR_UNIT_CPP (energy,"J")
	SCALAR_UNIT_CPP (action,"kg*m2/s")
	SCALAR_UNIT_CPP (power,"W")
	SCALAR_UNIT_CPP (power_density,"kg/m*s3")
	SCALAR_UNIT_CPP (entropy,"kg*m2/K*s2")
	SCALAR_UNIT_CPP (heat_capacity,"J/K")
	SCALAR_UNIT_CPP (heat_flux_density,"kg/s3")
	SCALAR_UNIT_CPP (thermal_conductivity,"W/m*K")
	SCALAR_UNIT_CPP (thermal_diffusivity,"m2/s")
	SCALAR_UNIT_CPP (thermal_resistance,"K/W")
	SCALAR_UNIT_CPP (thermal_expansion_coefficient,"1/K")
	VECTOR_UNIT_CPP (temperature_gradient,"K/m")
	SCALAR_UNIT_CPP (energy_flux_density,"kg/s3")
	SCALAR_UNIT_CPP (fuel_efficiency,"1/m2")
	SCALAR_UNIT_CPP (wavenumber,"1/m")
	SCALAR_UNIT_CPP (frequency,"Hz")
	SCALAR_UNIT_CPP (sound_power,"dB")
	VECTOR_UNIT_2D_HPP (displacement)
	VECTOR_UNIT_3D_HPP (displacement)
	VECTOR_UNIT_ND_HPP (displacement)
	VECTOR_UNIT_HPP (velocity)
	VECTOR_UNIT_HPP (acceleration)
	VECTOR_UNIT_HPP (momentum)
	VECTOR_UNIT_HPP (jerk)
	VECTOR_UNIT_HPP (snap)
	VECTOR_UNIT_HPP (angular_velocity)
	VECTOR_UNIT_HPP (angular_acceleration)
	VECTOR_UNIT_HPP (angular_momentum)
	VECTOR_UNIT_HPP (impulse)
	VECTOR_UNIT_HPP (force)
	VECTOR_UNIT_HPP (torque)
	VECTOR_UNIT_HPP (pressure)
	VECTOR_UNIT_HPP (surface_tension)
	SCALAR_UNIT_HPP (stiffness)
	SCALAR_UNIT_HPP (moment_of_inertia)
	VECTOR_UNIT_HPP (yank)
	SCALAR_UNIT_HPP (electric_current)
	SCALAR_UNIT_HPP (voltage)
	VECTOR_UNIT_HPP (electric_displacement_field)
	SCALAR_UNIT_HPP (electric_charge_density)
	SCALAR_UNIT_HPP (electric_current_density)
	VECTOR_UNIT_HPP (electric_field_strength)
	SCALAR_UNIT_HPP (electron_mobility)
	SCALAR_UNIT_HPP (inductance)
	SCALAR_UNIT_HPP (volumetric_flow)
	SCALAR_UNIT_HPP (diffusion_coefficient)
	SCALAR_UNIT_HPP (compressibility)
	SCALAR_UNIT_HPP (polarization_density)
	SCALAR_UNIT_HPP (magnetic_permeability)
	SCALAR_UNIT_HPP (magnetization)
	SCALAR_UNIT_HPP (magnetic_flux)
	VECTOR_UNIT_HPP (magnetic_flux_density)
	VECTOR_UNIT_HPP (magnetic_moment)
	SCALAR_UNIT_HPP (magnetic_reluctance)
	VECTOR_UNIT_HPP (magnetic_vector_potential)
	SCALAR_UNIT_HPP (magnetic_rigidity)
	VECTOR_UNIT_HPP (magnetomotive_force)
	SCALAR_UNIT_HPP (magnetic_susceptibility)
	SCALAR_UNIT_HPP (optical_power)
	SCALAR_UNIT_HPP (illuminance)
	SCALAR_UNIT_HPP (luminous_flux)
	SCALAR_UNIT_HPP (luminous_energy)
	SCALAR_UNIT_HPP (luminous_exposure)
	SCALAR_UNIT_HPP (luminous_efficacy)
	SCALAR_UNIT_HPP (ionizing_radiation)
	SCALAR_UNIT_HPP (absorbed_dose)
	SCALAR_UNIT_HPP (energy)
	SCALAR_UNIT_HPP (action)
	SCALAR_UNIT_HPP (power)
	SCALAR_UNIT_HPP (power_density)
	SCALAR_UNIT_HPP (entropy)
	SCALAR_UNIT_HPP (heat_capacity)
	SCALAR_UNIT_HPP (heat_flux_density)
	SCALAR_UNIT_HPP (thermal_conductivity)
	SCALAR_UNIT_HPP (thermal_diffusivity)
	SCALAR_UNIT_HPP (thermal_resistance)
	SCALAR_UNIT_HPP (thermal_expansion_coefficient)
	VECTOR_UNIT_HPP (temperature_gradient)
	SCALAR_UNIT_HPP (energy_flux_density)
	SCALAR_UNIT_HPP (fuel_efficiency)
	SCALAR_UNIT_HPP (wavenumber)
	SCALAR_UNIT_HPP (frequency)
	SCALAR_UNIT_HPP (sound_power)
	SCALAR_UNIT_CPP (radioactivity,"Bq")
	VECTOR_UNIT_CPP (irradiance,"kg/s3")
	VECTOR_UNIT_CPP (radiant_exposure,"kg/s2")
	SCALAR_UNIT_CPP (radiant_intensity,"kg*m2/s3")
	SCALAR_UNIT_CPP (radiance,"kg/s3")
	SCALAR_UNIT_CPP (spectral_radiance,"kg/m*s3")
	VECTOR_UNIT_CPP (radiant_flux,"kg*m2/s3")
	VECTOR_UNIT_CPP (spectral_flux,"kg*m/s3")
	SCALAR_UNIT_HPP (radioactivity)
	VECTOR_UNIT_HPP (irradiance)
	VECTOR_UNIT_HPP (radiant_exposure)
	SCALAR_UNIT_HPP (radiant_intensity)
	SCALAR_UNIT_HPP (radiance)
	SCALAR_UNIT_HPP (spectral_radiance)
	VECTOR_UNIT_HPP (radiant_flux)
	VECTOR_UNIT_HPP (spectral_flux)
	SCALAR_UNIT_CPP (area,"m2")
	SCALAR_UNIT_CPP (volume,"m3")
	SCALAR_UNIT_CPP (volume_4d,"m4")
	SCALAR_UNIT_CPP (curvature,"1/m")
	SCALAR_UNIT_HPP_BEGIN (area)
	area (const size_2d< length > &)
	SCALAR_UNIT_HPP_END ()
	SCALAR_UNIT_HPP_BEGIN (volume)
	volume (const size_3d< length > &)
	SCALAR_UNIT_HPP (volume_4d)
	SCALAR_UNIT_HPP (curvature)
string	to_string (const pixel &x)
bool	is_pixel (const string &init_pixel)
pixel	sqrt (const pixel &x)
pixel	sqrt_nth (const pixel &x, int index)
string	to_string (const size_2d< float > &x)
	Returns a string representation of size_2d<float>.
template<typename T >
string	to_string (const size_2d< T > &x)
	Returns a string representation of size_2d<T>.
string	to_string (const size_3d< float > &x)
	Returns a string representation of size_3d<float>.
template<typename T >
string	to_string (const size_3d< T > &x)
	Returns a string representation of size_3d<T>.
string	to_string (const size_nd< float > &x)
template<typename T >
string	to_string (const size_nd< T > &x)
	SCALAR_UNIT_CPP (length,"m")
	SCALAR_UNIT_CPP (mass,"g")
	SCALAR_UNIT_CPP (charge,"C")
	SCALAR_UNIT_CPP (temperature,"K")
	SCALAR_UNIT_CPP (mole,"mol")
	SCALAR_UNIT_CPP (light_intensity,"cd")
	SCALAR_UNIT_CPP (information_size,"B")
	SCALAR_UNIT_HPP (length)
	SCALAR_UNIT_HPP_BEGIN (mass)
	mass (const percentage &new_percentage, const mass &new_mass)
	mass (const string &init_percentage, const string &init_mass)
	SCALAR_UNIT_HPP (charge)
	SCALAR_UNIT_HPP (temperature)
	SCALAR_UNIT_HPP_BEGIN (mole)
	mole (const percentage &new_percentage, const mole &new_mole)
	mole (const string &init_percentage, const string &init_mole)
int	get_number_of_particles () const
	SCALAR_UNIT_HPP (light_intensity)
	SCALAR_UNIT_HPP (information_size)
float	fahrenheit_to_kelvin (float x)
float	kelvin_to_fahrenheit (float x)
string	to_string (const dimension &x)
	Creates the string representation of a dimension.
string	to_string (const vector< dimension > &x_dimensions, bool with_brackets)
	Creates the string representation of a vector of dimensions. Used to display the dimensions of scalar_unit and all vector_unit classes. The dimensions can be displayed optionally between brackets like '[]' too.
string	to_latex (const vector< dimension > &x_dimensions, bool with_brackets)
vector< dimension >	create_dimensions (string init_dimensions)
	Creates the dimensions from an initialization string of dimensions.
vector< dimension >	create_base_dimensions (const string &init_dimensions)
	Creates the base dimensions from an initialization string of dimensions.
vector< dimension >	create_base_dimensions (const vector< dimension > &x)
	Creates all the base dimensions from a vector of dimensions.
vector< dimension >	create_base_dimensions (const vector< dimension > &x, long double &value)
	Creates all the base dimensions from a vector of dimensions, updating also the associated value related to those dimensions based on the prefix math and the conversion factor of the dimension, if that conversion factor is different than one.
vector< dimension >	multiply_dimensions (const vector< dimension > &x, const vector< dimension > &y)
	Multiplies two vectors of dimensions. The result is normalized after, which means that equal dimensions at the numerator and at the denominator are cancelled.
vector< dimension >	multiply_dimensions (vector< dimension > x, const vector< dimension > &y, long double &value)
	Multiplies two vectors of dimensions. The result is normalized after, which means that equal dimensions at the numerator and at the denominator are cancelled. It also updates the value associated with those two vectors of dimensions with the prefix m ath and the conversion factor of those dimensions.
vector< dimension >	divide_dimensions (vector< dimension > x, const vector< dimension > &y, long double &value)
	Divides the first vector of dimensions with the other. The result is normalized after, which means that equal dimensions at the numerator and at the denominator are cancelled. It also updates the value associated with those two vectors of dimensions with the prefix m ath and the conversion factor of those dimensions.
vector< dimension >	square_dimensions (vector< dimension > x, int index, long double &value)
	Squares a vector of dimensions by an index. The value is updated too related to the prefix math and the conversion factor of this operation.
vector< dimension >	power_dimensions (const vector< dimension > &x, int exponent)
	Powers the dimensions by an exponent.
vector< dimension >	normalize_dimensions (const vector< dimension > &x)
	Normalizes the dimensions, which means that repited dimensions at the numerator and at the denominator are cancelled.
vector< dimension >	normalize_dimensions (const vector< dimension > &x, long double &value)
	Normalizes the dimensions, which means that repited dimensions at the numerator and at the denominator are cancelled. The value is updated if there are dimensions cancelled.
bool	is_dimension_char (const UChar32 &x)
bool	common_dimension (const dimension &x, const dimension &y)
	Checks if there's an equal basic dimension between the basic dimensions of those two dimensions.
bool	equal_dimensions (const string &init_dimensions_x, const string &init_dimensions_y)
	Checks if two initialization strings of dimensions initialize the same basic dimensions.
bool	equal_dimensions (const vector< dimension > &x, const vector< dimension > &y)
bool	equal_dimensions_and_prefixes (const vector< dimension > &x, const vector< dimension > &y)
	Checks if the base dimensions of two vectors of dimensions are equal, and if they have also the same prefixes.
prefix::type	prefix_string (const string &x)
	Returns the value of the enum prefix::type associated with the string x given.
prefix	closest_prefix (const prefix &actual_prefix, int actual_scale)
	Returns the closes prefix related to the scale of the current value. It is used when displaying a scalar_unit to the most close prefix available.
prefix	create_prefix_by_factor (int factor)
	Creates the prefix of the factor given, which is always between a range.
string	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	is_scalar_unit (const string &init_scalar)
	Checks if an string is an initialization string of a scalar_unit.
float	abs (const scalar_unit &x)
	Returns the absolute value of the scalar_unit, without dimensions.
scalar_unit	pow (const scalar_unit &x, int exponent)
	Exponentiates a scalar_unit to some numeric type, the dimensions are also exponentiated.
scalar_unit	sqrt (const scalar_unit &x)
	Square root of a scalar_unit, it squares the dimensions too.
scalar_unit	sqrt_nth (const scalar_unit &x, int index)
	Nth root of a scalar_unit to any numeric value, it squares the dimensions too.
scalar_unit	norm (const vector_unit_2d &x)
	It returns the value of the vector in polar coordinates, p.
vector_unit_2d	sqrt (const vector_unit_2d &x)
	It squares the vector, creating a vector_unit_2d with the value squared and always the same theta. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.
vector_unit_2d	sqrt_nth (const vector_unit_2d &x, int index)
	It takes the root of the vector with the index given, creating a vector_unit_2d with the value rooted to that index and always maintains the same theta. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.
scalar_unit	dot_product (const vector_unit_2d &x, const vector_unit_2d &y)
	Creates a scalar_unit as the dot product of the two vectors x and y.
angle	angle_between (const vector_unit_2d &x, const vector_unit_2d &y)
	Returns the angle between two vectors x and y inside a 2D space.
bool	same_direction (const vector_unit_2d &x, const vector_unit_2d &y)
	Checks if two vectors x and y have the same direction.
bool	parallel (const vector_unit_2d &x, const vector_unit_2d &y)
	Checks if two vectors x and y are parallel, which means that their direction is the same or the exact opposite.
bool	orthogonal (const vector_unit_2d &x, const vector_unit_2d &y)
	Checks if two vectors x and y are orthogonal, that's, if they have 90 degrees of difference.
string	to_string (const vector_unit_2d &x)
	It generates a string representation of vector_unit_2d.
scalar_unit	norm (const vector_unit_3d &x)
	It returns the value of the vector in spherical coordinates, r.
vector_unit_3d	sqrt (const vector_unit_3d &x)
	It squares the vector, creating a vector_unit_3d with the value squared and always the same theta and the same phi. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.
vector_unit_3d	sqrt_nth (const vector_unit_3d &x, int index)
	It takes the root of the vector with the index given, creating a vector_unit_3d with the value rooted to that index and always maintains the same theta and the same phi. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.
scalar_unit	dot_product (const vector_unit_3d &x, const vector_unit_3d &y)
	Creates a scalar_unit as the dot product of the two vectors x and y.
vector_unit_3d	cross_product (const vector_unit_3d &x, const vector_unit_3d &y)
	Creates a vector_unit_3d as the cross product of the two vectors x and y.
angle	angle_between (const vector_unit_3d &x, const vector_unit_3d &y)
	Returns the angle between two vectors x and y inside a 3D space.
bool	same_direction (const vector_unit_3d &x, const vector_unit_3d &y)
	Checks if two vectors x and y have the same direction.
bool	parallel (const vector_unit_3d &x, const vector_unit_3d &y)
	Checks if two vectors x and y are parallel, which means that their direction is the same or the exact opposite.
bool	orthogonal (const vector_unit_3d &x, const vector_unit_3d &y)
	Checks if two vectors x and y are orthogonal, that's, if they have 90 degrees between them.
string	to_string (const vector_unit_3d &x)
	It generates a string representation of vector_unit_3d.
string	to_string (const vector_unit_nd &x)
	It generates a string representation of vector_unit_nd.
scalar_unit	norm (const vector_unit_nd &x)
	It returns the value of the vector, which is the value in 1D, p in 2D (polar coordinates), or r in 3D (spherical coordinates).
vector_unit_nd	sqrt (const vector_unit_nd &x)
	It squares the vector, creating a vector_unit_nd with the value squared and always the same angles. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.
vector_unit_nd	sqrt_nth (const vector_unit_nd &x, int index)
	It takes the root of the vector with the index given, creating a vector_unit_nd with the value rooted to that index and always maintains the same angles. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.
scalar_unit	dot_product (const vector_unit_nd &x, const vector_unit_nd &y)
	Creates a scalar_unit as the dot product of the two vectors x and y.
vector_unit_nd	cross_product (const vector_unit_nd &x, const vector_unit_nd &y)
	Creates a vector_unit_nd as the cross product of the two vectors x and y. If both vectors aren't in 3D, it returns an empty vector_unit_nd, because the cross product doesn't exists outside 3D.
angle	angle_between (const vector_unit_nd &x, const vector_unit_nd &y)
	Returns the angle between two vectors x and y inside the ND space, which can be 2D or 3D, depending on the ND of the vectors. If the vectors have different ND, it returns an empty vector_unit_nd instead.
bool	same_nd (const vector_unit_nd &x, const vector_unit_nd &y)
	Checks if two vectors have the same number of dimensions.
bool	same_direction (const vector_unit_nd &x, const vector_unit_nd &y)
	Checks if two vectors x and y have the same direction. Both vectors must have the same ND, otherwise it returns an empty vector_unit_nd instead.
bool	parallel (const vector_unit_nd &x, const vector_unit_nd &y)
	Checks if two vectors x and y are parallel, which means that their direction is the same or the exact opposite. Both vectors must have the same ND, otherwise it returns an empty vector_unit_nd instead.
bool	orthogonal (const vector_unit_nd &x, const vector_unit_nd &y)
	Checks if two vectors x and y are orthogonal, that's, if they have 90 degrees between them. Both vectors must have the same ND, otherwise it returns an empty vector_unit_nd instead.
float	parse_float (const string &x)
int	parse_int (const string &x)
string	display_float (const float &value, int number_of_decimals)
string	display_double (const double &value, int number_of_decimals)
string	display_long_double (const long double &value, int number_of_decimals)

Variables
angle	coordinates_ndr_no_angle = angle()
const scalar_unit	WGS84_EARTH_SEMIAXIS_A = 6378137_m
const scalar_unit	WGS84_EARTH_SEMIAXIS_B = 6356752.314245_m
const long double	HYPERFINE_TRANSITION_FREQUENCY_OF_CS = 9192631770.0l
const long double	SPEED_OF_LIGHT = 299792458.0l
const long double	PLANCK_CONSTANT = 6.62607015e-34
const long double	ELEMENTARY_CHARGE = 1.602176634e-19
const long double	BOLTZMANN_CONSTANT = 1.380649e-23
const long double	AVOGADRO_CONSTANT = 6.02214076e23
const long double	LUMINOUS_EFFICACY_OF_540_THZ_RADIATION = 683.0l
const long double	GRAVITATIONAL_CONSTANT = 6.6743e-11
const long double	MOLAR_GAS_CONSTANT = 8.31446261815324l
const long double	ATOMIC_MASS_CONSTANT = 1.66053906660e-27
const long double	COULOMB_CONSTANT = 8.9875517873681764e9
const long double	VACUUM_PERMITTIVITY = 8.8541878188e-12
const long double	RYDBERG_CONSTANT = 1.0973731568539e7
const long double	FARADAY_CONSTANT = 9.64853321233100184e4

Detailed Description

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

Typedef Documentation

wavelength

typedef length scifir::wavelength

Definition at line 97 of file physics_units.hpp.

Enumeration Type Documentation

astronomical_body

enum class scifir::astronomical_body : int8_t

strong

Contains predefined astronomical bodies to be set automatically in the aid class. All of them are important astronomical bodies, unimportant astronomical bodies aren't included.

Enumerator
NONE	No predefined astronomical body selected.
MILKY_WAY	The Milky Way galaxy.
ANDROMEDA	The Andromeda galaxy, 2.5 million light years from Earth.
SOLAR_SYSTEM	The Solar System of the Earth.
SUN	The Sun, the sun of the solar system of the Earth.
MOON	The Moon of the Earth.
MERCURY	The planet Mercury.
VENUS	The planet Venus.
EARTH	The planet Earth.
MARS	The planet Mars.
JUPITER	The planet Jupiter.
SATURN	The planet Saturn.
URANUS	The planet Uranus.
NEPTUNE	The planet Neptune.
CERES	The dwarf planet Ceres.
ORCUS	The possible dwarf planet Orcus.
PLUTO	The dwarf planet Pluto.
HAUMEA	The dwarf planet Haumea.
QUAOAR	The dwarf planet Quaoar.
MAKEMAKE	The dwarf planet Makemake.
GONGGONG	The possible dwarf planet Gonggong.
ERIS	The dwarf planet Eris.
SEDNA	The minor body Sedna.
IO	The moon of Jupiter Io.
EUROPA	The moon of Jupiter Europa.
GANYMEDE	The moon of Jupiter Ganymede.
CALLISTO	The moon of Jupiter Callisto.
MIMAS	The moon of Saturn Mimas.
ENCELADUS	The moon of Saturn Enceladus.
TETHYS	The moon of Saturn Tethys.
DIONE	The moon of Saturn Dione.
RHEA	The moon of Saturn Rhea.
TITAN	The moon of Saturn Titan.
IAPETUS	The moon of Saturn Iapetus.
MIRANDA	The moon of Uranus Miranda.
ARIEL	The moon of Uranus Ariel.
UMBRIEL	The moon of Uranus Umbriel.
TITANIA	The moon of Uranus Titania.
OBERON	The moon of Uranus Oberon.
TRITON	The moon of Neptune Triton.
CHARON	The moon of Pluto Charon.
DYSNOMIA	The moon of Eris Dysnomia.

Definition at line 11 of file aid.hpp.

: int8_t {NONE,MILKY_WAY,ANDROMEDA,SOLAR_SYSTEM,SUN,MOON,MERCURY,VENUS,EARTH,MARS,JUPITER,SATURN,URANUS,NEPTUNE,CERES,ORCUS,PLUTO,HAUMEA,QUAOAR,MAKEMAKE,GONGGONG,ERIS,SEDNA,IO,EUROPA,GANYMEDE,CALLISTO,MIMAS,ENCELADUS,TETHYS,DIONE,RHEA,TITAN,IAPETUS,MIRANDA,ARIEL,UMBRIEL,TITANIA,OBERON,TRITON,CHARON,DYSNOMIA};

cardinale_point

enum class scifir::cardinale_point

strong

Enumerator
NORTH
SOUTH
EAST
WEST

Definition at line 20 of file coordinates_3d.hpp.

{ NORTH, SOUTH, EAST, WEST };

Function Documentation

abs() [1/2]

template<typename T >

T scifir::abs

(

const complex_number< T > &

x

)

Definition at line 186 of file complex_number.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.real,2) + scifir::pow(x.imaginary,2)));
    }

abs() [2/2]

float scifir::abs

(

const scalar_unit &

x

)

Returns the absolute value of the scalar_unit, without dimensions.

Definition at line 937 of file scalar_unit.cpp.

    {
        return std::abs(x.get_value());
    }

acos()

angle scifir::acos

(

float

x

)

Calculates the acos of some value x and returns the result as angle in degrees.

Definition at line 446 of file angle.cpp.

    {
        return angle(radian_to_degree(std::acos(x)));
    }

acos_degree()

float scifir::acos_degree ( float  x )

inline

Calculates the acos receiving x in degrees. It uses the acos() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.

Definition at line 247 of file angle.hpp.

    {
        return radian_to_degree(std::acos(x));
    }

acosh()

angle scifir::acosh

(

float

x

)

Calculates the acosh of some value x and returns the result as angle in degrees.

Definition at line 481 of file angle.cpp.

    {
        return angle(radian_to_degree(std::acosh(x)));
    }

acosh_degree()

float scifir::acosh_degree ( float  x )

inline

Calculates the acosh receiving x in degrees. It uses the acosh() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.

Definition at line 262 of file angle.hpp.

    {
        return radian_to_degree(std::acosh(x));
    }

angle_between() [1/3]

angle scifir::angle_between	(	const vector_unit_2d &	x,
		const vector_unit_2d &	y
	)

Returns the angle between two vectors x and y inside a 2D space.

Definition at line 369 of file vector_unit_2d.cpp.

    {
        return scifir::atan2(float(y.y_projection() * x.x_projection() - y.x_projection() * x.y_projection()),float(y.x_projection() * x.x_projection() + y.y_projection() * x.y_projection()));
    }

angle_between() [2/3]

angle scifir::angle_between	(	const vector_unit_3d &	x,
		const vector_unit_3d &	y
	)

Returns the angle between two vectors x and y inside a 3D space.

Definition at line 496 of file vector_unit_3d.cpp.

    {
        return scifir::acos(float(dot_product(x,y)/(norm(x)*norm(y))));
    }

angle_between() [3/3]

angle scifir::angle_between	(	const vector_unit_nd &	x,
		const vector_unit_nd &	y
	)

Returns the angle between two vectors x and y inside the ND space, which can be 2D or 3D, depending on the ND of the vectors. If the vectors have different ND, it returns an empty vector_unit_nd instead.

Definition at line 843 of file vector_unit_nd.cpp.

    {
        return scifir::acos(float(dot_product(x,y)/(norm(x) * norm(y))));
    }

area()

scifir::area::area ( const size_2d< length > &  x )

explicit

Definition at line 13 of file space_units.cpp.

                                       : scalar_unit()
    {
        length x_height = x.height;
        x_height.change_dimensions(x.width);
        *this = x.width * x_height;
    }

asin()

angle scifir::asin

(

float

x

)

Calculates the asin of some value x and returns the result as angle in degrees.

Definition at line 441 of file angle.cpp.

    {
        return angle(radian_to_degree(std::asin(x)));
    }

asin_degree()

float scifir::asin_degree ( float  x )

inline

Calculates the asin receiving x in degrees. It uses the asin() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.

Definition at line 242 of file angle.hpp.

    {
        return radian_to_degree(std::asin(x));
    }

asinh()

angle scifir::asinh

(

float

x

)

Calculates the asinh of some value x and returns the result as angle in degrees.

Definition at line 476 of file angle.cpp.

    {
        return angle(radian_to_degree(std::asinh(x)));
    }

asinh_degree()

float scifir::asinh_degree ( float  x )

inline

Calculates the asinh receiving x in degrees. It uses the asinh() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.

Definition at line 257 of file angle.hpp.

    {
        return radian_to_degree(std::asinh(x));
    }

atan()

angle scifir::atan

(

float

x

)

Calculates the atan of some value x and returns the result as angle in degrees.

Definition at line 451 of file angle.cpp.

    {
        return angle(radian_to_degree(std::atan(x)));
    }

atan2()

angle scifir::atan2	(	float	y,
		float	x
	)

Definition at line 456 of file angle.cpp.

    {
        return angle(radian_to_degree(std::atan2(y,x)));
    }

atan_degree()

float scifir::atan_degree ( float  x )

inline

Calculates the atan receiving x in degrees. It uses the atan() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.

Definition at line 252 of file angle.hpp.

    {
        return radian_to_degree(std::atan(x));
    }

atanh()

angle scifir::atanh

(

float

x

)

Calculates the atanh of some value x and returns the result as angle in degrees.

Definition at line 486 of file angle.cpp.

    {
        return angle(radian_to_degree(std::atanh(x)));
    }

atanh_degree()

float scifir::atanh_degree ( float  x )

inline

Calculates the atanh receiving x in degrees. It uses the atanh() function of the standard library of C++, but the difference is that the argument is in degrees, not in radians.

Definition at line 267 of file angle.hpp.

    {
        return radian_to_degree(std::atanh(x));
    }

cartesian_2d_to_polar_p() [1/2]

scalar_unit scifir::cartesian_2d_to_polar_p ( const scalar_unit &  x, scalar_unit  y  )

inline

Definition at line 354 of file coordinates_2d.hpp.

    {
        y.change_dimensions(x);
        return scalar_unit(std::sqrt(std::pow(float(x),2) + std::pow(float(y),2)),x.get_dimensions());
    }

cartesian_2d_to_polar_p() [2/2]

float scifir::cartesian_2d_to_polar_p ( float  x, float  y  )

inline

Definition at line 376 of file coordinates_2d.hpp.

    {
        return float(std::sqrt(std::pow(x,2) + std::pow(y,2)));
    }

cartesian_2d_to_polar_theta() [1/2]

angle scifir::cartesian_2d_to_polar_theta ( const scalar_unit &  x, scalar_unit  y  )

inline

Definition at line 360 of file coordinates_2d.hpp.

    {
        y.change_dimensions(x);
        return scifir::angle(scifir::atan_degree(float(y)/float(x)));
    }

cartesian_2d_to_polar_theta() [2/2]

angle scifir::cartesian_2d_to_polar_theta ( float  x, float  y  )

inline

Definition at line 381 of file coordinates_2d.hpp.

    {
        return scifir::angle(scifir::atan_degree(y/x));
    }

cartesian_3d_to_cylindrical_p() [1/2]

scalar_unit scifir::cartesian_3d_to_cylindrical_p ( const scalar_unit &  x, scalar_unit  y, const scalar_unit &  z  )

inline

Returns the p coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 726 of file coordinates_3d.hpp.

    {
        y.change_dimensions(x);
        return scalar_unit(std::sqrt(std::pow(float(x),2) + std::pow(float(y),2)),x.get_dimensions());
    }

cartesian_3d_to_cylindrical_p() [2/2]

float scifir::cartesian_3d_to_cylindrical_p ( float  x, float  y, float  z  )

inline

Returns the p coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 825 of file coordinates_3d.hpp.

    {
        return float(std::sqrt(std::pow(x,2) + std::pow(y,2)));
    }

cartesian_3d_to_cylindrical_theta() [1/2]

angle scifir::cartesian_3d_to_cylindrical_theta ( const scalar_unit &  x, scalar_unit  y, const scalar_unit &  z  )

inline

Returns the theta coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 732 of file coordinates_3d.hpp.

    {
        y.change_dimensions(x);
        return angle(scifir::atan_degree(float(y) / float(x)));
    }

cartesian_3d_to_cylindrical_theta() [2/2]

angle scifir::cartesian_3d_to_cylindrical_theta ( float  x, float  y, float  z  )

inline

Returns the theta coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 830 of file coordinates_3d.hpp.

    {
        return angle(scifir::atan_degree(y / x));
    }

cartesian_3d_to_cylindrical_z() [1/2]

scalar_unit scifir::cartesian_3d_to_cylindrical_z ( const scalar_unit &  x, const scalar_unit &  y, const scalar_unit &  z  )

inline

Returns the z coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 738 of file coordinates_3d.hpp.

    {
        return z;
    }

cartesian_3d_to_cylindrical_z() [2/2]

float scifir::cartesian_3d_to_cylindrical_z ( float  x, float  y, float  z  )

inline

Returns the z coordinate of the cylindrical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 835 of file coordinates_3d.hpp.

    {
        return z;
    }

cartesian_3d_to_spherical_phi() [1/2]

angle scifir::cartesian_3d_to_spherical_phi ( const scalar_unit &  x, scalar_unit  y, scalar_unit  z  )

inline

Returns the phi coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 756 of file coordinates_3d.hpp.

    {
        y.change_dimensions(x);
        z.change_dimensions(x);
        return angle(scifir::acos_degree(float(z) / float(std::sqrt(std::pow(float(x),2) + std::pow(float(y),2) + std::pow(float(z),2)))));
    }

cartesian_3d_to_spherical_phi() [2/2]

angle scifir::cartesian_3d_to_spherical_phi ( float  x, float  y, float  z  )

inline

Returns the phi coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 850 of file coordinates_3d.hpp.

    {
        return angle(scifir::acos_degree(z / float(std::sqrt(std::pow(x,2) + std::pow(y,2) + std::pow(z,2)))));
    }

cartesian_3d_to_spherical_r() [1/2]

scalar_unit scifir::cartesian_3d_to_spherical_r ( const scalar_unit &  x, scalar_unit  y, scalar_unit  z  )

inline

Returns the r coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 743 of file coordinates_3d.hpp.

    {
        y.change_dimensions(x);
        z.change_dimensions(x);
        return scalar_unit(std::sqrt(std::pow(float(x),2) + std::pow(float(y),2) + std::pow(float(z),2)),x.get_dimensions());
    }

cartesian_3d_to_spherical_r() [2/2]

float scifir::cartesian_3d_to_spherical_r ( float  x, float  y, float  z  )

inline

Returns the r coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 840 of file coordinates_3d.hpp.

    {
        return float(std::sqrt(std::pow(x,2) + std::pow(y,2) + std::pow(z,2)));
    }

cartesian_3d_to_spherical_theta() [1/2]

angle scifir::cartesian_3d_to_spherical_theta ( const scalar_unit &  x, scalar_unit  y, const scalar_unit &  z  )

inline

Returns the theta coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 750 of file coordinates_3d.hpp.

    {
        y.change_dimensions(x);
        return angle(scifir::atan_degree(float(y) / float(x)));
    }

cartesian_3d_to_spherical_theta() [2/2]

angle scifir::cartesian_3d_to_spherical_theta ( float  x, float  y, float  z  )

inline

Returns the theta coordinate of the spherical coordinates given the x, y and z of cartesian coordinates in 3D.

Definition at line 845 of file coordinates_3d.hpp.

    {
        return angle(scifir::atan_degree(y / x));
    }

closest_prefix()

prefix scifir::closest_prefix	(	const prefix &	actual_prefix,
		int	actual_scale
	)

Returns the closes prefix related to the scale of the current value. It is used when displaying a scalar_unit to the most close prefix available.

Definition at line 323 of file prefix.cpp.

    {
        int factor_difference = actual_scale + actual_prefix.get_conversion_factor();
        return create_prefix_by_factor(factor_difference);
        
    }

common_dimension()

bool scifir::common_dimension	(	const dimension &	x,
		const dimension &	y
	)

Checks if there's an equal basic dimension between the basic dimensions of those two dimensions.

Definition at line 2340 of file dimension.cpp.

    {
        for (const dimension& x_dimension : x.get_base_dimensions())
        {
            for (const dimension& y_dimension : y.get_base_dimensions())
            {
                if (x_dimension.dimension_type == y_dimension.dimension_type and x_dimension.dimension_position == y_dimension.dimension_position)
                {
                    return true;
                }
            }
        }
        return false;
    }

cos()

float scifir::cos

(

const angle &

x

)

Calculates the cos of angle x. It uses the cos() function of the standard library of C++, the difference is that angle is in degrees, not in radians.

Definition at line 431 of file angle.cpp.

    {
        return std::cos(x.get_radian());
    }

cosh()

float scifir::cosh

(

const angle &

x

)

Calculates the cosh of angle x. It uses the cosh() function of the standard library of C++, the difference is that angle is in degrees, not in radians.

Definition at line 466 of file angle.cpp.

    {
        return std::cosh(x.get_radian());
    }

create_astronomical_type()

aid::type scifir::create_astronomical_type

(

const string &

astronomical_type_abbreviation

)

Creates an instance of an aid::type with the given string, which is the reverse as the to_string() function of aid::type.

Definition at line 613 of file aid.cpp.

    {
        if (astronomical_type_abbreviation == "U")
        {
            return aid::UNIVERSE;
        }
        else if (astronomical_type_abbreviation == "G")
        {
            return aid::GALAXY;
        }
        else if (astronomical_type_abbreviation == "SS")
        {
            return aid::SOLAR_SYSTEM;
        }
        else if (astronomical_type_abbreviation == "P")
        {
            return aid::PLANET;
        }
        else if (astronomical_type_abbreviation == "ST")
        {
            return aid::STAR;
        }
        else if (astronomical_type_abbreviation == "A")
        {
            return aid::ASTEROID;
        }
        else if (astronomical_type_abbreviation == "MN")
        {
            return aid::MOON;
        }
        else if (astronomical_type_abbreviation == "MT")
        {
            return aid::METEOR;
        }
        else
        {
            return aid::NONE;
        }
    }

create_base_dimensions() [1/3]

vector< dimension > scifir::create_base_dimensions

(

const string &

init_dimensions

)

Creates the base dimensions from an initialization string of dimensions.

Definition at line 2033 of file dimension.cpp.

    {
        vector<dimension> new_dimensions = create_dimensions(init_dimensions);
        return create_base_dimensions(new_dimensions);
    }

create_base_dimensions() [2/3]

vector< dimension > scifir::create_base_dimensions

(

const vector< dimension > &

x

)

Creates all the base dimensions from a vector of dimensions.

Definition at line 2039 of file dimension.cpp.

    {
        vector<dimension> new_x = vector<dimension>();
        for(unsigned int i = 0; i < x.size(); i++)
        {
            vector<dimension> x_subdimensions = x[i].get_base_dimensions();
            for (dimension& x_subdimension : x_subdimensions)
            {
                if (x[i].dimension_position == dimension::DENOMINATOR)
                {
                    x_subdimension.invert();
                }
                new_x.push_back(x_subdimension);
            }
        }
        return new_x;
    }

create_base_dimensions() [3/3]

vector< dimension > scifir::create_base_dimensions	(	const vector< dimension > &	x,
		long double &	value
	)

Creates all the base dimensions from a vector of dimensions, updating also the associated value related to those dimensions based on the prefix math and the conversion factor of the dimension, if that conversion factor is different than one.

Definition at line 2057 of file dimension.cpp.

    {
        vector<dimension> new_x = vector<dimension>();
        for(unsigned int i = 0; i < x.size(); i++)
        {
            if (x[i].dimension_position == dimension::NUMERATOR)
            {
                value *= x[i].get_conversion_factor();
                value *= x[i].prefix_math();
            }
            else if (x[i].dimension_position == dimension::DENOMINATOR)
            {
                value /= x[i].get_conversion_factor();
                value /= x[i].prefix_math();
            }
            vector<dimension> x_subdimensions = x[i].get_base_dimensions();
            for (dimension& x_subdimension : x_subdimensions)
            {
                if (x[i].dimension_position == dimension::DENOMINATOR)
                {
                    x_subdimension.invert();
                }
                new_x.push_back(x_subdimension);
            }
        }
        if (x.size() == 1 and x[0].dimension_type == dimension::CELSIUS and x[0].dimension_position == dimension::NUMERATOR)
        {
            value += 273.15l;
        }
        return new_x;
    }

create_cardinale_point()

cardinale_point scifir::create_cardinale_point

(

const string &

x

)

Definition at line 28 of file coordinates_3d.cpp.

    {
        if (x == "NORTH")
        {
            return cardinale_point::NORTH;
        }
        else if (x == "SOUTH")
        {
            return cardinale_point::SOUTH;
        }
        else if (x == "EAST")
        {
            return cardinale_point::EAST;
        }
        else if (x == "WEST")
        {
            return cardinale_point::WEST;
        }
        return cardinale_point::NORTH;
    }

create_dimensions()

vector< dimension > scifir::create_dimensions

(

string

init_dimensions

)

Creates the dimensions from an initialization string of dimensions.

Definition at line 1921 of file dimension.cpp.

    {
        boost::algorithm::erase_all(init_dimensions, " ");
        dimension::position new_sign = dimension::NUMERATOR;
        int new_scale = 1;
        int new_size = 1;
        int new_start = 0;
        icu::UnicodeString new_dimension_str;
        vector<dimension> dimensions = vector<dimension>();
        icu::UnicodeString x_unicode = icu::UnicodeString(init_dimensions.c_str());
        int total_chars = x_unicode.countChar32();
        for(unsigned int j = 0; j < total_chars; j++)
        {
            if(x_unicode[j] == UChar32(U'1') and x_unicode[j + 1] == UChar32(U'/'))
            {
                new_sign = dimension::DENOMINATOR;
            }
            if(is_dimension_char(x_unicode[j]) and (!is_dimension_char(x_unicode[j + 1]) or (j + 1) == total_chars))
            {
                new_dimension_str = x_unicode.tempSubString(new_start,new_size);
                if(u_isdigit(x_unicode[j + 1]))
                {
                    new_scale = u_charDigitValue(x_unicode[j + 1]);
                }
            }
            if(x_unicode[j] == UChar32(U'*'))
            {
                new_size = 0;
                new_start = j + 1;
            }
            else if(x_unicode[j] == UChar32(U'/'))
            {
                new_sign = dimension::DENOMINATOR;
                new_size = 0;
                new_start = j + 1;
            }
            if(!new_dimension_str.countChar32() == 0)
            {
                dimension new_dimension;
                string new_dimension_str_stl2 = "";
                new_dimension_str.toUTF8String(new_dimension_str_stl2);
                if(new_dimension_str.countChar32() == 1)
                {
                    if(new_dimension_str[0] == 0x03A9)
                    {
                        new_dimension = dimension(dimension::OHM,prefix::NONE,new_sign);
                    }
                    else if(new_dimension_str[0] == 0x00C5)
                    {
                        new_dimension = dimension(dimension::ANGSTROM,prefix::NONE,new_sign);
                    }
                    else if(new_dimension_str[0] == 0x03B8)
                    {
                        new_dimension = dimension(dimension::DEGREE,prefix::NONE,new_sign);
                    }
                    else
                    {
                        string new_dimension_str_stl = "";
                        new_dimension_str.toUTF8String(new_dimension_str_stl);
                        new_dimension = dimension(new_dimension_str_stl,new_sign);
                    }
                }
                else
                {
                    if(new_dimension_str[new_dimension_str.countChar32() - 1] == 0x03A9)
                    {
                        string new_prefix_str = "";
                        new_dimension_str.tempSubString(0,new_dimension_str.countChar32() - 1).toUTF8String(new_prefix_str);
                        prefix new_prefix(new_prefix_str);
                        new_dimension = dimension(dimension::OHM,new_prefix,new_sign);
                    }
                    else if(new_dimension_str[new_dimension_str.countChar32() - 1] == 0x00C5)
                    {
                        string new_prefix_str = "";
                        new_dimension_str.tempSubString(0,new_dimension_str.countChar32() - 1).toUTF8String(new_prefix_str);
                        prefix new_prefix(new_prefix_str);
                        new_dimension = dimension(dimension::ANGSTROM,new_prefix,new_sign);
                    }
                    else if(new_dimension_str[new_dimension_str.countChar32() - 1] == 0x03B8)
                    {
                        string new_prefix_str = "";
                        new_dimension_str.tempSubString(0,new_dimension_str.countChar32() - 1).toUTF8String(new_prefix_str);
                        prefix new_prefix(new_prefix_str);
                        new_dimension = dimension(dimension::DEGREE,new_prefix,new_sign);
                    }
                    else if(new_dimension_str[new_dimension_str.countChar32() - 2] == 0x00B0 && new_dimension_str[new_dimension_str.countChar32() - 1] == 0x0043)
                    {
                        string new_prefix_str = "";
                        new_dimension_str.tempSubString(0,new_dimension_str.countChar32() - 2).toUTF8String(new_prefix_str);
                        prefix new_prefix(new_prefix_str);
                        new_dimension = dimension(dimension::CELSIUS,new_prefix,new_sign);
                    }
                    else
                    {
                        string new_dimension_str_stl = "";
                        new_dimension_str.toUTF8String(new_dimension_str_stl);
                        new_dimension = dimension(new_dimension_str_stl,new_sign);
                    }
                }
                for (int k = 0; k < new_scale; k++)
                {
                    dimensions.push_back(new_dimension);
                }
                new_dimension_str.remove();
                new_scale = 1;
                new_size = 0;
            }
            new_size++;
        }
        return dimensions;
    }

create_direction()

direction::name scifir::create_direction

(

const string &

x

)

Definition at line 55 of file direction.cpp.

    {
        if (x == "left")
        {
            return direction::LEFT;
        }
        else if (x == "right")
        {
            return direction::RIGHT;
        }
        else if (x == "top")
        {
            return direction::TOP;
        }
        else if (x == "bottom")
        {
            return direction::BOTTOM;
        }
        else if (x == "front")
        {
            return direction::FRONT;
        }
        else if (x == "back")
        {
            return direction::BACK;
        }
        else if (x == "left-top")
        {
            return direction::LEFT_TOP;
        }
        else if (x == "left-bottom")
        {
            return direction::LEFT_BOTTOM;
        }
        else if (x == "right-top")
        {
            return direction::RIGHT_TOP;
        }
        else if (x == "right-bottom")
        {
            return direction::RIGHT_BOTTOM;
        }
        else if (x == "left-front")
        {
            return direction::LEFT_FRONT;
        }
        else if (x == "left-back")
        {
            return direction::LEFT_BACK;
        }
        else if (x == "right-front")
        {
            return direction::RIGHT_FRONT;
        }
        else if (x == "right-back")
        {
            return direction::RIGHT_BACK;
        }
        else if (x == "top-front")
        {
            return direction::TOP_FRONT;
        }
        else if (x == "top-back")
        {
            return direction::TOP_BACK;
        }
        else if (x == "bottom-front")
        {
            return direction::BOTTOM_FRONT;
        }
        else if (x == "bottom-back")
        {
            return direction::BOTTOM_BACK;
        }
        else if (x == "left-top-front")
        {
            return direction::LEFT_TOP_FRONT;
        }
        else if (x == "left-top-back")
        {
            return direction::LEFT_TOP_BACK;
        }
        else if (x == "left-bottom-front")
        {
            return direction::LEFT_BOTTOM_FRONT;
        }
        else if (x == "left-bottom-back")
        {
            return direction::LEFT_BOTTOM_BACK;
        }
        else if (x == "right-top-front")
        {
            return direction::RIGHT_TOP_FRONT;
        }
        else if (x == "right-top-back")
        {
            return direction::RIGHT_TOP_BACK;
        }
        else if (x == "right-bottom-front")
        {
            return direction::RIGHT_BOTTOM_FRONT;
        }
        else if (x == "right-bottom-back")
        {
            return direction::RIGHT_BOTTOM_BACK;
        }
        else
        {
            return direction::NONE;
        }
    }

create_prefix_by_factor()

prefix scifir::create_prefix_by_factor

(

int

factor

)

Creates the prefix of the factor given, which is always between a range.

Definition at line 330 of file prefix.cpp.

    {
        if (factor == 0)
        {
            return prefix(prefix::NONE);
        }
        else if (factor == 1)
        {
            return prefix(prefix::DECA);
        }
        else if (factor == 2)
        {
            return prefix(prefix::HECTO);
        }
        else if (factor == -1)
        {
            return prefix(prefix::DECI);
        }
        else if (factor == -2)
        {
            return prefix(prefix::CENTI);
        }
        else if (factor >= 3 and factor < 6)
        {
            return prefix(prefix::KILO);
        }
        else if (factor >= 6 and factor < 9)
        {
            return prefix(prefix::MEGA);
        }
        else if (factor >= 9 and factor < 12)
        {
            return prefix(prefix::GIGA);
        }
        else if (factor >= 12 and factor < 15)
        {
            return prefix(prefix::TERA);
        }
        else if (factor >= 15 and factor < 18)
        {
            return prefix(prefix::PETA);
        }
        else if (factor >= 18 and factor < 21)
        {
            return prefix(prefix::EXA);
        }
        else if (factor >= 21 and factor < 24)
        {
            return prefix(prefix::ZETTA);
        }
        else if (factor >= 24 and factor < 27)
        {
            return prefix(prefix::YOTTA);
        }
        else if (factor >= 27 and factor < 30)
        {
            return prefix(prefix::RONNA);
        }
        else if (factor >= 30)
        {
            return prefix(prefix::QUETTA);
        }
        else if (factor <= -3 and factor > -6)
        {
            return prefix(prefix::MILLI);
        }
        else if (factor <= -6 and factor > -9)
        {
            return prefix(prefix::MICRO);
        }
        else if (factor <= -9 and factor > -12)
        {
            return prefix(prefix::NANO);
        }
        else if (factor <= -12 and factor > -15)
        {
            return prefix(prefix::PICO);
        }
        else if (factor <= -15 and factor > -18)
        {
            return prefix(prefix::FEMTO);
        }
        else if (factor <= -18 and factor > -21)
        {
            return prefix(prefix::ATTO);
        }
        else if (factor <= -21 and factor > -24)
        {
            return prefix(prefix::ZEPTO);
        }
        else if (factor <= -24 and factor > -27)
        {
            return prefix(prefix::YOCTO);
        }
        else if (factor <= -27 and factor > -30)
        {
            return prefix(prefix::RONTO);
        }
        else if (factor <= -30)
        {
            return prefix(prefix::QUECTO);
        }
        return prefix();
    }

create_zone_type()

zid::type scifir::create_zone_type

(

const string &

zone_type_abbreviation

)

Creates an instance of a zid::type with the given string, which is the reverse as the to_string() function of zid::type.

Definition at line 311 of file zid.cpp.

    {
        if (zone_type_abbreviation == "C")
        {
            return zid::COUNTRY;
        }
        else if (zone_type_abbreviation == "R")
        {
            return zid::REGION;
        }
        else if (zone_type_abbreviation == "S")
        {
            return zid::SETTLEMENT;
        }
        else if (zone_type_abbreviation == "Z")
        {
            return zid::ZONE;
        }
        else
        {
            return zid::NONE;
        }
    }

cross_product() [1/2]

vector_unit_3d scifir::cross_product	(	const vector_unit_3d &	x,
		const vector_unit_3d &	y
	)

Creates a vector_unit_3d as the cross product of the two vectors x and y.

Definition at line 474 of file vector_unit_3d.cpp.

    {
        long double new_value;
        angle new_theta;
        angle new_phi;
        if(y.theta == x.theta and y.phi == x.phi)
        {
            new_value = 0.0l;
        }
        else
        {
            float new_x = float(x.y_projection() * y.z_projection() - x.z_projection() * y.y_projection());
            float new_y = float(x.z_projection() * y.x_projection() - x.x_projection() * y.z_projection());
            float new_z = float(x.x_projection() * y.y_projection() - x.y_projection() * y.x_projection());
            new_value = cartesian_3d_to_spherical_r(new_x, new_y, new_z);
            new_theta = cartesian_3d_to_spherical_theta(new_x, new_y, new_z);
            new_phi = cartesian_3d_to_spherical_phi(new_x, new_y, new_z);
        }
        vector<dimension> new_dimensions = multiply_dimensions(x.get_dimensions(), y.get_dimensions(),new_value);
        return vector_unit_3d(float(new_value), new_dimensions, new_theta, new_phi);
    }

cross_product() [2/2]

vector_unit_nd scifir::cross_product	(	const vector_unit_nd &	x,
		const vector_unit_nd &	y
	)

Creates a vector_unit_nd as the cross product of the two vectors x and y. If both vectors aren't in 3D, it returns an empty vector_unit_nd, because the cross product doesn't exists outside 3D.

Definition at line 810 of file vector_unit_nd.cpp.

    {
        if(x.is_nd(3) and y.is_nd(3))
        {
            long double new_value;
            angle new_theta;
            angle new_phi;
            if(y.angles[0] == x.angles[0] and y.angles[1] == x.angles[1])
            {
                new_value = 0.0l;
            }
            else
            {
                float new_x = float(x.y_projection() * y.z_projection() - x.z_projection() * y.y_projection());
                float new_y = float(x.z_projection() * y.x_projection() - x.x_projection() * y.z_projection());
                float new_z = float(x.x_projection() * y.y_projection() - x.y_projection() * y.x_projection());
                new_value = cartesian_3d_to_spherical_r(new_x, new_y, new_z);
                new_theta = cartesian_3d_to_spherical_theta(new_x, new_y, new_z);
                new_phi = cartesian_3d_to_spherical_phi(new_x, new_y, new_z);
            }
            vector<dimension> new_dimensions = multiply_dimensions(x.get_dimensions(), y.get_dimensions(),new_value);
            scalar_unit new_unit = scalar_unit(float(new_value), new_dimensions);
            vector<angle> angles;
            angles.push_back(new_theta);
            angles.push_back(new_phi);
            return vector_unit_nd(new_unit, angles);
        }
        else
        {
            return vector_unit_nd();
        }
    }

cylindrical_to_cartesian_3d_x() [1/2]

scalar_unit scifir::cylindrical_to_cartesian_3d_x ( const scalar_unit &  p, const angle &  theta, const scalar_unit &  z  )

inline

Returns the x coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.

Definition at line 793 of file coordinates_3d.hpp.

    {
        return p * scifir::cos(theta);
    }

cylindrical_to_cartesian_3d_x() [2/2]

float scifir::cylindrical_to_cartesian_3d_x ( float  p, const angle &  theta, float  z  )

inline

Returns the x coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.

Definition at line 885 of file coordinates_3d.hpp.

    {
        return p * scifir::cos(theta);
    }

cylindrical_to_cartesian_3d_y() [1/2]

scalar_unit scifir::cylindrical_to_cartesian_3d_y ( const scalar_unit &  p, const angle &  theta, const scalar_unit &  z  )

inline

Returns the y coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.

Definition at line 798 of file coordinates_3d.hpp.

    {
        return p * scifir::sin(theta);
    }

cylindrical_to_cartesian_3d_y() [2/2]

float scifir::cylindrical_to_cartesian_3d_y ( float  p, const angle &  theta, float  z  )

inline

Returns the y coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.

Definition at line 890 of file coordinates_3d.hpp.

    {
        return p * scifir::sin(theta);
    }

cylindrical_to_cartesian_3d_z() [1/2]

scalar_unit scifir::cylindrical_to_cartesian_3d_z ( const scalar_unit &  p, const angle &  theta, const scalar_unit &  z  )

inline

Returns the z coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.

Definition at line 803 of file coordinates_3d.hpp.

    {
        return z;
    }

cylindrical_to_cartesian_3d_z() [2/2]

float scifir::cylindrical_to_cartesian_3d_z ( float  p, const angle &  theta, float  z  )

inline

Returns the z coordinate of the cartesian coordinates in 3D given the p, theta and z of cylindrical coordinates.

Definition at line 895 of file coordinates_3d.hpp.

    {
        return z;
    }

cylindrical_to_spherical_phi() [1/2]

angle scifir::cylindrical_to_spherical_phi ( const scalar_unit &  p, const angle &  theta, scalar_unit  z  )

inline

Returns the phi coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.

Definition at line 819 of file coordinates_3d.hpp.

    {
        z.change_dimensions(p);
        return angle(scifir::atan_degree(float(p) / float(z)));
    }

cylindrical_to_spherical_phi() [2/2]

angle scifir::cylindrical_to_spherical_phi ( float  p, const angle &  theta, float  z  )

inline

Returns the phi coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.

Definition at line 910 of file coordinates_3d.hpp.

    {
        return angle(scifir::atan_degree(p / z));
    }

cylindrical_to_spherical_r() [1/2]

scalar_unit scifir::cylindrical_to_spherical_r ( const scalar_unit &  p, const angle &  theta, scalar_unit  z  )

inline

Returns the r coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.

Definition at line 808 of file coordinates_3d.hpp.

    {
        z.change_dimensions(p);
        return scalar_unit(std::sqrt(std::pow(float(p),2) + std::pow(float(z),2)),p.get_dimensions());
    }

cylindrical_to_spherical_r() [2/2]

float scifir::cylindrical_to_spherical_r ( float  p, const angle &  theta, float  z  )

inline

Returns the r coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.

Definition at line 900 of file coordinates_3d.hpp.

    {
        return float(std::sqrt(std::pow(p,2) + std::pow(z,2)));
    }

cylindrical_to_spherical_theta() [1/2]

angle scifir::cylindrical_to_spherical_theta ( const scalar_unit &  p, const angle &  theta, const scalar_unit &  z  )

inline

Returns the theta coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.

Definition at line 814 of file coordinates_3d.hpp.

    {
        return theta;
    }

cylindrical_to_spherical_theta() [2/2]

angle scifir::cylindrical_to_spherical_theta ( float  p, const angle &  theta, float  z  )

inline

Returns the theta coordinate of the spherical coordinates given the p, theta and z of cylindrical coordinates.

Definition at line 905 of file coordinates_3d.hpp.

    {
        return theta;
    }

degree_to_gradian()

float scifir::degree_to_gradian ( float  x )

inline

Definition at line 46 of file angle.hpp.

    {
        return x / 0.9f;
    }

degree_to_radian()

float scifir::degree_to_radian ( float  x )

inline

Converts a degree to a radian.

Definition at line 31 of file angle.hpp.

    {
        return x * std::numbers::pi_v<float> / 180.0f;
    }

degree_to_turn()

float scifir::degree_to_turn ( float  x )

inline

Definition at line 61 of file angle.hpp.

    {
        return x / 360.0f;
    }

display_double()

string scifir::display_double	(	const double &	value,
		int	number_of_decimals
	)

Definition at line 57 of file types.cpp.

    {
        ostringstream output;
        if (number_of_decimals > 0)
        {
            output << (value*std::pow(10,number_of_decimals) / std::pow(10,number_of_decimals));
        }
        else
        {
            output << value;
        }
        if (output.str() == "-0")
        {
            return "0";
        }
        else
        {
            return output.str();
        }
    }

display_float()

string scifir::display_float	(	const float &	value,
		int	number_of_decimals
	)

Definition at line 36 of file types.cpp.

    {
        ostringstream output;
        if (number_of_decimals > 0)
        {
            output << (std::trunc(value*std::pow(10,number_of_decimals)) / std::pow(10,number_of_decimals));
        }
        else
        {
            output << value;
        }
        if (output.str() == "-0")
        {
            return "0";
        }
        else
        {
            return output.str();
        }
    }

display_long_double()

string scifir::display_long_double	(	const long double &	value,
		int	number_of_decimals
	)

Definition at line 78 of file types.cpp.

    {
        ostringstream output;
        if (number_of_decimals > 0)
        {
            output << (std::trunc(value*std::pow(10.0l,number_of_decimals)) / std::pow(10.0l,number_of_decimals));
        }
        else
        {
            output << value;
        }
        if (output.str() == "-0")
        {
            return "0";
        }
        else
        {
            return output.str();
        }
    }

distance() [1/26]

float scifir::distance	(	const coordinates_1d< float > &	x,
		const coordinates_1d< float > &	y
	)

Definition at line 13 of file coordinates_1d.cpp.

    {
        return float(std::sqrt(std::pow(x.x - y.x,2)));
    }

distance() [2/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_1d< T > &	x,
		const coordinates_1d< U > &	y
	)

Definition at line 191 of file coordinates_1d.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.x - y.x,2)));
    }

distance() [3/26]

float scifir::distance	(	const coordinates_2d< float > &	x,
		const coordinates_2d< float > &	y
	)

Definition at line 14 of file coordinates_2d.cpp.

    {
        return float(std::sqrt(std::pow(x.x - y.x,2) + std::pow(x.y - y.y,2)));
    }

distance() [4/26]

float scifir::distance	(	const coordinates_2d< float > &	x,
		const coordinates_2dr< float > &	y
	)

Definition at line 22 of file coordinates_2dr.cpp.

    {
        return float(std::sqrt(std::pow(x.x - y.x,2) + std::pow(x.y - y.y,2)));
    }

distance() [5/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_2d< T > &	x,
		const coordinates_2d< U > &	y
	)

Definition at line 347 of file coordinates_2d.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.x - y.x,2) + scifir::pow(x.y - y.y,2)));
    }

distance() [6/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_2d< T > &	x,
		const coordinates_2dr< U > &	y
	)

Definition at line 480 of file coordinates_2dr.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.x - y.x,2) + scifir::pow(x.y - y.y,2)));
    }

distance() [7/26]

float scifir::distance	(	const coordinates_2dr< float > &	x,
		const coordinates_2d< float > &	y
	)

Definition at line 17 of file coordinates_2dr.cpp.

    {
        return float(std::sqrt(std::pow(x.x - y.x,2) + std::pow(x.y - y.y,2)));
    }

distance() [8/26]

float scifir::distance	(	const coordinates_2dr< float > &	x,
		const coordinates_2dr< float > &	y
	)

Definition at line 12 of file coordinates_2dr.cpp.

    {
        return float(std::sqrt(std::pow(x.x - y.x,2) + std::pow(x.y - y.y,2)));
    }

distance() [9/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_2dr< T > &	x,
		const coordinates_2d< U > &	y
	)

Definition at line 472 of file coordinates_2dr.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.x - y.x,2) + scifir::pow(x.y - y.y,2)));
    }

distance() [10/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_2dr< T > &	x,
		const coordinates_2dr< U > &	y
	)

Definition at line 464 of file coordinates_2dr.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.x - y.x,2) + scifir::pow(x.y - y.y,2)));
    }

distance() [11/26]

float scifir::distance	(	const coordinates_3d< float > &	x,
		const coordinates_3d< float > &	y
	)

Calculates the distance between two coordinates_3d<float>.

Definition at line 49 of file coordinates_3d.cpp.

    {
        return float(std::sqrt(std::pow(x.x - y.x,2) + std::pow(x.y - y.y,2) + std::pow(x.z - y.z,2)));
    }

distance() [12/26]

float scifir::distance	(	const coordinates_3d< float > &	x,
		const coordinates_3dr< float > &	y
	)

Definition at line 22 of file coordinates_3dr.cpp.

    {
        return float(std::sqrt(std::pow(x.x - y.x,2) + std::pow(x.y - y.y,2) + std::pow(x.z - y.z,2)));
    }

distance() [13/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_3d< T > &	x,
		const coordinates_3d< U > &	y
	)

Calculates the distance between two coordinates_3d.

Definition at line 719 of file coordinates_3d.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.x - y.x,2) + scifir::pow(x.y - y.y,2) + scifir::pow(x.z - y.z,2)));
    }

distance() [14/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_3d< T > &	x,
		const coordinates_3dr< U > &	y
	)

Definition at line 924 of file coordinates_3dr.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.x - y.x,2) + scifir::pow(x.y - y.y,2) + scifir::pow(x.z - y.z,2)));
    }

distance() [15/26]

float scifir::distance	(	const coordinates_3dr< float > &	x,
		const coordinates_3d< float > &	y
	)

Definition at line 17 of file coordinates_3dr.cpp.

    {
        return float(std::sqrt(std::pow(x.x - y.x,2) + std::pow(x.y - y.y,2) + std::pow(x.z - y.z,2)));
    }

distance() [16/26]

float scifir::distance	(	const coordinates_3dr< float > &	x,
		const coordinates_3dr< float > &	y
	)

Definition at line 12 of file coordinates_3dr.cpp.

    {
        return float(std::sqrt(std::pow(x.x - y.x,2) + std::pow(x.y - y.y,2) + std::pow(x.z - y.z,2)));
    }

distance() [17/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_3dr< T > &	x,
		const coordinates_3d< U > &	y
	)

Definition at line 916 of file coordinates_3dr.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.x - y.x,2) + scifir::pow(x.y - y.y,2) + scifir::pow(x.z - y.z,2)));
    }

distance() [18/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_3dr< T > &	x,
		const coordinates_3dr< U > &	y
	)

Definition at line 908 of file coordinates_3dr.hpp.

    {
        return T(scifir::sqrt(scifir::pow(x.x - y.x,2) + scifir::pow(x.y - y.y,2) + scifir::pow(x.z - y.z,2)));
    }

distance() [19/26]

float scifir::distance	(	const coordinates_nd< float > &	x,
		const coordinates_nd< float > &	y
	)

Definition at line 30 of file coordinates_nd.cpp.

    {
        if (x.get_nd() == y.get_nd())
        {
            float x_length = 0;
            for (unsigned int i = 0; i < x.values.size(); i++)
            {
                x_length += float(std::pow(x.values[i] - y.values[i],2));
            }
            return std::sqrt(x_length);
        }
        else
        {
            return 0.0f;
        }
    }

distance() [20/26]

float scifir::distance	(	const coordinates_nd< float > &	x,
		const coordinates_ndr< float > &	y
	)

Definition at line 82 of file coordinates_ndr.cpp.

    {
        if (x.get_nd() == y.get_nd())
        {
            float x_length = 0;
            for (unsigned int i = 0; i < x.values.size(); i++)
            {
                x_length += float(std::pow(x.values[i] - y.get_value(i),2));
            }
            return std::sqrt(x_length);
        }
        else
        {
            return 0.0f;
        }
    }

distance() [21/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_nd< T > &	x,
		const coordinates_nd< U > &	y
	)

Definition at line 1160 of file coordinates_nd.hpp.

    {
        if (x.get_nd() == y.get_nd())
        {
            scalar_unit x_length = scalar_unit(0.0f,"m2");
            for (int i = 0; i < x.values.size(); i++)
            {
                x_length += scifir::pow(x.values[i] - y.values[i],2);
            }
            return T(scifir::sqrt(x_length));
        }
        else
        {
            return T();
        }
    }

distance() [22/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_nd< T > &	x,
		const coordinates_ndr< U > &	y
	)

Definition at line 2231 of file coordinates_ndr.hpp.

    {
        if (x.get_nd() == y.get_nd())
        {
            scalar_unit x_length = scalar_unit(0.0f,"m2");
            for (int i = 0; i < x.values.size(); i++)
            {
                x_length += scifir::pow(x.values[i] - y.get_value(i),2);
            }
            return T(scifir::sqrt(x_length));
        }
        else
        {
            return T();
        }
    }

distance() [23/26]

float scifir::distance	(	const coordinates_ndr< float > &	x,
		const coordinates_nd< float > &	y
	)

Definition at line 65 of file coordinates_ndr.cpp.

    {
        if (x.get_nd() == y.get_nd())
        {
            float x_length = 0;
            for (unsigned int i = 0; i < x.get_values().size(); i++)
            {
                x_length += float(std::pow(x.get_value(i) - y.values[i],2));
            }
            return std::sqrt(x_length);
        }
        else
        {
            return 0.0f;
        }
    }

distance() [24/26]

float scifir::distance	(	const coordinates_ndr< float > &	x,
		const coordinates_ndr< float > &	y
	)

Definition at line 48 of file coordinates_ndr.cpp.

    {
        if (x.get_nd() == y.get_nd())
        {
            float x_length = 0;
            for (unsigned int i = 0; i < x.get_values().size(); i++)
            {
                x_length += float(std::pow(x.get_value(i) - y.get_value(i),2));
            }
            return std::sqrt(x_length);
        }
        else
        {
            return 0.0f;
        }
    }

distance() [25/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_ndr< T > &	x,
		const coordinates_nd< U > &	y
	)

Definition at line 2211 of file coordinates_ndr.hpp.

    {
        if (x.get_nd() == y.get_nd())
        {
            scalar_unit x_length = scalar_unit(0.0f,"m2");
            for (int i = 0; i < x.get_values().size(); i++)
            {
                x_length += scifir::pow(x.get_value(i) - y.values[i],2);
            }
            return T(scifir::sqrt(x_length));
        }
        else
        {
            return T();
        }
    }

distance() [26/26]

template<typename T , typename U >

T scifir::distance	(	const coordinates_ndr< T > &	x,
		const coordinates_ndr< U > &	y
	)

Definition at line 2191 of file coordinates_ndr.hpp.

    {
        if (x.get_nd() == y.get_nd())
        {
            scalar_unit x_length = scalar_unit(0.0f,"m2");
            for (int i = 0; i < x.get_values().size(); i++)
            {
                x_length += scifir::pow(x.get_value(i) - y.get_value(i),2);
            }
            return T(scifir::sqrt(x_length));
        }
        else
        {
            return T();
        }
    }

divide_dimensions()

vector< dimension > scifir::divide_dimensions	(	vector< dimension >	x,
		const vector< dimension > &	y,
		long double &	value
	)

Divides the first vector of dimensions with the other. The result is normalized after, which means that equal dimensions at the numerator and at the denominator are cancelled. It also updates the value associated with those two vectors of dimensions with the prefix m ath and the conversion factor of those dimensions.

Definition at line 2108 of file dimension.cpp.

    {
        for(dimension y_dimension : y)
        {
            y_dimension.invert();
            x.push_back(y_dimension);
        }
        return normalize_dimensions(x,value);
    }

dot_product() [1/3]

scalar_unit scifir::dot_product	(	const vector_unit_2d &	x,
		const vector_unit_2d &	y
	)

Creates a scalar_unit as the dot product of the two vectors x and y.

Definition at line 362 of file vector_unit_2d.cpp.

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

dot_product() [2/3]

scalar_unit scifir::dot_product	(	const vector_unit_3d &	x,
		const vector_unit_3d &	y
	)

Creates a scalar_unit as the dot product of the two vectors x and y.

Definition at line 467 of file vector_unit_3d.cpp.

    {
        long double new_value = float(x.x_projection()*y.x_projection() + x.y_projection()*y.y_projection() + x.z_projection()*y.z_projection());
        vector<dimension> new_dimensions = multiply_dimensions(x.get_dimensions(), y.get_dimensions(),new_value);
        return scalar_unit(float(new_value),new_dimensions);
    }

dot_product() [3/3]

scalar_unit scifir::dot_product	(	const vector_unit_nd &	x,
		const vector_unit_nd &	y
	)

Creates a scalar_unit as the dot product of the two vectors x and y.

Definition at line 803 of file vector_unit_nd.cpp.

    {
        long double new_value = float(x.x_projection()*y.x_projection() + x.y_projection()*y.y_projection() + x.z_projection()*y.z_projection());
        vector<dimension> new_dimensions = multiply_dimensions(x.get_dimensions(), y.get_dimensions(),new_value);
        return scalar_unit(float(new_value),new_dimensions);
    }

ECEF_to_LLA_altitude() [1/2]

scalar_unit scifir::ECEF_to_LLA_altitude ( const scalar_unit &  x, scalar_unit  y, const scalar_unit &  z  )

inline

Definition at line 45 of file coordinates_3d.hpp.

    {
        scalar_unit e_square = (scifir::pow(WGS84_EARTH_SEMIAXIS_A,2) - scifir::pow(WGS84_EARTH_SEMIAXIS_B,2))/scifir::pow(WGS84_EARTH_SEMIAXIS_A,2);
        scalar_unit e_prim_square = (scifir::pow(WGS84_EARTH_SEMIAXIS_A,2) - scifir::pow(WGS84_EARTH_SEMIAXIS_B,2))/scifir::pow(WGS84_EARTH_SEMIAXIS_B,2);
        scalar_unit p = scifir::sqrt(scifir::pow(x,2) + scifir::pow(y,2));
        scalar_unit F = 54.0f * scifir::pow(WGS84_EARTH_SEMIAXIS_B,2) * scifir::pow(z,2);
        long double G = std::pow(p.get_value(),2) + (1.0f - e_square.get_value()) * std::pow(z.get_value(),2) - e_square.get_value() * (std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2));
        long double c = (scifir::pow(e_square,2) * F * scifir::pow(p,2)).get_value() / std::pow(G,3);
        long double s = std::cbrt(1.0f + c + std::sqrt(std::pow(c,2) + 2.0f * c));
        long double k = s + 1.0f + (1.0f/s);
        scalar_unit P = F/(3.0f * std::pow(k,2) * scalar_unit(std::pow(G,2),{ dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR),dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR),dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR),dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR) }));
        scalar_unit Q = scifir::sqrt(1.0f + 2.0f * scifir::pow(e_square,2) * P);
        scalar_unit r0 = -1.0f * ((P * e_square * p)/(1.0f + Q)) + scifir::sqrt((1.0f/2.0f) * scifir::pow(WGS84_EARTH_SEMIAXIS_A,2) * (1.0f + (1.0f / Q)) - (P * (1.0f - e_square) * scifir::pow(z,2))/(Q * (1.0f + Q)) - (1.0f/2.0f) * P * scifir::pow(p,2));
        scalar_unit U = scifir::sqrt(scifir::pow(p - e_square * r0,2) + scifir::pow(z,2));
        scalar_unit V = scifir::sqrt(scifir::pow(p - e_square * r0,2) + (1.0f - e_square) * scifir::pow(z,2));
        return scalar_unit(U.get_value() * (1.0f - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2) / (WGS84_EARTH_SEMIAXIS_A.get_value() * V.get_value())),{ dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR) });
    }

ECEF_to_LLA_altitude() [2/2]

float scifir::ECEF_to_LLA_altitude ( float  x, float  y, float  z  )

inline

Definition at line 110 of file coordinates_3d.hpp.

    {
        long double e_square = (std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2))/std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2);
        long double e_prim_square = (std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2))/std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2);
        long double p = std::sqrt(std::pow(x,2) + std::pow(y,2));
        long double F = 54.0f * std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2) * std::pow(z,2);
        long double G = std::pow(p,2) + (1.0f - e_square) * std::pow(z,2) - e_square * (std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2));
        long double c = std::pow(e_square,2) * F * std::pow(p,2) / std::pow(G,3);
        long double s = std::cbrt(1.0f + c + std::sqrt(std::pow(c,2) + 2.0f * c));
        long double k = s + 1.0f + (1.0f/s);
        long double P = F/(3.0f * std::pow(k,2) * std::pow(G,2));
        long double Q = std::sqrt(1.0f + 2.0f * std::pow(e_square,2) * P);
        long double r0 = -1.0f * ((P * e_square * p)/(1.0f + Q)) + std::sqrt((1.0f/2.0f) * std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) * (1.0f + (1.0f / Q)) - (P * (1.0f - e_square) * std::pow(z,2))/(Q * (1.0f + Q)) - (1.0f/2.0f) * P * std::pow(p,2));
        long double U = std::sqrt(std::pow(p - e_square * r0,2) + std::pow(z,2));
        long double V = std::sqrt(std::pow(p - e_square * r0,2) + (1.0f - e_square) * std::pow(z,2));
        return U * (1.0f - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2) / (WGS84_EARTH_SEMIAXIS_A.get_value() * V));
    }

ECEF_to_LLA_latitude() [1/2]

latitude scifir::ECEF_to_LLA_latitude ( const scalar_unit &  x, scalar_unit  y, const scalar_unit &  z  )

inline

Definition at line 22 of file coordinates_3d.hpp.

    {
        scalar_unit e_square = (scifir::pow(WGS84_EARTH_SEMIAXIS_A,2) - scifir::pow(WGS84_EARTH_SEMIAXIS_B,2))/scifir::pow(WGS84_EARTH_SEMIAXIS_A,2);
        scalar_unit e_prim_square = (scifir::pow(WGS84_EARTH_SEMIAXIS_A,2) - scifir::pow(WGS84_EARTH_SEMIAXIS_B,2))/scifir::pow(WGS84_EARTH_SEMIAXIS_B,2);
        scalar_unit p = scifir::sqrt(scifir::pow(x,2) + scifir::pow(y,2));
        scalar_unit F = 54.0f * scifir::pow(WGS84_EARTH_SEMIAXIS_B,2) * scifir::pow(z,2);
        long double G = std::pow(p.get_value(),2) + (1.0f - e_square.get_value()) * std::pow(z.get_value(),2) - e_square.get_value() * (std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2));
        long double c = (scifir::pow(e_square,2) * F * scifir::pow(p,2)).get_value() / std::pow(G,3);
        long double s = std::cbrt(1.0f + c + std::sqrt(std::pow(c,2) + 2.0f * c));
        long double k = s + 1.0f + (1.0f/s);
        scalar_unit P = F/(3.0f * std::pow(k,2) * scalar_unit(std::pow(G,2),{ dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR),dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR),dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR),dimension(dimension::METRE,prefix::NONE,dimension::NUMERATOR) }));
        scalar_unit Q = scifir::sqrt(1.0f + 2.0f * scifir::pow(e_square,2) * P);
        scalar_unit r0 = -1.0f * ((P * e_square * p)/(1.0f + Q)) + scifir::sqrt((1.0f/2.0f) * scifir::pow(WGS84_EARTH_SEMIAXIS_A,2) * (1.0f + (1.0f / Q)) - (P * (1.0f - e_square) * scifir::pow(z,2))/(Q * (1.0f + Q)) - (1.0f/2.0f) * P * scifir::pow(p,2));
        scalar_unit V = scifir::sqrt(scifir::pow(p - e_square * r0,2) + (1.0f - e_square) * scifir::pow(z,2));
        scalar_unit z0 = scifir::pow(WGS84_EARTH_SEMIAXIS_B,2)*z/(WGS84_EARTH_SEMIAXIS_A * V);
        return latitude(scifir::atan(float((z + e_prim_square * z0)/p)));
    }

ECEF_to_LLA_latitude() [2/2]

latitude scifir::ECEF_to_LLA_latitude ( float  x, float  y, float  z  )

inline

Definition at line 87 of file coordinates_3d.hpp.

    {
        long double e_square = (std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2))/std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2);
        long double e_prim_square = (std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2))/std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2);
        long double p = std::sqrt(std::pow(x,2) + std::pow(y,2));
        long double F = 54.0f * std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2) * std::pow(z,2);
        long double G = std::pow(p,2) + (1.0f - e_square) * std::pow(z,2) - e_square * (std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) - std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2));
        long double c = std::pow(e_square,2) * F * std::pow(p,2) / std::pow(G,3);
        long double s = std::cbrt(1.0f + c + std::sqrt(std::pow(c,2) + 2.0f * c));
        long double k = s + 1.0f + (1.0f/s);
        long double P = F/(3.0f * std::pow(k,2) * std::pow(G,2));
        long double Q = std::sqrt(1.0f + 2.0f * std::pow(e_square,2) * P);
        long double r0 = -1.0f * ((P * e_square * p)/(1.0f + Q)) + std::sqrt((1.0f/2.0f) * std::pow(WGS84_EARTH_SEMIAXIS_A.get_value(),2) * (1.0f + (1.0f / Q)) - (P * (1.0f - e_square) * std::pow(z,2))/(Q * (1.0f + Q)) - (1.0f/2.0f) * P * std::pow(p,2));
        long double V = std::sqrt(std::pow(p - e_square * r0,2) + (1.0f - e_square) * std::pow(z,2));
        long double z0 = std::pow(WGS84_EARTH_SEMIAXIS_B.get_value(),2)*z/(WGS84_EARTH_SEMIAXIS_A.get_value() * V);
        return latitude(scifir::atan(float((z + e_prim_square * z0)/p)));
    }

ECEF_to_LLA_longitude() [1/2]

longitude scifir::ECEF_to_LLA_longitude ( const scalar_unit &  x, scalar_unit  y, const scalar_unit &  z  )

inline

Definition at line 40 of file coordinates_3d.hpp.

    {
        return longitude(scifir::atan2(float(y),float(x)));
    }

ECEF_to_LLA_longitude() [2/2]

longitude scifir::ECEF_to_LLA_longitude ( float  x, float  y, float  z  )

inline

Definition at line 105 of file coordinates_3d.hpp.

    {
        return longitude(scifir::atan2(y,x));
    }

equal_dimensions() [1/2]

bool scifir::equal_dimensions	(	const string &	init_dimensions_x,
		const string &	init_dimensions_y
	)

Checks if two initialization strings of dimensions initialize the same basic dimensions.

Definition at line 2355 of file dimension.cpp.

    {
        vector<dimension> x_dimensions = create_dimensions(init_dimensions_x);
        vector<dimension> y_dimensions = create_dimensions(init_dimensions_y);
        return equal_dimensions(x_dimensions,y_dimensions);
    }

equal_dimensions() [2/2]

bool scifir::equal_dimensions	(	const vector< dimension > &	x,
		const vector< dimension > &	y
	)

brief Checks if the base dimensions of two vectors of dimensions are equal.

Definition at line 2362 of file dimension.cpp.

    {
        vector<dimension> x_base_dimensions = create_base_dimensions(x);
        vector<dimension> y_base_dimensions = create_base_dimensions(y);
        if (x_base_dimensions.size() == y_base_dimensions.size())
        {
            if (x_base_dimensions.size() == 0)
            {
                return true;
            }
            vector<unsigned int> skip = vector<unsigned int>();
            for (const dimension& x_dimension: x_base_dimensions)
            {
                bool is_equal = false;
                for (unsigned int j = 0; j < y_base_dimensions.size(); j++)
                {
                    bool skip_j = false;
                    if (skip.size() > 0)
                    {
                        for (unsigned int k = 0; k < skip.size(); k++)
                        {
                            if (j == skip[k])
                            {
                                skip_j = true;
                            }
                        }
                    }
                    if (skip_j)
                    {
                        continue;
                    }
                    if (x_dimension.dimension_type == y_base_dimensions[j].dimension_type and x_dimension.dimension_position == y_base_dimensions[j].dimension_position)
                    {
                        skip.push_back(j);
                        is_equal = true;
                        break;
                    }
                }
                if (!is_equal)
                {
                    return false;
                }
            }
            return true;
        }
        else
        {
            return false;
        }
    }

equal_dimensions_and_prefixes()

bool scifir::equal_dimensions_and_prefixes	(	const vector< dimension > &	x,
		const vector< dimension > &	y
	)

Checks if the base dimensions of two vectors of dimensions are equal, and if they have also the same prefixes.

Definition at line 2413 of file dimension.cpp.

    {
        vector<unsigned int> skip = vector<unsigned int>();
        if (x.size() == y.size())
        {
            for (const dimension& x_dimension: x)
            {
                bool is_equal = false;
                for (unsigned int j = 0; j < y.size(); j++)
                {
                    bool skip_j = false;
                    if (skip.size() > 0)
                    {
                        for (unsigned int k = 0; k < skip.size(); k++)
                        {
                            if (j == skip[k])
                            {
                                skip_j = true;
                            }
                        }
                    }
                    if (skip_j)
                    {
                        continue;
                    }
                    if (x_dimension == y[j])
                    {
                        skip.push_back(j);
                        is_equal = true;
                        break;
                    }
                }
                if (!is_equal)
                {
                    return false;
                }
            }
            return true;
        }
        else
        {
            return false;
        }
    }

fahrenheit_to_kelvin()

float scifir::fahrenheit_to_kelvin ( float  x )

inline

Definition at line 37 of file conversion.hpp.

    {
        return (x - 32.0f) * (5.0f / 9.0f) + 273.15f;
    }

get_number_of_particles()

int scifir::mole::get_number_of_particles

(

)

const

Definition at line 399 of file base_units.cpp.

    {
        return 1;
        /*if (scalar_unit::actual_dimensions.count(particles))
        {
            return scalar_unit::value;
        }
        else
        {
            return scalar_unit::value * scifir::AVOGADRO_CONSTANT;
        }*/
    }

gradian_to_degree()

float scifir::gradian_to_degree ( float  x )

inline

Definition at line 21 of file angle.hpp.

    {
        return x * 0.9f;
    }

gradian_to_radian()

float scifir::gradian_to_radian ( float  x )

inline

Definition at line 36 of file angle.hpp.

    {
        return x * 0.015708f;
    }

gradian_to_turn()

float scifir::gradian_to_turn ( float  x )

inline

Definition at line 71 of file angle.hpp.

    {
        return x / 400.0f;
    }

invert()

direction::name scifir::invert

(

direction::name

x

)

Definition at line 167 of file direction.cpp.

    {
        if (x == direction::LEFT)
        {
            return direction::RIGHT;
        }
        else if (x == direction::RIGHT)
        {
            return direction::LEFT;
        }
        else if (x == direction::TOP)
        {
            return direction::BOTTOM;
        }
        else if (x == direction::BOTTOM)
        {
            return direction::TOP;
        }
        else if (x == direction::FRONT)
        {
            return direction::BACK;
        }
        else if (x == direction::BACK)
        {
            return direction::FRONT;
        }
        else if (x == direction::LEFT_TOP)
        {
            return direction::RIGHT_BOTTOM;
        }
        else if (x == direction::LEFT_BOTTOM)
        {
            return direction::RIGHT_TOP;
        }
        else if (x == direction::RIGHT_TOP)
        {
            return direction::LEFT_BOTTOM;
        }
        else if (x == direction::RIGHT_BOTTOM)
        {
            return direction::LEFT_TOP;
        }
        else if (x == direction::LEFT_FRONT)
        {
            return direction::RIGHT_BACK;
        }
        else if (x == direction::LEFT_BACK)
        {
            return direction::RIGHT_FRONT;
        }
        else if (x == direction::RIGHT_FRONT)
        {
            return direction::LEFT_BACK;
        }
        else if (x == direction::RIGHT_BACK)
        {
            return direction::LEFT_FRONT;
        }
        else if (x == direction::TOP_FRONT)
        {
            return direction::BOTTOM_BACK;
        }
        else if (x == direction::TOP_BACK)
        {
            return direction::BOTTOM_FRONT;
        }
        else if (x == direction::BOTTOM_FRONT)
        {
            return direction::TOP_BACK;
        }
        else if (x == direction::BOTTOM_BACK)
        {
            return direction::TOP_FRONT;
        }
        else if (x == direction::LEFT_TOP_FRONT)
        {
            return direction::RIGHT_BOTTOM_BACK;
        }
        else if (x == direction::LEFT_TOP_BACK)
        {
            return direction::RIGHT_BOTTOM_FRONT;
        }
        else if (x == direction::LEFT_BOTTOM_FRONT)
        {
            return direction::RIGHT_TOP_BACK;
        }
        else if (x == direction::LEFT_BOTTOM_BACK)
        {
            return direction::RIGHT_TOP_FRONT;
        }
        else if (x == direction::RIGHT_TOP_FRONT)
        {
            return direction::LEFT_BOTTOM_BACK;
        }
        else if (x == direction::RIGHT_TOP_BACK)
        {
            return direction::LEFT_BOTTOM_FRONT;
        }
        else if (x == direction::RIGHT_BOTTOM_FRONT)
        {
            return direction::LEFT_TOP_BACK;
        }
        else if (x == direction::RIGHT_BOTTOM_BACK)
        {
            return direction::LEFT_TOP_FRONT;
        }
        else
        {
            return direction::NONE;
        }
    }

is_angle()

bool scifir::is_angle

(

const string &

init_angle

)

Checks if some string is an initialization string of an angle.

Definition at line 336 of file angle.cpp.

    {
        icu::UnicodeString x_unicode = icu::UnicodeString(init_angle.c_str());
        int total_chars = x_unicode.countChar32();
        bool loop = false;
        if (x_unicode[total_chars - 1] == 0x00B0 || x_unicode[total_chars - 1] == 0x00BA)
        {
            loop = true;
        }
        else if (total_chars >= 5 and init_angle.substr(init_angle.length() - 4) == " deg")
        {
            loop = true;
            total_chars -= 4;
        }
        else if (total_chars >= 5 and init_angle.substr(init_angle.length() - 4) == " rad")
        {
            loop = true;
            total_chars -= 4;
        }
        else if (total_chars>= 6 and init_angle.substr(init_angle.length() - 5) == " grad")
        {
            loop = true;
            total_chars -= 5;
        }
        else if (total_chars >= 4 and init_angle.substr(init_angle.length() - 3) == " tr")
        {
            loop = true;
            total_chars -= 3;
        }
        if (loop == false)
        {
            return false;
        }
        bool dot_present = false;
        for (int i = 0; i < (total_chars - 1); i++)
        {
            if (x_unicode[i] == '.')
            {
                if (dot_present)
                {
                    return false;
                }
                else
                {
                    dot_present = true;
                }
            }
            else if (!u_isdigit(x_unicode[i]))
            {
                return false;
            }
        }
        return true;
    }

is_complex()

bool scifir::is_complex

(

const string &

init_complex_number

)

Definition at line 7 of file complex_number.cpp.

    {
        if ((init_complex_number.find("+") != string::npos or init_complex_number.find("-") != string::npos) and init_complex_number.length() > 1)
        {
            vector<string> numbers;
            boost::split(numbers,init_complex_number,boost::is_any_of("+-"));
            if (numbers.size() != 2)
            {
                return false;
            }
            if ((int(numbers[1].length()) - 3) <= 0)
            {
                return false;
            }
            unsigned int imaginary_length = int(numbers[1].length()) - 3;
            if (numbers[1].substr(imaginary_length) == "(i)")
            {
                bool dot_present = false;
                bool after_whitespace = false;
                bool after_alpha = false;
                boost::trim(numbers[0]);
                boost::trim(numbers[1]);
                for (unsigned int i = 0; i < numbers[0].length(); i++)
                {
                    if (numbers[0][i] == '.')
                    {
                        if (dot_present)
                        {
                            return false;
                        }
                        else
                        {
                            dot_present = true;
                            continue;
                        }
                    }
                    else if (numbers[0][i] == ' ')
                    {
                        after_whitespace = true;
                        continue;
                    }
                    else if (!std::isdigit(numbers[0][i]) and after_whitespace == false)
                    {
                        return false;
                    }
                    else if (after_whitespace == true)
                    {
                        if (after_alpha == true and std::isalpha(numbers[0][i]))
                        {
                            return false;
                        }
                        else if (std::isalpha(numbers[0][i]))
                        {
                            continue;
                        }
                        else if (std::isdigit(numbers[0][i]))
                        {
                            after_alpha = true;
                        }
                    }
                }
                dot_present = false;
                after_whitespace = false;
                after_alpha = false;
                for (unsigned int i = 0; i < imaginary_length; i++)
                {
                    if (numbers[1][i] == '.')
                    {
                        if (dot_present)
                        {
                            return false;
                        }
                        else
                        {
                            dot_present = true;
                            continue;
                        }
                    }
                    else if (numbers[1][i] == ' ')
                    {
                        after_whitespace = true;
                        continue;
                    }
                    else if (!std::isdigit(numbers[1][i]) and after_whitespace == false)
                    {
                        return false;
                    }
                    else if (after_whitespace == true)
                    {
                        if (after_alpha == true and std::isalpha(numbers[1][i]))
                        {
                            return false;
                        }
                        else if (std::isalpha(numbers[1][i]))
                        {
                            continue;
                        }
                        else if (std::isdigit(numbers[1][i]))
                        {
                            after_alpha = true;
                        }
                    }
                }
                return true;
            }
            else
            {
                return false;
            }
        }
        else
        {
            return false;
        }
    }

is_dimension_char()

bool scifir::is_dimension_char

(

const UChar32 &

x

)

Definition at line 2335 of file dimension.cpp.

    {
        return u_isalpha(x) || x == UChar32(U'Ω') || x == UChar32(U'Å') || x == UChar32(U'θ') || x == UChar32(U'°');
    }

is_lab_number()

bool scifir::is_lab_number

(

const string &

init_lab_number

)

Definition at line 7 of file lab_number.cpp.

    {
        if ((init_lab_number.find("\u00B1") != string::npos or init_lab_number.find("+") != string::npos or init_lab_number.find("-") != string::npos) and init_lab_number.length() > 1)
        {
            vector<string> numbers;
            boost::split(numbers,init_lab_number,boost::is_any_of("+-,\u00B1"));
            if (numbers.size() != 3)
            {
                return false;
            }
            if (numbers[2].length() < 1)
            {
                return false;
            }
            bool dot_present = false;
            bool after_whitespace = false;
            bool after_alpha = false;
            boost::trim(numbers[0]);
            boost::trim(numbers[2]);
            for (unsigned int i = 0; i < numbers[0].length(); i++)
            {
                if (numbers[0][i] == '.')
                {
                    if (dot_present)
                    {
                        return false;
                    }
                    else
                    {
                        dot_present = true;
                        continue;
                    }
                }
                else if (numbers[0][i] == ' ')
                {
                    after_whitespace = true;
                    continue;
                }
                else if (!std::isdigit(numbers[0][i]) and after_whitespace == false)
                {
                    return false;
                }
                else if (after_whitespace == true)
                {
                    if (after_alpha == true and std::isalpha(numbers[0][i]))
                    {
                        return false;
                    }
                    else if (std::isalpha(numbers[0][i]))
                    {
                        continue;
                    }
                    else if (std::isdigit(numbers[0][i]))
                    {
                        after_alpha = true;
                    }
                }
            }
            dot_present = false;
            after_whitespace = false;
            after_alpha = false;
            for (unsigned int i = 0; i < numbers[2].length(); i++)
            {
                if (numbers[2][i] == '.')
                {
                    if (dot_present)
                    {
                        return false;
                    }
                    else
                    {
                        dot_present = true;
                        continue;
                    }
                }
                else if (numbers[2][i] == ' ')
                {
                    after_whitespace = true;
                    continue;
                }
                else if (!std::isdigit(numbers[2][i]) and after_whitespace == false)
                {
                    return false;
                }
                else if (after_whitespace == true)
                {
                    if (after_alpha == true and std::isalpha(numbers[2][i]))
                    {
                        return false;
                    }
                    else if (std::isalpha(numbers[2][i]))
                    {
                        continue;
                    }
                    else if (std::isdigit(numbers[2][i]))
                    {
                        after_alpha = true;
                    }
                }
            }
            return true;
        }
        else
        {
            return false;
        }
    }

is_latitude()

bool scifir::is_latitude

(

const string &

init_latitude

)

Definition at line 199 of file latitude.cpp.

    {
        if (init_latitude.length() == 0)
        {
            return false;
        }
        bool cardinale_point_present = false;
        if (init_latitude.substr(init_latitude.length() - 1) == "N")
        {
            cardinale_point_present = true;
        }
        else if (init_latitude.substr(init_latitude.length() - 1) == "S")
        {
            cardinale_point_present = true;
        }
        int start_point = 0;
        if (cardinale_point_present == false && init_latitude[0] == '-')
        {
            start_point++;
        }
        icu::UnicodeString x_unicode = icu::UnicodeString(init_latitude.c_str());
        int total_chars = x_unicode.countChar32();
        if (cardinale_point_present)
        {
            total_chars--;
        }
        bool loop = false;
        if (x_unicode[total_chars - 1] == 0x00B0 || x_unicode[total_chars - 1] == 0x00BA)
        {
            loop = true;
        }
        if (loop == false)
        {
            return false;
        }
        bool dot_present = false;
        for (int i = start_point; i < (total_chars - 1); i++)
        {
            if (x_unicode[i] == '.')
            {
                if (dot_present)
                {
                    return false;
                }
                else
                {
                    dot_present = true;
                }
            }
            else if (!u_isdigit(x_unicode[i]))
            {
                return false;
            }
        }
        return true;
    }

is_longitude()

bool scifir::is_longitude

(

const string &

init_longitude

)

Definition at line 195 of file longitude.cpp.

    {
        if (init_longitude.length() == 0)
        {
            return false;
        }
        bool cardinale_point_present = false;
        if (init_longitude.substr(init_longitude.length() - 1) == "E")
        {
            cardinale_point_present = true;
        }
        else if (init_longitude.substr(init_longitude.length() - 1) == "W")
        {
            cardinale_point_present = true;
        }
        int start_point = 0;
        if (cardinale_point_present == false && init_longitude[0] == '-')
        {
            start_point++;
        }
        icu::UnicodeString x_unicode = icu::UnicodeString(init_longitude.c_str());
        int total_chars = x_unicode.countChar32();
        if (cardinale_point_present)
        {
            total_chars--;
        }
        bool loop = false;
        if (x_unicode[total_chars - 1] == 0x00B0 || x_unicode[total_chars - 1] == 0x00BA)
        {
            loop = true;
        }
        if (loop == false)
        {
            return false;
        }
        bool dot_present = false;
        for (int i = start_point; i < (total_chars - 1); i++)
        {
            if (x_unicode[i] == '.')
            {
                if (dot_present)
                {
                    return false;
                }
                else
                {
                    dot_present = true;
                }
            }
            else if (!u_isdigit(x_unicode[i]))
            {
                return false;
            }
        }
        return true;
    }

is_percentage()

bool scifir::is_percentage

(

const string &

init_percentage

)

Checks if a string is an initialization string of percentage.

Definition at line 488 of file percentage.cpp.

    {
        int iteration_limit;
        if (init_percentage.back() == '%')
        {
            iteration_limit = int(init_percentage.length()) - 1;
        }
        else
        {
            string percentage_unit = init_percentage.substr(init_percentage.length() - 4,4);
            if (percentage_unit == " ppm"/* or percentage_unit == " ppb" or percentage_unit == " ppt" or percentage_unit == " ppq"*/)
            {
                iteration_limit = int(init_percentage.length()) - 4;
            }
            else
            {
                percentage_unit = init_percentage.substr(init_percentage.length() - 3,3);
                if (percentage_unit == "ppm"/* or percentage_unit == "ppb" or percentage_unit == "ppt" or percentage_unit == "ppq"*/)
                {
                    iteration_limit = int(init_percentage.length()) - 3;
                }
                else
                {
                    return false;
                }
            }
        }
        bool dot_present = false;
        for (int i = 0; i < iteration_limit; i++)
        {
            if (init_percentage[i] == '.')
            {
                if (dot_present)
                {
                    return false;
                }
                else
                {
                    dot_present = true;
                }
            }
            else if (!std::isdigit(init_percentage[i]))
            {
                return false;
            }
        }
        return true;
    }

is_pixel()

bool scifir::is_pixel

(

const string &

init_pixel

)

Definition at line 201 of file pixel.cpp.

    {
        int iteration_limit;
        if (init_pixel.substr(init_pixel.length() - 3,3) == " px")
        {
            iteration_limit = int(init_pixel.length()) - 3;
        }
        else if (init_pixel.substr(init_pixel.length() - 2,2) == "px")
        {
            iteration_limit = int(init_pixel.length()) - 2;
        }
        else
        {
            iteration_limit = int(init_pixel.length());
        }
        bool dot_present = false;
        for (int i = 0; i < iteration_limit; i++)
        {
            if (init_pixel[i] == '.')
            {
                if (dot_present)
                {
                    return false;
                }
                else
                {
                    dot_present = true;
                }
            }
            else if (!std::isdigit(init_pixel[i]))
            {
                return false;
            }
        }
        return true;
    }

is_scalar_unit()

bool scifir::is_scalar_unit

(

const string &

init_scalar

)

Checks if an string is an initialization string of a scalar_unit.

Parameters

init_scalar

string to check. It must be an initialization string of a scalar_unit to return true.

Definition at line 745 of file scalar_unit.cpp.

    {
        bool dot_present = false;
        bool e_present = false;
        unsigned int current_pos = 0;
        int e_present_pos = 0;
        for (unsigned int i = 0; i < init_scalar.length(); i++)
        {
            if (init_scalar[i] == ' ')
            {
                if (e_present and ((unsigned int)(e_present_pos + 1) == i))
                {
                    return false;
                }
                current_pos = i;
                break;
            }
            if (e_present == false)
            {
                if (init_scalar[i] == '.')
                {
                    if (dot_present)
                    {
                        return false;
                    }
                    else
                    {
                        dot_present = true;
                    }
                }
                else if (init_scalar[i] == 'e' or init_scalar[i] == 'E')
                {
                    e_present = true;
                    e_present_pos = i;
                    continue;
                }
                else if (init_scalar[i] == '*')
                {
                    if (!(init_scalar.substr(i + 1,3) == "10^"))
                    {
                        return false;
                    }
                    else
                    {
                        e_present = true;
                        i += 3;
                        e_present_pos = i;
                        continue;
                    }
                }
                else if (!isdigit(init_scalar[i]))
                {
                    return false;
                }
                else if (i == (init_scalar.length() - 1))
                {
                    return false;
                }
            }
            else
            {
                if (!isdigit(init_scalar[i]))
                {
                    return false;
                }
            }
        }
        if (current_pos == (init_scalar.length() - 1))
        {
            return false;
        }
        if (current_pos == 0)
        {
            return false;
        }
        bool brackets_present = false;
        if (init_scalar.at(current_pos + 1) == '[')
        {
            if (init_scalar.at(init_scalar.size() - 1) != ']')
            {
                return false;
            }
            current_pos++;
            brackets_present = true;
        }
        vector<string> values;
        boost::split(values,init_scalar.substr(current_pos + 1,init_scalar.size() - 1),boost::is_any_of("/"));
        if (brackets_present)
        {
            values[values.size() - 1] = values[values.size() - 1].substr(0,values[values.size() - 1].size() - 1);
        }
        if (values.size() == 1)
        {
            vector<string> subvalues;
            boost::split(subvalues,values[0],boost::is_any_of("*"));
            for (string& x_subvalue : subvalues)
            {
                boost::trim(x_subvalue);
                bool number_present = false;
                for (unsigned int i = 0; i < x_subvalue.length(); i++)
                {
                    if (number_present == false)
                    {
                        if (isdigit(x_subvalue[i]))
                        {
                            number_present = true;
                            continue;
                        }
                        else if (!isalpha(x_subvalue[i]))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        if (!isdigit(x_subvalue[i]))
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }
        else if (values.size() == 2)
        {
            if (values[0] != "1")
            {
                vector<string> subvalues;
                boost::split(subvalues,values[0],boost::is_any_of("*"));
                for (string& x_subvalue : subvalues)
                {
                    boost::trim(x_subvalue);
                    bool number_present = false;
                    for (unsigned int i = 0; i < x_subvalue.length(); i++)
                    {
                        if (number_present == false)
                        {
                            if (isdigit(x_subvalue[i]))
                            {
                                number_present = true;
                                continue;
                            }
                            else if (!isalpha(x_subvalue[i]))
                            {
                                return false;
                            }
                        }
                        else
                        {
                            if (!isdigit(x_subvalue[i]))
                            {
                                return false;
                            }
                        }
                    }
                }
            }
            vector<string> subvalues_denominator;
            boost::split(subvalues_denominator,values[1],boost::is_any_of("*"));
            for (string& x_subvalue : subvalues_denominator)
            {
                boost::trim(x_subvalue);
                bool number_present = false;
                for (unsigned int i = 0; i < x_subvalue.length(); i++)
                {
                    if (number_present == false)
                    {
                        if (isdigit(x_subvalue[i]))
                        {
                            number_present = true;
                            continue;
                        }
                        else if (!isalpha(x_subvalue[i]))
                        {
                            return false;
                        }
                    }
                    else
                    {
                        if (!isdigit(x_subvalue[i]))
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }
        return false;
    }

kelvin_to_fahrenheit()

float scifir::kelvin_to_fahrenheit ( float  x )

inline

Definition at line 42 of file conversion.hpp.

    {
        return (x - 273.15f) * 1.8f + 32.0f;
    }

LLA_to_ECEF_x()

scalar_unit scifir::LLA_to_ECEF_x ( const latitude &  latitude, const longitude &  longitude, scalar_unit  altitude  )

inline

Definition at line 63 of file coordinates_3d.hpp.

    {
        long double e_square = 0.00669437999014l;
        long double n = WGS84_EARTH_SEMIAXIS_A.get_value() / std::sqrt(1 - e_square * scifir::sin(latitude) * scifir::sin(latitude));
        altitude.change_dimensions("m");
        return (n + altitude) * scifir::cos(latitude) * scifir::cos(longitude);
    }

LLA_to_ECEF_y()

scalar_unit scifir::LLA_to_ECEF_y ( const latitude &  latitude, const longitude &  longitude, scalar_unit  altitude  )

inline

Definition at line 71 of file coordinates_3d.hpp.

    {
        long double e_square = 0.00669437999014l;
        long double n = WGS84_EARTH_SEMIAXIS_A.get_value() / std::sqrt(1 - e_square * scifir::sin(latitude) * scifir::sin(latitude));
        altitude.change_dimensions("m");
        return (n + altitude) * scifir::cos(latitude) * scifir::sin(longitude);
    }

LLA_to_ECEF_z()

scalar_unit scifir::LLA_to_ECEF_z ( const latitude &  latitude, const longitude &  longitude, scalar_unit  altitude  )

inline

Definition at line 79 of file coordinates_3d.hpp.

    {
        long double e_square = 0.00669437999014l;
        long double n = WGS84_EARTH_SEMIAXIS_A.get_value() / std::sqrt(1 - e_square * scifir::sin(latitude) * scifir::sin(latitude));
        altitude.change_dimensions("m");
        return ((1 - e_square) * n + altitude) * scifir::sin(latitude);
    }

mass() [1/2]

scifir::mass::mass	(	const percentage &	new_percentage,
		const mass &	new_mass
	)

Definition at line 369 of file base_units.cpp.

                                                                    : scalar_unit()
    {
        dimensions = new_mass.get_dimensions();
        value = new_percentage * new_mass.get_value();
    }

mass() [2/2]

scifir::mass::mass	(	const string &	init_percentage,
		const string &	init_mass
	)

Definition at line 375 of file base_units.cpp.

                                                                    : scalar_unit()
    {
        initialize_from_string(init_mass,mass::real_dimensions);
        percentage new_percentage = percentage(init_percentage);
        value = new_percentage * value;
    }

mole() [1/2]

scifir::mole::mole	(	const percentage &	new_percentage,
		const mole &	new_mole
	)

Definition at line 386 of file base_units.cpp.

                                                                    : scalar_unit()
    {
        dimensions = new_mole.get_dimensions();
        value = new_percentage * new_mole.get_value();
    }

mole() [2/2]

scifir::mole::mole	(	const string &	init_percentage,
		const string &	init_mole
	)

Definition at line 392 of file base_units.cpp.

                                                                    : scalar_unit()
    {
        initialize_from_string(init_mole,mole::real_dimensions);
        percentage new_percentage = percentage(init_percentage);
        value = new_percentage * value;
    }

multiply_dimensions() [1/2]

vector< dimension > scifir::multiply_dimensions	(	const vector< dimension > &	x,
		const vector< dimension > &	y
	)

Multiplies two vectors of dimensions. The result is normalized after, which means that equal dimensions at the numerator and at the denominator are cancelled.

Definition at line 2089 of file dimension.cpp.

    {
        vector<dimension> new_dimensions = x;
        for(const dimension& y_dimension : y)
        {
            new_dimensions.push_back(y_dimension);
        }
        return new_dimensions;
    }

multiply_dimensions() [2/2]

vector< dimension > scifir::multiply_dimensions	(	vector< dimension >	x,
		const vector< dimension > &	y,
		long double &	value
	)

Multiplies two vectors of dimensions. The result is normalized after, which means that equal dimensions at the numerator and at the denominator are cancelled. It also updates the value associated with those two vectors of dimensions with the prefix m ath and the conversion factor of those dimensions.

Definition at line 2099 of file dimension.cpp.

    {
        for(const dimension& y_dimension : y)
        {
            x.push_back(y_dimension);
        }
        return normalize_dimensions(x,value);
    }

norm() [1/3]

scalar_unit scifir::norm

(

const vector_unit_2d &

x

)

It returns the value of the vector in polar coordinates, p.

Definition at line 345 of file vector_unit_2d.cpp.

    {
        return scalar_unit(std::abs(x.get_value()),x.get_dimensions());
    }

norm() [2/3]

scalar_unit scifir::norm

(

const vector_unit_3d &

x

)

It returns the value of the vector in spherical coordinates, r.

Definition at line 450 of file vector_unit_3d.cpp.

    {
        return scalar_unit(std::abs(x.get_value()),x.get_dimensions());
    }

norm() [3/3]

scalar_unit scifir::norm

(

const vector_unit_nd &

x

)

It returns the value of the vector, which is the value in 1D, p in 2D (polar coordinates), or r in 3D (spherical coordinates).

Definition at line 786 of file vector_unit_nd.cpp.

    {
        return scalar_unit(std::abs(x.get_value()),x.get_dimensions());
    }

normalize_dimensions() [1/2]

vector< dimension > scifir::normalize_dimensions

(

const vector< dimension > &

x

)

Normalizes the dimensions, which means that repited dimensions at the numerator and at the denominator are cancelled.

Definition at line 2203 of file dimension.cpp.

    {
        vector<dimension> new_x = create_base_dimensions(x);
        if (new_x.size() == 1)
        {
            return x;
        }
        vector<unsigned int> skip_dimensions = vector<unsigned int>();
        for(unsigned int i = 0; i < new_x.size(); i++)
        {
            for(unsigned int j = i + 1; j < new_x.size(); j++)
            {
                if (skip_dimensions.size() > 0)
                {
                    bool skip = false;
                    for(unsigned int k = 0; k < skip_dimensions.size(); k++)
                    {
                        if (j == skip_dimensions[k])
                        {
                            skip = true;
                            break;
                        }
                    }
                    if (skip)
                    {
                        continue;
                    }
                }
                if (new_x[i].dimension_type == new_x[j].dimension_type and new_x[i].dimension_position != new_x[j].dimension_position)
                {
                    skip_dimensions.push_back(i);
                    skip_dimensions.push_back(j);
                    break;
                }
            }
        }
        vector<dimension> new_dimensions = vector<dimension>();
        for(unsigned int i = 0; i < new_x.size(); i++)
        {
            bool skip = false;
            for(unsigned int j = 0; j < skip_dimensions.size(); j++)
            {
                if (i == skip_dimensions[j])
                {
                    skip = true;
                    break;
                }
            }
            if (!skip)
            {
                new_dimensions.push_back(new_x[i]);
            }
        }
        return new_dimensions;
    }

normalize_dimensions() [2/2]

vector< dimension > scifir::normalize_dimensions	(	const vector< dimension > &	x,
		long double &	value
	)

Normalizes the dimensions, which means that repited dimensions at the numerator and at the denominator are cancelled. The value is updated if there are dimensions cancelled.

Definition at line 2259 of file dimension.cpp.

    {
        vector<dimension> new_x = create_base_dimensions(x,value);
        if (new_x.size() == 1)
        {
            return x;
        }
        vector<unsigned int> skip_dimensions = vector<unsigned int>();
        for(unsigned int i = 0; i < new_x.size(); i++)
        {
            for(unsigned int j = i + 1; j < new_x.size(); j++)
            {
                if (skip_dimensions.size() > 0)
                {
                    bool skip = false;
                    for(unsigned int k = 0; k < skip_dimensions.size(); k++)
                    {
                        if (j == skip_dimensions[k])
                        {
                            skip = true;
                            break;
                        }
                    }
                    if (skip)
                    {
                        continue;
                    }
                }
                if (new_x[i].dimension_type == new_x[j].dimension_type and new_x[i].dimension_position != new_x[j].dimension_position)
                {
                    if (new_x[i].dimension_position == dimension::NUMERATOR)
                    {
                        value *= float(new_x[i].get_conversion_factor());
                        value *= float(new_x[i].prefix_math());
                    }
                    else if (new_x[i].dimension_position == dimension::DENOMINATOR)
                    {
                        value /= float(new_x[i].get_conversion_factor());
                        value /= float(new_x[i].prefix_math());
                    }
                    if (new_x[j].dimension_position == dimension::NUMERATOR)
                    {
                        value *= float(new_x[j].get_conversion_factor());
                        value *= float(new_x[j].prefix_math());
                    }
                    else if (new_x[j].dimension_position == dimension::DENOMINATOR)
                    {
                        value /= float(new_x[j].get_conversion_factor());
                        value /= float(new_x[j].prefix_math());
                    }
                    skip_dimensions.push_back(i);
                    skip_dimensions.push_back(j);
                    break;
                }
            }
        }
        vector<dimension> new_dimensions = vector<dimension>();
        for(unsigned int i = 0; i < new_x.size(); i++)
        {
            bool skip = false;
            for(unsigned int j = 0; j < skip_dimensions.size(); j++)
            {
                if (i == skip_dimensions[j])
                {
                    skip = true;
                    break;
                }
            }
            if (!skip)
            {
                new_dimensions.push_back(new_x[i]);
            }
        }
        return new_dimensions;
    }

orthogonal() [1/4]

bool scifir::orthogonal	(	const angle &	x,
		const angle &	y
	)

Checks if two angles in a 2D correspond to orthogonal lines (or orthogonal vectors).

Definition at line 403 of file angle.cpp.

    {
        float difference = std::abs((x - y).get_value());
        if (difference == 90.0f or difference == 270.0f)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

orthogonal() [2/4]

bool scifir::orthogonal	(	const vector_unit_2d &	x,
		const vector_unit_2d &	y
	)

Checks if two vectors x and y are orthogonal, that's, if they have 90 degrees of difference.

Definition at line 384 of file vector_unit_2d.cpp.

    {
        return scifir::orthogonal(x.theta,y.theta);
    }

orthogonal() [3/4]

bool scifir::orthogonal	(	const vector_unit_3d &	x,
		const vector_unit_3d &	y
	)

Checks if two vectors x and y are orthogonal, that's, if they have 90 degrees between them.

Definition at line 525 of file vector_unit_3d.cpp.

    {
        scifir::angle x_angle = angle_between(x,y);
        return (x_angle == 90.0f);
    }

orthogonal() [4/4]

bool scifir::orthogonal	(	const vector_unit_nd &	x,
		const vector_unit_nd &	y
	)

Checks if two vectors x and y are orthogonal, that's, if they have 90 degrees between them. Both vectors must have the same ND, otherwise it returns an empty vector_unit_nd instead.

Definition at line 903 of file vector_unit_nd.cpp.

    {
        if (same_nd(x,y))
        {
            if (x.get_nd() == 1)
            {
                return false;
            }
            else if (x.get_nd() == 2)
            {
                return scifir::orthogonal(x.angles[0],y.angles[0]);
            }
            else if (x.get_nd() == 3)
            {
                scifir::angle x_angle = angle_between(x,y);
                return (x_angle == 90.0f);
            }
        }
        return false;
    }

parallel() [1/4]

bool scifir::parallel	(	const angle &	x,
		const angle &	y
	)

Checks if two angles in a 2D correspond to parallel lines (or parallel vectors).

Definition at line 391 of file angle.cpp.

    {
        if(x == y or (x + 180.0f) == y)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

parallel() [2/4]

bool scifir::parallel	(	const vector_unit_2d &	x,
		const vector_unit_2d &	y
	)

Checks if two vectors x and y are parallel, which means that their direction is the same or the exact opposite.

Definition at line 379 of file vector_unit_2d.cpp.

    {
        return scifir::parallel(x.theta,y.theta);
    }

parallel() [3/4]

bool scifir::parallel	(	const vector_unit_3d &	x,
		const vector_unit_3d &	y
	)

Checks if two vectors x and y are parallel, which means that their direction is the same or the exact opposite.

Definition at line 513 of file vector_unit_3d.cpp.

    {
        if ((x.theta == y.theta and x.phi == y.phi) or (x.theta == (180.0f + y.theta) and x.phi == (180.0f - y.phi)))
        {
            return true;
        }
        else
        {
            return false;
        }
    }

parallel() [4/4]

bool scifir::parallel	(	const vector_unit_nd &	x,
		const vector_unit_nd &	y
	)

Checks if two vectors x and y are parallel, which means that their direction is the same or the exact opposite. Both vectors must have the same ND, otherwise it returns an empty vector_unit_nd instead.

Definition at line 876 of file vector_unit_nd.cpp.

    {
        if (same_nd(x,y))
        {
            if (x.get_nd() == 1)
            {
                return true;
            }
            else if (x.get_nd() == 2)
            {
                return scifir::parallel(x.angles[0],y.angles[0]);
            }
            else if (x.get_nd() == 3)
            {
                if ((x.angles[0] == y.angles[0] and x.angles[1] == y.angles[1]) or (x.angles[0] == (180.0f + y.angles[0]) and x.angles[1] == (180.0f - y.angles[1])))
                {
                    return true;
                }
                else
                {
                    return false;
                }
            }
        }
        return false;
    }

parse_float()

float scifir::parse_float

(

const string &

x

)

Definition at line 10 of file types.cpp.

    {
        try
        {
            float value = stof(x);
            return value;
        }
        catch (const exception& e)
        {
            return 0;
        }
    }

parse_int()

int scifir::parse_int

(

const string &

x

)

Definition at line 23 of file types.cpp.

    {
        try
        {
            int value = stoi(x);
            return value;
        }
        catch (const exception& e)
        {
            return 0;
        }
    }

polar_to_cartesian_2d_x() [1/2]

scalar_unit scifir::polar_to_cartesian_2d_x ( const scalar_unit &  p, const angle &  theta  )

inline

Definition at line 366 of file coordinates_2d.hpp.

    {
        return p * scifir::cos(theta);
    }

polar_to_cartesian_2d_x() [2/2]

float scifir::polar_to_cartesian_2d_x ( float  p, const angle &  theta  )

inline

Definition at line 386 of file coordinates_2d.hpp.

    {
        return p * scifir::cos(theta);
    }

polar_to_cartesian_2d_y() [1/2]

scalar_unit scifir::polar_to_cartesian_2d_y ( const scalar_unit &  p, const angle &  theta  )

inline

Definition at line 371 of file coordinates_2d.hpp.

    {
        return p * scifir::sin(theta);
    }

polar_to_cartesian_2d_y() [2/2]

float scifir::polar_to_cartesian_2d_y ( float  p, const angle &  theta  )

inline

Definition at line 391 of file coordinates_2d.hpp.

    {
        return p * scifir::sin(theta);
    }

pow()

scalar_unit scifir::pow	(	const scalar_unit &	x,
		int	exponent
	)

Exponentiates a scalar_unit to some numeric type, the dimensions are also exponentiated.

Definition at line 942 of file scalar_unit.cpp.

    {
        return x ^ exponent;
    }

power_dimensions()

vector< dimension > scifir::power_dimensions	(	const vector< dimension > &	x,
		int	exponent
	)

Powers the dimensions by an exponent.

Definition at line 2190 of file dimension.cpp.

    {
        vector<dimension> new_dimensions = vector<dimension>();
        for (const dimension& x_dimension: x)
        {
            for (unsigned int j = 1; j <= exponent; j++)
            {
                new_dimensions.push_back(x_dimension);
            }
        }
        return new_dimensions;
    }

prefix_string()

prefix::type scifir::prefix_string

(

const string &

x

)

Returns the value of the enum prefix::type associated with the string x given.

Definition at line 215 of file prefix.cpp.

    {
        if (x == "Q")
        {
            return prefix::QUETTA;
        }
        else if (x == "R")
        {
            return prefix::RONNA;
        }
        else if (x == "Y")
        {
            return prefix::YOTTA;
        }
        else if (x == "Z")
        {
            return prefix::ZETTA;
        }
        else if (x == "E")
        {
            return prefix::EXA;
        }
        else if (x == "P")
        {
            return prefix::PETA;
        }
        else if (x == "T")
        {
            return prefix::TERA;
        }
        else if(x == "G")
        {
            return prefix::GIGA;
        }
        else if(x == "M")
        {
            return prefix::MEGA;
        }
        else if(x == "k")
        {
            return prefix::KILO;
        }
        else if(x == "h")
        {
            return prefix::HECTO;
        }
        else if(x == "da")
        {
            return prefix::DECA;
        }
        else if(x == "d")
        {
            return prefix::DECI;
        }
        else if(x == "c")
        {
            return prefix::CENTI;
        }
        else if(x == "m")
        {
            return prefix::MILLI;
        }
        else if(x == "u" or x == "µ")
        {
            return prefix::MICRO;
        }
        else if(x == "n")
        {
            return prefix::NANO;
        }
        else if(x == "p")
        {
            return prefix::PICO;
        }
        else if(x == "f")
        {
            return prefix::FEMTO;
        }
        else if(x == "a")
        {
            return prefix::ATTO;
        }
        else if(x == "z")
        {
            return prefix::ZEPTO;
        }
        else if(x == "y")
        {
            return prefix::YOCTO;
        }
        else if(x == "r")
        {
            return prefix::RONTO;
        }
        else if(x == "q")
        {
            return prefix::QUECTO;
        }
        else if (x == "")
        {
            return prefix::NONE;
        }
        else
        {
            return prefix::NONE;
        }
    }

radian_to_degree()

float scifir::radian_to_degree ( float  x )

inline

Converts a radian to degree.

Definition at line 16 of file angle.hpp.

    {
        return x * 180.0f / std::numbers::pi_v<float>;
    }

radian_to_gradian()

float scifir::radian_to_gradian ( float  x )

inline

Definition at line 51 of file angle.hpp.

    {
        return x * 200.0f / std::numbers::pi_v<float>;
    }

radian_to_turn()

float scifir::radian_to_turn ( float  x )

inline

Definition at line 66 of file angle.hpp.

    {
        return x / (2.0f * std::numbers::pi_v<float>);
    }

same_direction() [1/3]

bool scifir::same_direction	(	const vector_unit_2d &	x,
		const vector_unit_2d &	y
	)

Checks if two vectors x and y have the same direction.

Definition at line 374 of file vector_unit_2d.cpp.

    {
        return x.theta == y.theta;
    }

same_direction() [2/3]

bool scifir::same_direction	(	const vector_unit_3d &	x,
		const vector_unit_3d &	y
	)

Checks if two vectors x and y have the same direction.

Definition at line 501 of file vector_unit_3d.cpp.

    {
        if (x.theta == y.theta and x.phi == y.phi)
        {
            return true;
        }
        else
        {
            return false;
        }
    }

same_direction() [3/3]

bool scifir::same_direction	(	const vector_unit_nd &	x,
		const vector_unit_nd &	y
	)

Checks if two vectors x and y have the same direction. Both vectors must have the same ND, otherwise it returns an empty vector_unit_nd instead.

Definition at line 860 of file vector_unit_nd.cpp.

    {
        if (same_nd(x,y))
        {
            for(unsigned int i = 0; i < x.angles.size(); i++)
            {
                if(x.angles[i] != y.angles[i])
                {
                    return false;
                }
            }
            return true;
        }
        return false;
    }

same_nd()

bool scifir::same_nd	(	const vector_unit_nd &	x,
		const vector_unit_nd &	y
	)

Checks if two vectors have the same number of dimensions.

Definition at line 848 of file vector_unit_nd.cpp.

    {
        if(x.angles.size() == y.angles.size())
        {
            return true;
        }
        else
        {
            return false;
        }
    }

SCALAR_UNIT_CPP() [1/92]

scifir::SCALAR_UNIT_CPP	(	absorbed_dose	,
		"Gy/s"
	)

SCALAR_UNIT_CPP() [2/92]

scifir::SCALAR_UNIT_CPP	(	action	,
		"kg*m2/s"
	)

SCALAR_UNIT_CPP() [3/92]

scifir::SCALAR_UNIT_CPP	(	amount_of_effect	,
		"IU"
	)

SCALAR_UNIT_CPP() [4/92]

scifir::SCALAR_UNIT_CPP	(	area	,
		"m2"
	)

SCALAR_UNIT_CPP() [5/92]

scifir::SCALAR_UNIT_CPP	(	area_density	,
		"g/m2"
	)

SCALAR_UNIT_CPP() [6/92]

scifir::SCALAR_UNIT_CPP	(	brain_memory	,
		"memo"
	)

SCALAR_UNIT_CPP() [7/92]

scifir::SCALAR_UNIT_CPP	(	capacitance	,
		"F"
	)

SCALAR_UNIT_CPP() [8/92]

scifir::SCALAR_UNIT_CPP	(	catalytic_activity	,
		"kat"
	)

SCALAR_UNIT_CPP() [9/92]

scifir::SCALAR_UNIT_CPP	(	catalytic_efficiency	,
		"m3/s*mol"
	)

SCALAR_UNIT_CPP() [10/92]

scifir::SCALAR_UNIT_CPP	(	charge	,
		"C"
	)

SCALAR_UNIT_CPP() [11/92]

scifir::SCALAR_UNIT_CPP	(	compressibility	,
		"m*s2/kg"
	)

SCALAR_UNIT_CPP() [12/92]

scifir::SCALAR_UNIT_CPP	(	curvature	,
		"1/m"
	)

SCALAR_UNIT_CPP() [13/92]

scifir::SCALAR_UNIT_CPP	(	density	,
		"g/m3"
	)

SCALAR_UNIT_CPP() [14/92]

scifir::SCALAR_UNIT_CPP	(	diffusion_coefficient	,
		"m2/s"
	)

SCALAR_UNIT_CPP() [15/92]

scifir::SCALAR_UNIT_CPP	(	dynamic_viscosity	,
		"g/m*s"
	)

SCALAR_UNIT_CPP() [16/92]

scifir::SCALAR_UNIT_CPP	(	electric_charge_density	,
		"C/m3"
	)

SCALAR_UNIT_CPP() [17/92]

scifir::SCALAR_UNIT_CPP	(	electric_conductance	,
		"S"
	)

SCALAR_UNIT_CPP() [18/92]

scifir::SCALAR_UNIT_CPP	(	electric_current	,
		"A"
	)

SCALAR_UNIT_CPP() [19/92]

scifir::SCALAR_UNIT_CPP	(	electric_current_density	,
		"A/m2"
	)

SCALAR_UNIT_CPP() [20/92]

scifir::SCALAR_UNIT_CPP	(	electrical_conductivity	,
		"S/m"
	)

SCALAR_UNIT_CPP() [21/92]

scifir::SCALAR_UNIT_CPP	(	electron_mobility	,
		"m2/V*s"
	)

SCALAR_UNIT_CPP() [22/92]

scifir::SCALAR_UNIT_CPP	(	energy	,
		"J"
	)

SCALAR_UNIT_CPP() [23/92]

scifir::SCALAR_UNIT_CPP	(	energy_density	,
		"g/m*s2"
	)

SCALAR_UNIT_CPP() [24/92]

scifir::SCALAR_UNIT_CPP	(	energy_flux_density	,
		"kg/s3"
	)

SCALAR_UNIT_CPP() [25/92]

scifir::SCALAR_UNIT_CPP	(	entropy	,
		"kg*m2/K*s2"
	)

SCALAR_UNIT_CPP() [26/92]

scifir::SCALAR_UNIT_CPP	(	frequency	,
		"Hz"
	)

SCALAR_UNIT_CPP() [27/92]

scifir::SCALAR_UNIT_CPP	(	frequency_drift	,
		"1/s2"
	)

SCALAR_UNIT_CPP() [28/92]

scifir::SCALAR_UNIT_CPP	(	fuel_efficiency	,
		"1/m2"
	)

SCALAR_UNIT_CPP() [29/92]

scifir::SCALAR_UNIT_CPP	(	heat_capacity	,
		"J/K"
	)

SCALAR_UNIT_CPP() [30/92]

scifir::SCALAR_UNIT_CPP	(	heat_flux_density	,
		"kg/s3"
	)

SCALAR_UNIT_CPP() [31/92]

scifir::SCALAR_UNIT_CPP	(	illuminance	,
		"lx"
	)

SCALAR_UNIT_CPP() [32/92]

scifir::SCALAR_UNIT_CPP	(	inductance	,
		"H"
	)

SCALAR_UNIT_CPP() [33/92]

scifir::SCALAR_UNIT_CPP	(	information_size	,
		"B"
	)

SCALAR_UNIT_CPP() [34/92]

scifir::SCALAR_UNIT_CPP	(	ionizing_radiation	,
		"Gy"
	)

SCALAR_UNIT_CPP() [35/92]

scifir::SCALAR_UNIT_CPP	(	length	,
		"m"
	)

SCALAR_UNIT_CPP() [36/92]

scifir::SCALAR_UNIT_CPP	(	light_intensity	,
		"cd"
	)

SCALAR_UNIT_CPP() [37/92]

scifir::SCALAR_UNIT_CPP	(	linear_charge_density	,
		"C/m"
	)

SCALAR_UNIT_CPP() [38/92]

scifir::SCALAR_UNIT_CPP	(	linear_mass_density	,
		"g/m"
	)

SCALAR_UNIT_CPP() [39/92]

scifir::SCALAR_UNIT_CPP	(	luminous_efficacy	,
		"lm/W"
	)

SCALAR_UNIT_CPP() [40/92]

scifir::SCALAR_UNIT_CPP	(	luminous_energy	,
		"lm*s"
	)

SCALAR_UNIT_CPP() [41/92]

scifir::SCALAR_UNIT_CPP	(	luminous_exposure	,
		"lx*s"
	)

SCALAR_UNIT_CPP() [42/92]

scifir::SCALAR_UNIT_CPP	(	luminous_flux	,
		"lm"
	)

SCALAR_UNIT_CPP() [43/92]

scifir::SCALAR_UNIT_CPP	(	magnetic_flux	,
		"Wb"
	)

SCALAR_UNIT_CPP() [44/92]

scifir::SCALAR_UNIT_CPP	(	magnetic_permeability	,
		"H/m"
	)

SCALAR_UNIT_CPP() [45/92]

scifir::SCALAR_UNIT_CPP	(	magnetic_reluctance	,
		"1/H"
	)

SCALAR_UNIT_CPP() [46/92]

scifir::SCALAR_UNIT_CPP	(	magnetic_rigidity	,
		"T*m"
	)

SCALAR_UNIT_CPP() [47/92]

scifir::SCALAR_UNIT_CPP	(	magnetic_susceptibility	,
		"m/H"
	)

SCALAR_UNIT_CPP() [48/92]

scifir::SCALAR_UNIT_CPP	(	magnetization	,
		"A/m"
	)

SCALAR_UNIT_CPP() [49/92]

scifir::SCALAR_UNIT_CPP	(	mass	,
		"g"
	)

SCALAR_UNIT_CPP() [50/92]

scifir::SCALAR_UNIT_CPP	(	mass_flow_rate	,
		"g/s"
	)

SCALAR_UNIT_CPP() [51/92]

scifir::SCALAR_UNIT_CPP	(	molality	,
		"mol/g"
	)

SCALAR_UNIT_CPP() [52/92]

scifir::SCALAR_UNIT_CPP	(	molar_conductivity	,
		"s3*A2/g*mol"
	)

SCALAR_UNIT_CPP() [53/92]

scifir::SCALAR_UNIT_CPP	(	molar_energy	,
		"m2*g/s2*mol"
	)

SCALAR_UNIT_CPP() [54/92]

scifir::SCALAR_UNIT_CPP	(	molar_enthalpy	,
		"m2*g/s2*mol"
	)

SCALAR_UNIT_CPP() [55/92]

scifir::SCALAR_UNIT_CPP	(	molar_entropy	,
		"m2*g/s2*K*mol"
	)

SCALAR_UNIT_CPP() [56/92]

scifir::SCALAR_UNIT_CPP	(	molar_heat_capacity	,
		"m2*g/s2*K*mol"
	)

SCALAR_UNIT_CPP() [57/92]

scifir::SCALAR_UNIT_CPP	(	molar_mass	,
		"g/mol"
	)

SCALAR_UNIT_CPP() [58/92]

scifir::SCALAR_UNIT_CPP	(	molar_volume	,
		"m3/mol"
	)

SCALAR_UNIT_CPP() [59/92]

scifir::SCALAR_UNIT_CPP	(	molarity	,
		"M"
	)

SCALAR_UNIT_CPP() [60/92]

scifir::SCALAR_UNIT_CPP	(	mole	,
		"mol"
	)

SCALAR_UNIT_CPP() [61/92]

scifir::SCALAR_UNIT_CPP	(	moment_of_inertia	,
		"m2*kg"
	)

SCALAR_UNIT_CPP() [62/92]

scifir::SCALAR_UNIT_CPP	(	optical_power	,
		"1/m"
	)

SCALAR_UNIT_CPP() [63/92]

scifir::SCALAR_UNIT_CPP	(	permittivity	,
		"F/m"
	)

SCALAR_UNIT_CPP() [64/92]

scifir::SCALAR_UNIT_CPP	(	polarization_density	,
		"C/m2"
	)

SCALAR_UNIT_CPP() [65/92]

scifir::SCALAR_UNIT_CPP	(	power	,
		"W"
	)

SCALAR_UNIT_CPP() [66/92]

scifir::SCALAR_UNIT_CPP	(	power_density	,
		"kg/m*s3"
	)

SCALAR_UNIT_CPP() [67/92]

scifir::SCALAR_UNIT_CPP	(	radiance	,
		"kg/s3"
	)

SCALAR_UNIT_CPP() [68/92]

scifir::SCALAR_UNIT_CPP	(	radiant_intensity	,
		"kg*m2/s3"
	)

SCALAR_UNIT_CPP() [69/92]

scifir::SCALAR_UNIT_CPP	(	radioactivity	,
		"Bq"
	)

SCALAR_UNIT_CPP() [70/92]

scifir::SCALAR_UNIT_CPP	(	resistance	,
		"Ω"
	)

SCALAR_UNIT_CPP() [71/92]

scifir::SCALAR_UNIT_CPP	(	resistivity	,
		"Ω*m"
	)

SCALAR_UNIT_CPP() [72/92]

scifir::SCALAR_UNIT_CPP	(	sound_power	,
		"dB"
	)

SCALAR_UNIT_CPP() [73/92]

scifir::SCALAR_UNIT_CPP	(	specific_energy	,
		"m2/s2"
	)

SCALAR_UNIT_CPP() [74/92]

scifir::SCALAR_UNIT_CPP	(	specific_entropy	,
		"m2/s2*K"
	)

SCALAR_UNIT_CPP() [75/92]

scifir::SCALAR_UNIT_CPP	(	specific_heat_capacity	,
		"J/K*kg"
	)

SCALAR_UNIT_CPP() [76/92]

scifir::SCALAR_UNIT_CPP	(	specific_volume	,
		"m3/g"
	)

SCALAR_UNIT_CPP() [77/92]

scifir::SCALAR_UNIT_CPP	(	spectral_radiance	,
		"kg/m*s3"
	)

SCALAR_UNIT_CPP() [78/92]

scifir::SCALAR_UNIT_CPP	(	stiffness	,
		"kg/s2"
	)

SCALAR_UNIT_CPP() [79/92]

scifir::SCALAR_UNIT_CPP	(	surface_charge_density	,
		"C/m2"
	)

SCALAR_UNIT_CPP() [80/92]

scifir::SCALAR_UNIT_CPP	(	temperature	,
		"K"
	)

SCALAR_UNIT_CPP() [81/92]

scifir::SCALAR_UNIT_CPP	(	thermal_conductivity	,
		"W/m*K"
	)

SCALAR_UNIT_CPP() [82/92]

scifir::SCALAR_UNIT_CPP	(	thermal_diffusivity	,
		"m2/s"
	)

SCALAR_UNIT_CPP() [83/92]

scifir::SCALAR_UNIT_CPP	(	thermal_expansion_coefficient	,
		"1/K"
	)

SCALAR_UNIT_CPP() [84/92]

scifir::SCALAR_UNIT_CPP	(	thermal_resistance	,
		"K/W"
	)

SCALAR_UNIT_CPP() [85/92]

scifir::SCALAR_UNIT_CPP	(	transfer_speed	,
		"B/s"
	)

SCALAR_UNIT_CPP() [86/92]

scifir::SCALAR_UNIT_CPP	(	viscosity	,
		"m2/s"
	)

SCALAR_UNIT_CPP() [87/92]

scifir::SCALAR_UNIT_CPP	(	voltage	,
		"V"
	)

SCALAR_UNIT_CPP() [88/92]

scifir::SCALAR_UNIT_CPP	(	volume	,
		"m3"
	)

SCALAR_UNIT_CPP() [89/92]

scifir::SCALAR_UNIT_CPP	(	volume_4d	,
		"m4"
	)

SCALAR_UNIT_CPP() [90/92]

scifir::SCALAR_UNIT_CPP	(	volume_charge_density	,
		"C/m3"
	)

SCALAR_UNIT_CPP() [91/92]

scifir::SCALAR_UNIT_CPP	(	volumetric_flow	,
		"m3/s"
	)

SCALAR_UNIT_CPP() [92/92]

scifir::SCALAR_UNIT_CPP	(	wavenumber	,
		"1/m"
	)

SCALAR_UNIT_HPP() [1/88]

scifir::SCALAR_UNIT_HPP

(

absorbed_dose

)

SCALAR_UNIT_HPP() [2/88]

scifir::SCALAR_UNIT_HPP

(

action

)

SCALAR_UNIT_HPP() [3/88]

scifir::SCALAR_UNIT_HPP

(

amount_of_effect

)

SCALAR_UNIT_HPP() [4/88]

scifir::SCALAR_UNIT_HPP

(

area_density

)

SCALAR_UNIT_HPP() [5/88]

scifir::SCALAR_UNIT_HPP

(

brain_memory

)

SCALAR_UNIT_HPP() [6/88]

scifir::SCALAR_UNIT_HPP

(

capacitance

)

SCALAR_UNIT_HPP() [7/88]

scifir::SCALAR_UNIT_HPP

(

catalytic_activity

)

SCALAR_UNIT_HPP() [8/88]

scifir::SCALAR_UNIT_HPP

(

catalytic_efficiency

)

SCALAR_UNIT_HPP() [9/88]

scifir::SCALAR_UNIT_HPP

(

charge

)

SCALAR_UNIT_HPP() [10/88]

scifir::SCALAR_UNIT_HPP

(

compressibility

)

SCALAR_UNIT_HPP() [11/88]

scifir::SCALAR_UNIT_HPP

(

curvature

)

SCALAR_UNIT_HPP() [12/88]

scifir::SCALAR_UNIT_HPP

(

density

)

SCALAR_UNIT_HPP() [13/88]

scifir::SCALAR_UNIT_HPP

(

diffusion_coefficient

)

SCALAR_UNIT_HPP() [14/88]

scifir::SCALAR_UNIT_HPP

(

dynamic_viscosity

)

SCALAR_UNIT_HPP() [15/88]

scifir::SCALAR_UNIT_HPP

(

electric_charge_density

)

SCALAR_UNIT_HPP() [16/88]

scifir::SCALAR_UNIT_HPP

(

electric_conductance

)

SCALAR_UNIT_HPP() [17/88]

scifir::SCALAR_UNIT_HPP

(

electric_current

)

SCALAR_UNIT_HPP() [18/88]

scifir::SCALAR_UNIT_HPP

(

electric_current_density

)

SCALAR_UNIT_HPP() [19/88]

scifir::SCALAR_UNIT_HPP

(

electrical_conductivity

)

SCALAR_UNIT_HPP() [20/88]

scifir::SCALAR_UNIT_HPP

(

electron_mobility

)

SCALAR_UNIT_HPP() [21/88]

scifir::SCALAR_UNIT_HPP

(

energy

)

SCALAR_UNIT_HPP() [22/88]

scifir::SCALAR_UNIT_HPP

(

energy_density

)

SCALAR_UNIT_HPP() [23/88]

scifir::SCALAR_UNIT_HPP

(

energy_flux_density

)

SCALAR_UNIT_HPP() [24/88]

scifir::SCALAR_UNIT_HPP

(

entropy

)

SCALAR_UNIT_HPP() [25/88]

scifir::SCALAR_UNIT_HPP

(

frequency

)

SCALAR_UNIT_HPP() [26/88]

scifir::SCALAR_UNIT_HPP

(

frequency_drift

)

SCALAR_UNIT_HPP() [27/88]

scifir::SCALAR_UNIT_HPP

(

fuel_efficiency

)

SCALAR_UNIT_HPP() [28/88]

scifir::SCALAR_UNIT_HPP

(

heat_capacity

)

SCALAR_UNIT_HPP() [29/88]

scifir::SCALAR_UNIT_HPP

(

heat_flux_density

)

SCALAR_UNIT_HPP() [30/88]

scifir::SCALAR_UNIT_HPP

(

illuminance

)

SCALAR_UNIT_HPP() [31/88]

scifir::SCALAR_UNIT_HPP

(

inductance

)

SCALAR_UNIT_HPP() [32/88]

scifir::SCALAR_UNIT_HPP

(

information_size

)

SCALAR_UNIT_HPP() [33/88]

scifir::SCALAR_UNIT_HPP

(

ionizing_radiation

)

SCALAR_UNIT_HPP() [34/88]

scifir::SCALAR_UNIT_HPP

(

length

)

SCALAR_UNIT_HPP() [35/88]

scifir::SCALAR_UNIT_HPP

(

light_intensity

)

SCALAR_UNIT_HPP() [36/88]

scifir::SCALAR_UNIT_HPP

(

linear_charge_density

)

SCALAR_UNIT_HPP() [37/88]

scifir::SCALAR_UNIT_HPP

(

linear_mass_density

)

SCALAR_UNIT_HPP() [38/88]

scifir::SCALAR_UNIT_HPP

(

luminous_efficacy

)

SCALAR_UNIT_HPP() [39/88]

scifir::SCALAR_UNIT_HPP

(

luminous_energy

)

SCALAR_UNIT_HPP() [40/88]

scifir::SCALAR_UNIT_HPP

(

luminous_exposure

)

SCALAR_UNIT_HPP() [41/88]

scifir::SCALAR_UNIT_HPP

(

luminous_flux

)

SCALAR_UNIT_HPP() [42/88]

scifir::SCALAR_UNIT_HPP

(

magnetic_flux

)

SCALAR_UNIT_HPP() [43/88]

scifir::SCALAR_UNIT_HPP

(

magnetic_permeability

)

SCALAR_UNIT_HPP() [44/88]

scifir::SCALAR_UNIT_HPP

(

magnetic_reluctance

)

SCALAR_UNIT_HPP() [45/88]

scifir::SCALAR_UNIT_HPP

(

magnetic_rigidity

)

SCALAR_UNIT_HPP() [46/88]

scifir::SCALAR_UNIT_HPP

(

magnetic_susceptibility

)

SCALAR_UNIT_HPP() [47/88]

scifir::SCALAR_UNIT_HPP

(

magnetization

)

SCALAR_UNIT_HPP() [48/88]

scifir::SCALAR_UNIT_HPP

(

mass_flow_rate

)

SCALAR_UNIT_HPP() [49/88]

scifir::SCALAR_UNIT_HPP

(

molality

)

SCALAR_UNIT_HPP() [50/88]

scifir::SCALAR_UNIT_HPP

(

molar_conductivity

)

SCALAR_UNIT_HPP() [51/88]

scifir::SCALAR_UNIT_HPP

(

molar_energy

)

SCALAR_UNIT_HPP() [52/88]

scifir::SCALAR_UNIT_HPP

(

molar_enthalpy

)

SCALAR_UNIT_HPP() [53/88]

scifir::SCALAR_UNIT_HPP

(

molar_entropy

)

SCALAR_UNIT_HPP() [54/88]

scifir::SCALAR_UNIT_HPP

(

molar_heat_capacity

)

SCALAR_UNIT_HPP() [55/88]

scifir::SCALAR_UNIT_HPP

(

molar_mass

)

SCALAR_UNIT_HPP() [56/88]

scifir::SCALAR_UNIT_HPP

(

molar_volume

)

SCALAR_UNIT_HPP() [57/88]

scifir::SCALAR_UNIT_HPP

(

molarity

)

SCALAR_UNIT_HPP() [58/88]

scifir::SCALAR_UNIT_HPP

(

moment_of_inertia

)

SCALAR_UNIT_HPP() [59/88]

scifir::SCALAR_UNIT_HPP

(

optical_power

)

SCALAR_UNIT_HPP() [60/88]

scifir::SCALAR_UNIT_HPP

(

permittivity

)

SCALAR_UNIT_HPP() [61/88]

scifir::SCALAR_UNIT_HPP

(

polarization_density

)

SCALAR_UNIT_HPP() [62/88]

scifir::SCALAR_UNIT_HPP

(

power

)

SCALAR_UNIT_HPP() [63/88]

scifir::SCALAR_UNIT_HPP

(

power_density

)

SCALAR_UNIT_HPP() [64/88]

scifir::SCALAR_UNIT_HPP

(

radiance

)

SCALAR_UNIT_HPP() [65/88]

scifir::SCALAR_UNIT_HPP

(

radiant_intensity

)

SCALAR_UNIT_HPP() [66/88]

scifir::SCALAR_UNIT_HPP

(

radioactivity

)

SCALAR_UNIT_HPP() [67/88]

scifir::SCALAR_UNIT_HPP

(

resistance

)

SCALAR_UNIT_HPP() [68/88]

scifir::SCALAR_UNIT_HPP

(

resistivity

)

SCALAR_UNIT_HPP() [69/88]

scifir::SCALAR_UNIT_HPP

(

sound_power

)

SCALAR_UNIT_HPP() [70/88]

scifir::SCALAR_UNIT_HPP

(

specific_energy

)

SCALAR_UNIT_HPP() [71/88]

scifir::SCALAR_UNIT_HPP

(

specific_entropy

)

SCALAR_UNIT_HPP() [72/88]

scifir::SCALAR_UNIT_HPP

(

specific_heat_capacity

)

SCALAR_UNIT_HPP() [73/88]

scifir::SCALAR_UNIT_HPP

(

specific_volume

)

SCALAR_UNIT_HPP() [74/88]

scifir::SCALAR_UNIT_HPP

(

spectral_radiance

)

SCALAR_UNIT_HPP() [75/88]

scifir::SCALAR_UNIT_HPP

(

stiffness

)

SCALAR_UNIT_HPP() [76/88]

scifir::SCALAR_UNIT_HPP

(

surface_charge_density

)

SCALAR_UNIT_HPP() [77/88]

scifir::SCALAR_UNIT_HPP

(

temperature

)

SCALAR_UNIT_HPP() [78/88]

scifir::SCALAR_UNIT_HPP

(

thermal_conductivity

)

SCALAR_UNIT_HPP() [79/88]

scifir::SCALAR_UNIT_HPP

(

thermal_diffusivity

)

SCALAR_UNIT_HPP() [80/88]

scifir::SCALAR_UNIT_HPP

(

thermal_expansion_coefficient

)

SCALAR_UNIT_HPP() [81/88]

scifir::SCALAR_UNIT_HPP

(

thermal_resistance

)

SCALAR_UNIT_HPP() [82/88]

scifir::SCALAR_UNIT_HPP

(

transfer_speed

)

SCALAR_UNIT_HPP() [83/88]

scifir::SCALAR_UNIT_HPP

(

viscosity

)

SCALAR_UNIT_HPP() [84/88]

scifir::SCALAR_UNIT_HPP

(

voltage

)

SCALAR_UNIT_HPP() [85/88]

scifir::SCALAR_UNIT_HPP

(

volume_4d

)

SCALAR_UNIT_HPP() [86/88]

scifir::SCALAR_UNIT_HPP

(

volume_charge_density

)

SCALAR_UNIT_HPP() [87/88]

scifir::SCALAR_UNIT_HPP

(

volumetric_flow

)

SCALAR_UNIT_HPP() [88/88]

scifir::SCALAR_UNIT_HPP

(

wavenumber

)

SCALAR_UNIT_HPP_BEGIN() [1/4]

scifir::SCALAR_UNIT_HPP_BEGIN

(

area

)

SCALAR_UNIT_HPP_BEGIN() [2/4]

scifir::SCALAR_UNIT_HPP_BEGIN

(

mass

)

SCALAR_UNIT_HPP_BEGIN() [3/4]

scifir::SCALAR_UNIT_HPP_BEGIN

(

mole

)

SCALAR_UNIT_HPP_BEGIN() [4/4]

scifir::SCALAR_UNIT_HPP_BEGIN

(

volume

)

SCALAR_UNIT_HPP_END()

scifir::SCALAR_UNIT_HPP_END

(

)

sin()

float scifir::sin

(

const angle &

x

)

Calculates the sin of angle x. It uses the sin() function of the standard library of C++, the difference is that angle is in degrees, not in radians.

Definition at line 426 of file angle.cpp.

    {
        return std::sin(x.get_radian());
    }

sinh()

float scifir::sinh

(

const angle &

x

)

Calculates the sinh of angle x. It uses the sinh() function of the standard library of C++, the difference is that angle is in degrees, not in radians.

Definition at line 461 of file angle.cpp.

    {
        return std::sinh(x.get_radian());
    }

spherical_to_cartesian_3d_x() [1/2]

scalar_unit scifir::spherical_to_cartesian_3d_x ( const scalar_unit &  r, const angle &  theta, const angle &  phi  )

inline

Returns the x coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.

Definition at line 763 of file coordinates_3d.hpp.

    {
        return r * scifir::cos(theta) * scifir::sin(phi);
    }

spherical_to_cartesian_3d_x() [2/2]

float scifir::spherical_to_cartesian_3d_x ( float  r, const angle &  theta, const angle &  phi  )

inline

Returns the x coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.

Definition at line 855 of file coordinates_3d.hpp.

    {
        return r * scifir::cos(theta) * scifir::sin(phi);
    }

spherical_to_cartesian_3d_y() [1/2]

scalar_unit scifir::spherical_to_cartesian_3d_y ( const scalar_unit &  r, const angle &  theta, const angle &  phi  )

inline

Returns the y coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.

Definition at line 768 of file coordinates_3d.hpp.

    {
        return r * scifir::sin(theta) * scifir::sin(phi);
    }

spherical_to_cartesian_3d_y() [2/2]

float scifir::spherical_to_cartesian_3d_y ( float  r, const angle &  theta, const angle &  phi  )

inline

Returns the y coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.

Definition at line 860 of file coordinates_3d.hpp.

    {
        return r * scifir::sin(theta) * scifir::sin(phi);
    }

spherical_to_cartesian_3d_z() [1/2]

scalar_unit scifir::spherical_to_cartesian_3d_z ( const scalar_unit &  r, const angle &  theta, const angle &  phi  )

inline

Returns the z coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.

Definition at line 773 of file coordinates_3d.hpp.

    {
        return r * scifir::cos(phi);
    }

spherical_to_cartesian_3d_z() [2/2]

float scifir::spherical_to_cartesian_3d_z ( float  r, const angle &  theta, const angle &  phi  )

inline

Returns the z coordinate of the cartesian coordinates in 3D given the r, theta and phi of spherical coordinates.

Definition at line 865 of file coordinates_3d.hpp.

    {
        return r * scifir::cos(phi);
    }

spherical_to_cylindrical_p() [1/2]

scalar_unit scifir::spherical_to_cylindrical_p ( const scalar_unit &  r, const angle &  theta, const angle &  phi  )

inline

Returns the p coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.

Definition at line 778 of file coordinates_3d.hpp.

    {
        return r * scifir::sin(phi);
    }

spherical_to_cylindrical_p() [2/2]

float scifir::spherical_to_cylindrical_p ( float  r, const angle &  theta, const angle &  phi  )

inline

Returns the p coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.

Definition at line 870 of file coordinates_3d.hpp.

    {
        return r * scifir::sin(phi);
    }

spherical_to_cylindrical_theta() [1/2]

angle scifir::spherical_to_cylindrical_theta ( const scalar_unit &  r, const angle &  theta, const angle &  phi  )

inline

Returns the theta coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.

Definition at line 783 of file coordinates_3d.hpp.

    {
        return theta;
    }

spherical_to_cylindrical_theta() [2/2]

angle scifir::spherical_to_cylindrical_theta ( float  r, const angle &  theta, const angle &  phi  )

inline

Returns the theta coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.

Definition at line 875 of file coordinates_3d.hpp.

    {
        return theta;
    }

spherical_to_cylindrical_z() [1/2]

scalar_unit scifir::spherical_to_cylindrical_z ( const scalar_unit &  r, const angle &  theta, const angle &  phi  )

inline

Returns the z coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.

Definition at line 788 of file coordinates_3d.hpp.

    {
        return r * scifir::cos(phi);
    }

spherical_to_cylindrical_z() [2/2]

float scifir::spherical_to_cylindrical_z ( float  r, const angle &  theta, const angle &  phi  )

inline

Returns the z coordinate of the cylindrical coordinates given the r, theta and phi of spherical coordinates.

Definition at line 880 of file coordinates_3d.hpp.

    {
        return r * scifir::cos(phi);
    }

sqrt() [1/7]

angle scifir::sqrt

(

const angle &

x

)

Calculates the square root of the angle x and returns that new angle.

Definition at line 416 of file angle.cpp.

    {
        return angle(std::sqrt(x.get_value()));
    }

sqrt() [2/7]

template<typename T >

complex_number< scalar_unit > scifir::sqrt

(

const complex_number< T > &

x

)

Definition at line 192 of file complex_number.hpp.

    {
        int sgn_value;
        if (x.imaginary > 0)
        {
            sgn_value = 1;
        }
        else if (x.imaginary < 0)
        {
            sgn_value = -1;
        }
        else
        {
            sgn_value = 0;
        }
        scalar_unit new_real = scifir::sqrt(x.real + scifir::sqrt((x.real^2) + (x.imaginary^2)));
        scalar_unit new_imaginary = sgn_value * scifir::sqrt(((-1) * x.real + scifir::sqrt((x.real^2) + (x.imaginary^2))) / 2);
        return complex_number<scalar_unit>(new_real,new_imaginary);
    }

sqrt() [3/7]

pixel scifir::sqrt

(

const pixel &

x

)

Definition at line 238 of file pixel.cpp.

    {
        return pixel(std::sqrt(x.get_value()));
    }

sqrt() [4/7]

scalar_unit scifir::sqrt

(

const scalar_unit &

x

)

Square root of a scalar_unit, it squares the dimensions too.

Definition at line 947 of file scalar_unit.cpp.

    {
        long double new_value = x.get_value();
        vector<dimension> new_dimensions = square_dimensions(x.get_dimensions(), 2, new_value);
        new_value = std::sqrt(new_value);
        return scalar_unit(new_value, new_dimensions);
    }

sqrt() [5/7]

vector_unit_2d scifir::sqrt

(

const vector_unit_2d &

x

)

It squares the vector, creating a vector_unit_2d with the value squared and always the same theta. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.

Definition at line 350 of file vector_unit_2d.cpp.

    {
        scalar_unit new_value = scifir::sqrt(scalar_unit(x));
        return vector_unit_2d(new_value, x.theta);
    }

sqrt() [6/7]

vector_unit_3d scifir::sqrt

(

const vector_unit_3d &

x

)

It squares the vector, creating a vector_unit_3d with the value squared and always the same theta and the same phi. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.

Definition at line 455 of file vector_unit_3d.cpp.

    {
        scalar_unit new_value = scifir::sqrt(scalar_unit(x));
        return vector_unit_3d(new_value, x.theta, x.phi);
    }

sqrt() [7/7]

vector_unit_nd scifir::sqrt

(

const vector_unit_nd &

x

)

It squares the vector, creating a vector_unit_nd with the value squared and always the same angles. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.

Definition at line 791 of file vector_unit_nd.cpp.

    {
        scalar_unit new_value = scifir::sqrt(scalar_unit(x));
        return vector_unit_nd(new_value, x.angles);
    }

sqrt_nth() [1/6]

angle scifir::sqrt_nth	(	const angle &	x,
		int	index
	)

Calculates the nth root of the angle x and returns that new angle.

Definition at line 421 of file angle.cpp.

    {
        return angle(std::pow(x.get_value(), float(1.0f / index)));
    }

sqrt_nth() [2/6]

pixel scifir::sqrt_nth	(	const pixel &	x,
		int	index
	)

Definition at line 243 of file pixel.cpp.

    {
        return pixel(std::pow(x.get_value(), 1.0f / index));
    }

sqrt_nth() [3/6]

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.

Definition at line 955 of file scalar_unit.cpp.

    {
        long double new_value = x.get_value();
        vector<dimension> new_dimensions = square_dimensions(x.get_dimensions(), index, new_value);
        new_value = std::pow(new_value, 1.0f / index);
        return scalar_unit(new_value, new_dimensions);
    }

sqrt_nth() [4/6]

vector_unit_2d scifir::sqrt_nth	(	const vector_unit_2d &	x,
		int	index
	)

It takes the root of the vector with the index given, creating a vector_unit_2d with the value rooted to that index and always maintains the same theta. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.

Definition at line 356 of file vector_unit_2d.cpp.

    {
        scalar_unit new_value = scifir::sqrt_nth(scalar_unit(x), index);
        return vector_unit_2d(new_value, x.theta);
    }

sqrt_nth() [5/6]

vector_unit_3d scifir::sqrt_nth	(	const vector_unit_3d &	x,
		int	index
	)

It takes the root of the vector with the index given, creating a vector_unit_3d with the value rooted to that index and always maintains the same theta and the same phi. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.

Definition at line 461 of file vector_unit_3d.cpp.

    {
        scalar_unit new_value = scifir::sqrt_nth(scalar_unit(x), index);
        return vector_unit_3d(new_value, x.theta, x.phi);
    }

sqrt_nth() [6/6]

vector_unit_nd scifir::sqrt_nth	(	const vector_unit_nd &	x,
		int	index
	)

It takes the root of the vector with the index given, creating a vector_unit_nd with the value rooted to that index and always maintains the same angles. The dimensions are squared with the same rules for the square of dimensions than scalar_unit classes.

Definition at line 797 of file vector_unit_nd.cpp.

    {
        scalar_unit new_value = scifir::sqrt_nth(scalar_unit(x), index);
        return vector_unit_nd(new_value, x.angles);
    }

square_dimensions()

vector< dimension > scifir::square_dimensions	(	vector< dimension >	x,
		int	index,
		long double &	value
	)

Squares a vector of dimensions by an index. The value is updated too related to the prefix math and the conversion factor of this operation.

Definition at line 2118 of file dimension.cpp.

    {
        map<dimension::type,int> dimensions_count = map<dimension::type,int>();
        for (const dimension& x_dimension : x)
        {
            dimensions_count[x_dimension.dimension_type]++;
        }
        for (const auto& x_count : dimensions_count)
        {
            if ((x_count.second % index) != 0)
            {
                return vector<dimension>();
            }
        }
        vector<dimension> new_dimensions = vector<dimension>();
        if (dimensions_count.size() == 1) // If there's only one type of dimension, square it and conserve its type
        {
            for (int i = 0; i < dimensions_count[x[0].dimension_type]; i++)
            {
                if (x[i].dimension_position == dimension::NUMERATOR)
                {
                    value *= x[i].get_conversion_factor();
                    value *= x[i].prefix_math();
                }
                else if (x[i].dimension_position == dimension::DENOMINATOR)
                {
                    value /= x[i].get_conversion_factor();
                    value /= x[i].prefix_math();
                }
            }
            int total_dimensions = int(std::pow(dimensions_count[x[0].dimension_type], 1.0f / index));
            x[0].prefix.prefix_type = prefix::NONE;
            for (int j = 0; j < total_dimensions; j++)
            {
                new_dimensions.push_back(x[0]);
            }
            return new_dimensions;
        }
        else // If there's more than one type of dimension, creates the simple dimensions of them, and squares the total. If there are special names, they are changed by their simple dimensions
        {
            x = normalize_dimensions(x,value);
            vector<dimension::type> counted_dimensions = vector<dimension::type>();
            dimensions_count.clear();
            for (const dimension& x_dimension : x)
            {
                dimensions_count[x_dimension.dimension_type]++;
            }
            for (const dimension& x_dimension : x)
            {
                bool counted = false;
                for (const dimension::type& counted_dimension : counted_dimensions)
                {
                    if (counted_dimension == x_dimension.dimension_type)
                    {
                        counted = true;
                    }
                }
                if (counted == true)
                {
                    continue;
                }
                int total_dimensions = int(std::pow(dimensions_count[x_dimension.dimension_type], 1.0f / index));
                for (int j = 0; j < total_dimensions; j++)
                {
                    new_dimensions.push_back(x_dimension);
                }
                counted_dimensions.push_back(x_dimension.dimension_type);
            }
        }
        return new_dimensions;
    }

tan()

float scifir::tan

(

const angle &

x

)

Calculates the tan of angle x. It uses the tan() function of the standard library of C++, the difference is that angle is in degrees, not in radians.

Definition at line 436 of file angle.cpp.

    {
        return std::tan(x.get_radian());
    }

tanh()

float scifir::tanh

(

const angle &

x

)

Calculates the tanh of angle x. It uses the tanh() function of the standard library of C++, the difference is that angle is in degrees, not in radians.

Definition at line 471 of file angle.cpp.

    {
        return std::tanh(x.get_radian());
    }

to_latex()

string scifir::to_latex	(	const vector< dimension > &	x_dimensions,
		bool	with_brackets
	)

Definition at line 1782 of file dimension.cpp.

    {
        ostringstream out;
        bool is_fraction = false;
        if (x_dimensions.size() > 0)
        {
            vector<dimension::type> printed_dimensions = vector<dimension::type>();
            map<prefix,int> counted_prefixes = map<prefix,int>();
            bool first_print = true;
            for (const dimension& x_dimension : x_dimensions)
            {
                if (x_dimension.dimension_position == dimension::NUMERATOR)
                {
                    bool printed = false;
                    for (const dimension::type& print_dimension : printed_dimensions)
                    {
                        if (print_dimension == x_dimension.dimension_type)
                        {
                            printed = true;
                        }
                    }
                    if (printed == true)
                    {
                        continue;
                    }
                    counted_prefixes = map<prefix,int>();
                    for (const dimension& y_dimension : x_dimensions)
                    {
                        if (x_dimension.dimension_type == y_dimension.dimension_type)
                        {
                            counted_prefixes[y_dimension.prefix]++;
                        }
                    }
                    for (const auto& x_prefix : counted_prefixes)
                    {
                        if (!first_print)
                        {
                            out << "*";
                        }
                        out << x_prefix.first << x_dimension.get_symbol();
                        if (x_prefix.second > 1)
                        {
                            out << "^" << x_prefix.second;
                        }
                        first_print = false;
                    }
                    printed_dimensions.push_back(x_dimension.dimension_type);
                }
            }
            printed_dimensions.clear();
            bool first_negative_iteration = true;
            bool first_negative_prefix = true;
            for (const dimension& x_dimension : x_dimensions)
            {
                if (x_dimension.dimension_position == dimension::DENOMINATOR)
                {
                    is_fraction = true;
                    if (first_negative_iteration == true)
                    {
                        if (first_print)
                        {
                            out << "1";
                        }
                        out << "}{";
                        first_negative_iteration = false;
                    }
                    bool printed = false;
                    for (const dimension::type& print_dimension : printed_dimensions)
                    {
                        if (print_dimension == x_dimension.dimension_type)
                        {
                            printed = true;
                        }
                    }
                    if (printed == true)
                    {
                        continue;
                    }
                    counted_prefixes = map<prefix,int>();
                    for (const dimension& y_dimension : x_dimensions)
                    {
                        if (x_dimension.dimension_type == y_dimension.dimension_type)
                        {
                            counted_prefixes[y_dimension.prefix]++;
                        }
                    }
                    for (const auto& x_prefix : counted_prefixes)
                    {
                        if (first_negative_prefix == false)
                        {
                            out << "*";
                        }
                        out << x_prefix.first << x_dimension.get_symbol();
                        if (x_prefix.second > 1)
                        {
                            out << "^" << x_prefix.second;
                        }
                        first_negative_prefix = false;
                    }
                    printed_dimensions.push_back(x_dimension.dimension_type);
                }
            }
            if (is_fraction)
            {
                out << "}";
            }
            if (with_brackets)
            {
                out << "]";
            }
        }
        else
        {
            out << "[empty]";
        }
        if (is_fraction)
        {
            if (with_brackets)
            {
                return "[\frac{" + out.str();
            }
            else
            {
                return "\frac{" + out.str();
            }
        }
        else
        {
            if (with_brackets)
            {
                return "[" + out.str();
            }
            else
            {
                return out.str();
            }
        }
    }

to_string() [1/38]

string scifir::to_string

(

cardinale_point

x

)

Definition at line 7 of file coordinates_3d.cpp.

    {
        switch(x)
        {
            case cardinale_point::NORTH:
                return "NORTH";
            case cardinale_point::SOUTH:
                return "SOUTH";
            case cardinale_point::EAST:
                return "EAST";
            case cardinale_point::WEST:
                return "WEST";
        }
        return "";
    }

to_string() [2/38]

string scifir::to_string

(

const aid &

x

)

Creates a string representation of aid, it's for aid equivalent to the display() function of aid.

Definition at line 582 of file aid.cpp.

    {
        return x.display();
    }

to_string() [3/38]

string scifir::to_string

(

const aid::type &

x

)

Converts a value of the enum aid::type to its string representation, which can be a single or a pair of letters. The value UNIVERSE returns U. The value GALAXY returns G. The value SOLAR_SYSTEM returns SS. The value PLANET returns P. The value STAR returns ST. The value ASTEROID returns A. The value MOON returns MN. The value METEOR returns MT. The value NONE returns an empty string.

Definition at line 587 of file aid.cpp.

    {
        switch (x)
        {
            case aid::UNIVERSE:
                return "U";
            case aid::GALAXY:
                return "G";
            case aid::SOLAR_SYSTEM:
                return "SS";
            case aid::PLANET:
                return "P";
            case aid::STAR:
                return "ST";
            case aid::ASTEROID:
                return "A";
            case aid::MOON:
                return "MN";
            case aid::METEOR:
                return "MT";
            case aid::NONE:
                return "";
        }
        return "";
    }

to_string() [4/38]

string scifir::to_string

(

const angle &

x

)

Converts an angle to their string representation.

Definition at line 331 of file angle.cpp.

    {
        return x.display(2);
    }

to_string() [5/38]

template<typename T >

string scifir::to_string

(

const complex_number< T > &

x

)

Definition at line 178 of file complex_number.hpp.

    {
        return x.display(2);
    }

to_string() [6/38]

string scifir::to_string

(

const coordinates_1d< float > &

x

)

Definition at line 8 of file coordinates_1d.cpp.

    {
        return x.display_cartesian();
    }

to_string() [7/38]

template<typename T >

string scifir::to_string

(

const coordinates_1d< T > &

x

)

Definition at line 183 of file coordinates_1d.hpp.

    {
        return x.display_cartesian();
    }

to_string() [8/38]

string scifir::to_string

(

const coordinates_2d< float > &

x

)

Definition at line 9 of file coordinates_2d.cpp.

    {
        return x.display_cartesian();
    }

to_string() [9/38]

template<typename T >

string scifir::to_string

(

const coordinates_2d< T > &

x

)

Definition at line 339 of file coordinates_2d.hpp.

    {
        return x.display_cartesian();
    }

to_string() [10/38]

string scifir::to_string

(

const coordinates_2dr< float > &

x

)

Definition at line 7 of file coordinates_2dr.cpp.

    {
        return x.display_cartesian();
    }

to_string() [11/38]

template<typename T >

string scifir::to_string

(

const coordinates_2dr< T > &

x

)

Definition at line 456 of file coordinates_2dr.hpp.

    {
        return x.display_cartesian();
    }

to_string() [12/38]

string scifir::to_string

(

const coordinates_3d< float > &

x

)

Returns the string representation of coordinates_3d<float>.

Definition at line 23 of file coordinates_3d.cpp.

    {
        return x.display_cartesian();
    }

to_string() [13/38]

template<typename T >

string scifir::to_string

(

const coordinates_3d< T > &

x

)

Returns the string representation of coordinates_3d.

Definition at line 709 of file coordinates_3d.hpp.

    {
        return x.display_cartesian();
    }

to_string() [14/38]

string scifir::to_string

(

const coordinates_3dr< float > &

x

)

Definition at line 7 of file coordinates_3dr.cpp.

    {
        return x.display_cartesian();
    }

to_string() [15/38]

template<typename T >

string scifir::to_string

(

const coordinates_3dr< T > &

x

)

Definition at line 900 of file coordinates_3dr.hpp.

    {
        return x.display_cartesian();
    }

to_string() [16/38]

string scifir::to_string

(

const coordinates_nd< float > &

x

)

Definition at line 7 of file coordinates_nd.cpp.

    {
        if (x.values.size() > 0)
        {
            ostringstream out;
            out << "(";
            for (int i = 0; i < x.values.size(); i++)
            {
                out << display_float(x.values[i]);
                if ((i + 1) != x.values.size())
                {
                    out << ",";
                }
            }
            out << ")";
            return out.str();
        }
        else
        {
            return "[empty]";
        }
    }

to_string() [17/38]

template<typename T >

string scifir::to_string

(

const coordinates_nd< T > &

x

)

Definition at line 1134 of file coordinates_nd.hpp.

    {
        if (x.values.size() > 0)
        {
            ostringstream out;
            out << "(";
            for (int i = 0; i < x.values.size(); i++)
            {
                out << x.values[i];
                if ((i + 1) != x.values.size())
                {
                    out << ",";
                }
            }
            out << ")";
            return out.str();
        }
        else
        {
            return "[empty]";
        }
    }

to_string() [18/38]

string scifir::to_string

(

const coordinates_ndr< float > &

x

)

Definition at line 10 of file coordinates_ndr.cpp.

    {
        if (x.get_values().size() > 0)
        {
            ostringstream out;
            out << "(";
            if (x.get_values().size() > 0)
            {
                for (int i = 0; i < x.get_values().size(); i++)
                {
                    out << display_float(x.get_value(i));
                    if ((i + 1) != x.get_values().size())
                    {
                        out << ",";
                    }
                }
            }
            if (x.get_angles().size() > 0)
            {
                out << ";";
                for (int i = 0; i < x.get_angles().size(); i++)
                {
                    out << x.get_angle(i);
                    if ((i + 1) != x.get_angles().size())
                    {
                        out << ",";
                    }
                }
            }
            out << ")";
            return out.str();
        }
        else
        {
            return "[empty]";
        }
    }

to_string() [19/38]

template<typename T >

string scifir::to_string

(

const coordinates_ndr< T > &

x

)

Definition at line 2150 of file coordinates_ndr.hpp.

    {
        if (x.get_values().size() > 0)
        {
            ostringstream out;
            out << "(";
            if (x.get_values().size() > 0)
            {
                for (int i = 0; i < x.get_values().size(); i++)
                {
                    out << x.get_value(i);
                    if ((i + 1) != x.get_values().size())
                    {
                        out << ",";
                    }
                }
            }
            if (x.get_angles().size() > 0)
            {
                out << ";";
                for (int i = 0; i < x.get_angles().size(); i++)
                {
                    out << x.get_angle(i);
                    if ((i + 1) != x.get_angles().size())
                    {
                        out << ",";
                    }
                }
            }
            out << ")";
            return out.str();
        }
        else
        {
            return "[empty]";
        }
    }

to_string() [20/38]

string scifir::to_string

(

const dimension &

x

)

Creates the string representation of a dimension.

Definition at line 1659 of file dimension.cpp.

    {
        ostringstream out;
        out << x.prefix << x.get_symbol();
        return out.str();
    }

to_string() [21/38]

string scifir::to_string

(

const direction &

x

)

Definition at line 341 of file direction.cpp.

    {
        return to_string(x.value);
    }

to_string() [22/38]

template<typename T >

string scifir::to_string

(

const lab_number< T > &

x

)

Definition at line 114 of file lab_number.hpp.

    {
        return x.display(2);
    }

to_string() [23/38]

string scifir::to_string

(

const percentage &

x

)

Returns a string representation of percentage x.

Definition at line 483 of file percentage.cpp.

    {
        return x.display_percentage();
    }

to_string() [24/38]

string scifir::to_string

(

const pixel &

x

)

Definition at line 196 of file pixel.cpp.

    {
        return x.display();
    }

to_string() [25/38]

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.

Parameters

x	scalar_unit to generate the string.

Definition at line 740 of file scalar_unit.cpp.

    {
        return x.display(2);
    }

to_string() [26/38]

string scifir::to_string

(

const size_2d< float > &

x

)

Returns a string representation of size_2d<float>.

Definition at line 7 of file size_2d.cpp.

    {
        return x.display();
    }

to_string() [27/38]

template<typename T >

string scifir::to_string

(

const size_2d< T > &

x

)

Returns a string representation of size_2d<T>.

Definition at line 212 of file size_2d.hpp.

    {
        return x.display();
    }

to_string() [28/38]

string scifir::to_string

(

const size_3d< float > &

x

)

Returns a string representation of size_3d<float>.

Definition at line 7 of file size_3d.cpp.

    {
        return x.display();
    }

to_string() [29/38]

template<typename T >

string scifir::to_string

(

const size_3d< T > &

x

)

Returns a string representation of size_3d<T>.

Definition at line 226 of file size_3d.hpp.

    {
        return x.display();
    }

to_string() [30/38]

string scifir::to_string

(

const size_nd< float > &

x

)

Definition at line 7 of file size_nd.cpp.

    {
        return x.display();
    }

to_string() [31/38]

template<typename T >

string scifir::to_string

(

const size_nd< T > &

x

)

Definition at line 350 of file size_nd.hpp.

    {
        return x.display();
    }

to_string() [32/38]

string scifir::to_string	(	const vector< dimension > &	x_dimensions,
		bool	with_brackets = false
	)

Creates the string representation of a vector of dimensions. Used to display the dimensions of scalar_unit and all vector_unit classes. The dimensions can be displayed optionally between brackets like '[]' too.

Definition at line 1666 of file dimension.cpp.

    {
        ostringstream out;
        if (x_dimensions.size() > 0)
        {
            if (with_brackets)
            {
                out << "[";
            }
            vector<dimension::type> printed_dimensions = vector<dimension::type>();
            map<prefix,int> counted_prefixes = map<prefix,int>();
            bool first_print = true;
            for (const dimension& x_dimension : x_dimensions)
            {
                if (x_dimension.dimension_position == dimension::NUMERATOR)
                {
                    bool printed = false;
                    for (const dimension::type& print_dimension : printed_dimensions)
                    {
                        if (print_dimension == x_dimension.dimension_type)
                        {
                            printed = true;
                        }
                    }
                    if (printed == true)
                    {
                        continue;
                    }
                    counted_prefixes = map<prefix,int>();
                    for (const dimension& y_dimension : x_dimensions)
                    {
                        if (x_dimension.dimension_type == y_dimension.dimension_type)
                        {
                            counted_prefixes[y_dimension.prefix]++;
                        }
                    }
                    for (const auto& x_prefix : counted_prefixes)
                    {
                        if (!first_print)
                        {
                            out << "*";
                        }
                        out << x_prefix.first << x_dimension.get_symbol();
                        if (x_prefix.second > 1)
                        {
                            out << x_prefix.second;
                        }
                        first_print = false;
                    }
                    printed_dimensions.push_back(x_dimension.dimension_type);
                }
            }
            printed_dimensions.clear();
            bool first_negative_iteration = true;
            bool first_negative_prefix = true;
            for (const dimension& x_dimension : x_dimensions)
            {
                if (x_dimension.dimension_position == dimension::DENOMINATOR)
                {
                    if (first_negative_iteration == true)
                    {
                        if (first_print)
                        {
                            out << "1";
                        }
                        out << "/";
                        first_negative_iteration = false;
                    }
                    bool printed = false;
                    for (const dimension::type& print_dimension : printed_dimensions)
                    {
                        if (print_dimension == x_dimension.dimension_type)
                        {
                            printed = true;
                        }
                    }
                    if (printed == true)
                    {
                        continue;
                    }
                    counted_prefixes = map<prefix,int>();
                    for (const dimension& y_dimension : x_dimensions)
                    {
                        if (x_dimension.dimension_type == y_dimension.dimension_type)
                        {
                            counted_prefixes[y_dimension.prefix]++;
                        }
                    }
                    for (const auto& x_prefix : counted_prefixes)
                    {
                        if (first_negative_prefix == false)
                        {
                            out << "*";
                        }
                        out << x_prefix.first << x_dimension.get_symbol();
                        if (x_prefix.second > 1)
                        {
                            out << x_prefix.second;
                        }
                        first_negative_prefix = false;
                    }
                    printed_dimensions.push_back(x_dimension.dimension_type);
                }
            }
            if (with_brackets)
            {
                out << "]";
            }
        }
        else
        {
            out << "[empty]";
        }
        return out.str();
    }

to_string() [33/38]

string scifir::to_string

(

const vector_unit_2d &

x

)

It generates a string representation of vector_unit_2d.

to_string() [34/38]

string scifir::to_string

(

const vector_unit_3d &

x

)

It generates a string representation of vector_unit_3d.

to_string() [35/38]

string scifir::to_string

(

const vector_unit_nd &

x

)

It generates a string representation of vector_unit_nd.

Definition at line 781 of file vector_unit_nd.cpp.

    {
        return x.vectorial_display(2);
    }

to_string() [36/38]

string scifir::to_string

(

const zid &

x

)

Returns a string representation of zid, same as display().

Definition at line 288 of file zid.cpp.

    {
        return x.display();
    }

to_string() [37/38]

string scifir::to_string

(

const zid::type &

x

)

Converts a value of the enum zid::type to its string representation, which is a single letter. The value COUNTRY returns C. The value REGION returns R. The value SETTLEMENT returns S. The value ZONE returns Z.

Definition at line 293 of file zid.cpp.

    {
        switch (x)
        {
            case zid::NONE:
                return "";
            case zid::COUNTRY:
                return "C";
            case zid::REGION:
                return "R";
            case zid::SETTLEMENT:
                return "S";
            case zid::ZONE:
                return "Z";
        }
        return "";
    }

to_string() [38/38]

string scifir::to_string

(

direction::name

x

)

Definition at line 279 of file direction.cpp.

    {
        switch (x)
        {
            case direction::NONE:
                return "";
            case direction::LEFT:
                return "left";
            case direction::RIGHT:
                return "right";
            case direction::TOP:
                return "top";
            case direction::BOTTOM:
                return "bottom";
            case direction::FRONT:
                return "front";
            case direction::BACK:
                return "back";
            case direction::LEFT_TOP:
                return "left-top";
            case direction::LEFT_BOTTOM:
                return "left-bottom";
            case direction::RIGHT_TOP:
                return "right-top";
            case direction::RIGHT_BOTTOM:
                return "right-bottom";
            case direction::LEFT_FRONT:
                return "left-front";
            case direction::LEFT_BACK:
                return "left-back";
            case direction::RIGHT_FRONT:
                return "right-front";
            case direction::RIGHT_BACK:
                return "right-back";
            case direction::TOP_FRONT:
                return "top-front";
            case direction::TOP_BACK:
                return "top-back";
            case direction::BOTTOM_FRONT:
                return "bottom-front";
            case direction::BOTTOM_BACK:
                return "bottom-back";
            case direction::LEFT_TOP_FRONT:
                return "left-top-front";
            case direction::LEFT_TOP_BACK:
                return "left-top-back";
            case direction::LEFT_BOTTOM_FRONT:
                return "left-bottom-front";
            case direction::LEFT_BOTTOM_BACK:
                return "left-bottom-back";
            case direction::RIGHT_TOP_FRONT:
                return "right-top-front";
            case direction::RIGHT_TOP_BACK:
                return "right-top-back";
            case direction::RIGHT_BOTTOM_FRONT:
                return "right-bottom-front";
            case direction::RIGHT_BOTTOM_BACK:
                return "right-bottom-back";
        }
        return "";
    }

turn_to_degree()

float scifir::turn_to_degree ( float  x )

inline

Definition at line 26 of file angle.hpp.

    {
        return x * 360.0f;
    }

turn_to_gradian()

float scifir::turn_to_gradian ( float  x )

inline

Definition at line 56 of file angle.hpp.

    {
        return x * 400.f;
    }

turn_to_radian()

float scifir::turn_to_radian ( float  x )

inline

Definition at line 41 of file angle.hpp.

    {
        return x * 2 * std::numbers::pi_v<float>;
    }

VECTOR_UNIT_2D_CPP()

scifir::VECTOR_UNIT_2D_CPP	(	displacement	,
		"m"
	)

VECTOR_UNIT_2D_HPP()

scifir::VECTOR_UNIT_2D_HPP

(

displacement

)

VECTOR_UNIT_3D_CPP()

scifir::VECTOR_UNIT_3D_CPP	(	displacement	,
		"m"
	)

VECTOR_UNIT_3D_HPP()

scifir::VECTOR_UNIT_3D_HPP

(

displacement

)

VECTOR_UNIT_CPP() [1/26]

scifir::VECTOR_UNIT_CPP	(	acceleration	,
		"m/s2"
	)

VECTOR_UNIT_CPP() [2/26]

scifir::VECTOR_UNIT_CPP	(	angular_acceleration	,
		"rad/s2"
	)

VECTOR_UNIT_CPP() [3/26]

scifir::VECTOR_UNIT_CPP	(	angular_momentum	,
		"m2*kg/s"
	)

VECTOR_UNIT_CPP() [4/26]

scifir::VECTOR_UNIT_CPP	(	angular_velocity	,
		"rad/s"
	)

VECTOR_UNIT_CPP() [5/26]

scifir::VECTOR_UNIT_CPP	(	electric_displacement_field	,
		"C/m2"
	)

VECTOR_UNIT_CPP() [6/26]

scifir::VECTOR_UNIT_CPP	(	electric_field_strength	,
		"V/m"
	)

VECTOR_UNIT_CPP() [7/26]

scifir::VECTOR_UNIT_CPP	(	force	,
		"N"
	)

VECTOR_UNIT_CPP() [8/26]

scifir::VECTOR_UNIT_CPP	(	impulse	,
		"m*kg/s"
	)

VECTOR_UNIT_CPP() [9/26]

scifir::VECTOR_UNIT_CPP	(	irradiance	,
		"kg/s3"
	)

VECTOR_UNIT_CPP() [10/26]

scifir::VECTOR_UNIT_CPP	(	jerk	,
		"m/s3"
	)

VECTOR_UNIT_CPP() [11/26]

scifir::VECTOR_UNIT_CPP	(	magnetic_flux_density	,
		"T"
	)

VECTOR_UNIT_CPP() [12/26]

scifir::VECTOR_UNIT_CPP	(	magnetic_moment	,
		"Wb*m"
	)

VECTOR_UNIT_CPP() [13/26]

scifir::VECTOR_UNIT_CPP	(	magnetic_vector_potential	,
		"Wb/m"
	)

VECTOR_UNIT_CPP() [14/26]

scifir::VECTOR_UNIT_CPP	(	magnetomotive_force	,
		"A*rad"
	)

VECTOR_UNIT_CPP() [15/26]

scifir::VECTOR_UNIT_CPP	(	momentum	,
		"kg*m/s"
	)

VECTOR_UNIT_CPP() [16/26]

scifir::VECTOR_UNIT_CPP	(	pressure	,
		"Pa"
	)

VECTOR_UNIT_CPP() [17/26]

scifir::VECTOR_UNIT_CPP	(	radiant_exposure	,
		"kg/s2"
	)

VECTOR_UNIT_CPP() [18/26]

scifir::VECTOR_UNIT_CPP	(	radiant_flux	,
		"kg*m2/s3"
	)

VECTOR_UNIT_CPP() [19/26]

scifir::VECTOR_UNIT_CPP	(	snap	,
		"m/s4"
	)

VECTOR_UNIT_CPP() [20/26]

scifir::VECTOR_UNIT_CPP	(	specific_angular_momentum	,
		"m2/s"
	)

VECTOR_UNIT_CPP() [21/26]

scifir::VECTOR_UNIT_CPP	(	spectral_flux	,
		"kg*m/s3"
	)

VECTOR_UNIT_CPP() [22/26]

scifir::VECTOR_UNIT_CPP	(	surface_tension	,
		"kg/s2"
	)

VECTOR_UNIT_CPP() [23/26]

scifir::VECTOR_UNIT_CPP	(	temperature_gradient	,
		"K/m"
	)

VECTOR_UNIT_CPP() [24/26]

scifir::VECTOR_UNIT_CPP	(	torque	,
		"kg*m2/s2"
	)

VECTOR_UNIT_CPP() [25/26]

scifir::VECTOR_UNIT_CPP	(	velocity	,
		"m/s"
	)

VECTOR_UNIT_CPP() [26/26]

scifir::VECTOR_UNIT_CPP	(	yank	,
		"N/s"
	)

VECTOR_UNIT_HPP() [1/26]

scifir::VECTOR_UNIT_HPP

(

acceleration

)

VECTOR_UNIT_HPP() [2/26]

scifir::VECTOR_UNIT_HPP

(

angular_acceleration

)

VECTOR_UNIT_HPP() [3/26]

scifir::VECTOR_UNIT_HPP

(

angular_momentum

)

VECTOR_UNIT_HPP() [4/26]

scifir::VECTOR_UNIT_HPP

(

angular_velocity

)

VECTOR_UNIT_HPP() [5/26]

scifir::VECTOR_UNIT_HPP

(

electric_displacement_field

)

VECTOR_UNIT_HPP() [6/26]

scifir::VECTOR_UNIT_HPP

(

electric_field_strength

)

VECTOR_UNIT_HPP() [7/26]

scifir::VECTOR_UNIT_HPP

(

force

)

VECTOR_UNIT_HPP() [8/26]

scifir::VECTOR_UNIT_HPP

(

impulse

)

VECTOR_UNIT_HPP() [9/26]

scifir::VECTOR_UNIT_HPP

(

irradiance

)

VECTOR_UNIT_HPP() [10/26]

scifir::VECTOR_UNIT_HPP

(

jerk

)

VECTOR_UNIT_HPP() [11/26]

scifir::VECTOR_UNIT_HPP

(

magnetic_flux_density

)

VECTOR_UNIT_HPP() [12/26]

scifir::VECTOR_UNIT_HPP

(

magnetic_moment

)

VECTOR_UNIT_HPP() [13/26]

scifir::VECTOR_UNIT_HPP

(

magnetic_vector_potential

)

VECTOR_UNIT_HPP() [14/26]

scifir::VECTOR_UNIT_HPP

(

magnetomotive_force

)

VECTOR_UNIT_HPP() [15/26]

scifir::VECTOR_UNIT_HPP

(

momentum

)

VECTOR_UNIT_HPP() [16/26]

scifir::VECTOR_UNIT_HPP

(

pressure

)

VECTOR_UNIT_HPP() [17/26]

scifir::VECTOR_UNIT_HPP

(

radiant_exposure

)

VECTOR_UNIT_HPP() [18/26]

scifir::VECTOR_UNIT_HPP

(

radiant_flux

)

VECTOR_UNIT_HPP() [19/26]

scifir::VECTOR_UNIT_HPP

(

snap

)

VECTOR_UNIT_HPP() [20/26]

scifir::VECTOR_UNIT_HPP

(

specific_angular_momentum

)

VECTOR_UNIT_HPP() [21/26]

scifir::VECTOR_UNIT_HPP

(

spectral_flux

)

VECTOR_UNIT_HPP() [22/26]

scifir::VECTOR_UNIT_HPP

(

surface_tension

)

VECTOR_UNIT_HPP() [23/26]

scifir::VECTOR_UNIT_HPP

(

temperature_gradient

)

VECTOR_UNIT_HPP() [24/26]

scifir::VECTOR_UNIT_HPP

(

torque

)

VECTOR_UNIT_HPP() [25/26]

scifir::VECTOR_UNIT_HPP

(

velocity

)

VECTOR_UNIT_HPP() [26/26]

scifir::VECTOR_UNIT_HPP

(

yank

)

VECTOR_UNIT_ND_CPP()

scifir::VECTOR_UNIT_ND_CPP	(	displacement	,
		"m"
	)

VECTOR_UNIT_ND_HPP()

scifir::VECTOR_UNIT_ND_HPP

(

displacement

)

volume()

scifir::volume::volume ( const size_3d< length > &  x )

explicit

Definition at line 22 of file space_units.cpp.

                                           : scalar_unit()
    {
        length x_height = x.height;
        length x_depth = x.depth;
        x_height.change_dimensions(x.width);
        x_depth.change_dimensions(x.width);
        *this = x.width * x_height * x_depth;
    }

Variable Documentation

ATOMIC_MASS_CONSTANT

const long double scifir::ATOMIC_MASS_CONSTANT = 1.66053906660e-27

Definition at line 20 of file constants.hpp.

AVOGADRO_CONSTANT

const long double scifir::AVOGADRO_CONSTANT = 6.02214076e23

Definition at line 15 of file constants.hpp.

BOLTZMANN_CONSTANT

const long double scifir::BOLTZMANN_CONSTANT = 1.380649e-23

Definition at line 14 of file constants.hpp.

coordinates_ndr_no_angle

angle scifir::coordinates_ndr_no_angle = angle()

Definition at line 7 of file coordinates_ndr.cpp.

COULOMB_CONSTANT

const long double scifir::COULOMB_CONSTANT = 8.9875517873681764e9

Definition at line 21 of file constants.hpp.

ELEMENTARY_CHARGE

const long double scifir::ELEMENTARY_CHARGE = 1.602176634e-19

Definition at line 13 of file constants.hpp.

FARADAY_CONSTANT

const long double scifir::FARADAY_CONSTANT = 9.64853321233100184e4

Definition at line 24 of file constants.hpp.

GRAVITATIONAL_CONSTANT

const long double scifir::GRAVITATIONAL_CONSTANT = 6.6743e-11

Definition at line 18 of file constants.hpp.

HYPERFINE_TRANSITION_FREQUENCY_OF_CS

const long double scifir::HYPERFINE_TRANSITION_FREQUENCY_OF_CS = 9192631770.0l

Definition at line 10 of file constants.hpp.

LUMINOUS_EFFICACY_OF_540_THZ_RADIATION

const long double scifir::LUMINOUS_EFFICACY_OF_540_THZ_RADIATION = 683.0l

Definition at line 16 of file constants.hpp.

MOLAR_GAS_CONSTANT

const long double scifir::MOLAR_GAS_CONSTANT = 8.31446261815324l

Definition at line 19 of file constants.hpp.

PLANCK_CONSTANT

const long double scifir::PLANCK_CONSTANT = 6.62607015e-34

Definition at line 12 of file constants.hpp.

RYDBERG_CONSTANT

const long double scifir::RYDBERG_CONSTANT = 1.0973731568539e7

Definition at line 23 of file constants.hpp.

SPEED_OF_LIGHT

const long double scifir::SPEED_OF_LIGHT = 299792458.0l

Definition at line 11 of file constants.hpp.

VACUUM_PERMITTIVITY

const long double scifir::VACUUM_PERMITTIVITY = 8.8541878188e-12

Definition at line 22 of file constants.hpp.

WGS84_EARTH_SEMIAXIS_A

const scalar_unit scifir::WGS84_EARTH_SEMIAXIS_A = 6378137_m

Definition at line 9 of file constants.cpp.

WGS84_EARTH_SEMIAXIS_B

const scalar_unit scifir::WGS84_EARTH_SEMIAXIS_B = 6356752.314245_m

Definition at line 10 of file constants.cpp.