vnix::units::basic_dim< DBO > Class Template Reference

Rational exponent for each basis-element of dimension. More...

#include <dim.hpp>

Inheritance diagram for vnix::units::basic_dim< DBO >:

Collaboration diagram for vnix::units::basic_dim< DBO >:

Classes
struct	divd
	Function object used for dividing every exponent by a single factor. More...
struct	mult
	Function object used for multiplying every exponent by a single factor. More...

Public Types
enum	{ NUM_BASES = DBO::num_offs, NUM_BITS = NUM_BASES * rat::BITS }
using	rat = rational< 4, 2 >
	Type of rational for dimensioned values. More...
using	off = DBO
	Type of offset for each base-element. More...
using	word = typename int_types< NUM_BITS >::US
	Type of unsigned word in which dimensions are encoded. More...

Public Member Functions
constexpr	basic_dim ()
constexpr	basic_dim (word u)
	Initialize from dim that has been encoded into a word. More...
template<typename... T>
constexpr	basic_dim (T...ts)
	Initialize exponents, one for each base quantity. More...
constexpr	basic_dim (std::array< rat, NUM_BASES > const &a)
constexpr word	encode () const
	Encode data for this dim into a word. More...
constexpr rat	exp (DBO off) const
	Rational exponent at specified offset. More...
constexpr rat	operator[] (DBO off) const
	Rational exponent at specified offset. More...
constexpr void	set (DBO off, rat r)
	Set rational exponent at specified offset. More...
template<typename F >
constexpr basic_dim	combine (basic_dim const &d, F f) const
	Combine each exponent with corresponding other exponent via function. More...
template<typename F >
constexpr basic_dim	transform (F f) const
	Transform each exponent according to a function. More...
constexpr basic_dim	operator+ (basic_dim const &a) const
	Add corresponding exponents. More...
constexpr basic_dim	operator- (basic_dim const &s) const
	Subtract corresponding exponents. More...
constexpr basic_dim	operator* (rat f) const
	Multiply exponents by rational factor. More...
constexpr basic_dim	operator/ (rat f) const
	Divide exponents by rational factor. More...
constexpr basic_dim	operator/ (rat::stype f) const
	Divide exponents by rational factor. More...
constexpr bool	operator== (basic_dim const &d) const
constexpr bool	operator!= (basic_dim const &d) const

Static Public Member Functions
static constexpr rat	add (rat x, rat y)
	Function used to add corresponding exponents. More...
static constexpr rat	sbtrct (rat x, rat y)
	Function used to subtract corresponding exponents. More...
static std::ostream &	print_unit (std::ostream &s, char const *u, rat e)
	Print to output stream the symbolic contribution from a given unit. More...

Private Types
enum	{ MAX_SHIFT = (NUM_BASES - 1) * rat::BITS }

Static Private Member Functions
template<typename T >
static constexpr word	encode (T t)
	Encode exponent associated with highest DBO at highest bit-offsets. More...
template<typename T , typename... U>
static constexpr word	encode (T t, U...us)
	Encode exponents, with higher DBO at higher bit-offsets. More...
static constexpr word	encode (std::array< rat, NUM_BASES > const &a)

Private Attributes
word	e_
	Storage for exponents. More...

Friends
std::ostream &	operator<< (std::ostream &s, basic_dim d)
	Print to to output stream. More...

Detailed Description

template<typename DBO>
class vnix::units::basic_dim< DBO >

Rational exponent for each basis-element of dimension.

The template-type parameter DBO is of type dim_base_offset, which is automatically generated from YAML and ERB before the header-only library is installed.

Template Parameters

DBO	Type of offset of basis-element of dimension.

Definition at line 24 of file dim.hpp.

Member Typedef Documentation

template<typename DBO>

using vnix::units::basic_dim< DBO >::off = DBO

Type of offset for each base-element.

Definition at line 27 of file dim.hpp.

template<typename DBO>

using vnix::units::basic_dim< DBO >::rat = rational<4, 2>

Type of rational for dimensioned values.

Definition at line 26 of file dim.hpp.

template<typename DBO>

using vnix::units::basic_dim< DBO >::word = typename int_types<NUM_BITS>::US

Type of unsigned word in which dimensions are encoded.

Definition at line 35 of file dim.hpp.

Member Enumeration Documentation

template<typename DBO>

anonymous enum

Enumerator
NUM_BASES	Number of bases for dimension.
NUM_BITS	Number of bits in instance of dim.

Definition at line 29 of file dim.hpp.

       {
    NUM_BASES = DBO::num_offs,        
    NUM_BITS  = NUM_BASES * rat::BITS 
  };

template<typename DBO>

anonymous enum

private

Enumerator
MAX_SHIFT	Maximum number of bits to shift an encoding of a rational exponent.

Definition at line 41 of file dim.hpp.

       {
    MAX_SHIFT = (NUM_BASES - 1) * rat::BITS
  };

Constructor & Destructor Documentation

template<typename DBO>

constexpr vnix::units::basic_dim< DBO >::basic_dim ( )

inline

Definition at line 82 of file dim.hpp.

: e_(0) {}

Here is the caller graph for this function:

template<typename DBO>

constexpr vnix::units::basic_dim< DBO >::basic_dim ( word  u )

inlineexplicit

Initialize from dim that has been encoded into a word.

By default, initialize null (dimensionless) dim.

Parameters

u	Encoded data for dim.

Definition at line 87 of file dim.hpp.

: e_(u) {}

Here is the caller graph for this function:

template<typename DBO>

template<typename... T>

constexpr vnix::units::basic_dim< DBO >::basic_dim ( T...  ts )

inline

Initialize exponents, one for each base quantity.

Template Parameters

T	List of types, one for each initializer in list for rat_array. Each type should be rat.

Parameters

ts	List of initializers for rat_array.

Definition at line 96 of file dim.hpp.

                                                        : e_(encode(ts...)) {
    static_assert(sizeof...(ts) == NUM_BASES, "illegal number of bases");
  }

template<typename DBO>

constexpr vnix::units::basic_dim< DBO >::basic_dim ( std::array< rat, NUM_BASES > const &  a )

inline

Definition at line 101 of file dim.hpp.

: e_(encode(a)) {}

Here is the caller graph for this function:

Member Function Documentation

template<typename DBO>

static constexpr rat vnix::units::basic_dim< DBO >::add ( rat  x, rat  y  )

inlinestatic

Function used to add corresponding exponents.

Definition at line 156 of file dim.hpp.

{ return x + y; }

Here is the caller graph for this function:

template<typename DBO>

template<typename F >

constexpr basic_dim vnix::units::basic_dim< DBO >::combine ( basic_dim< DBO > const &  d, F  f  ) const

inline

Combine each exponent with corresponding other exponent via function.

Template Parameters

F	Type of function for combining two rationals to make third.

Parameters

d	Other rational exponents.
f	Function operating on pair of rationals.

Returns

New rational exponents.

Definition at line 133 of file dim.hpp.

                                                             {
    basic_dim r(word(0));
    for (auto b : off::array) {
      auto const os = DBO(b);
      r.set(os, f(exp(os), d.exp(os)));
    }
    return r;
  }

template<typename DBO>

template<typename T >

static constexpr word vnix::units::basic_dim< DBO >::encode ( T  t )

inlinestaticprivate

Encode exponent associated with highest DBO at highest bit-offsets.

Template Parameters

T	Type that is convertible rat.
t	Exponent to be encoded.

Definition at line 49 of file dim.hpp.

                                                          {
    return rat::encode(t) << MAX_SHIFT;
  }

template<typename DBO>

template<typename T , typename... U>

static constexpr word vnix::units::basic_dim< DBO >::encode ( T  t, U...  us  )

inlinestaticprivate

Encode exponents, with higher DBO at higher bit-offsets.

Template Parameters

T	Type that is convertible to rat.
U	List of types, each convertible to rat.

Parameters

t	Exponent to be encoded at lowest bit-offsets.
us	Exponents to be encoded at higher bit-offsets.

Definition at line 60 of file dim.hpp.

                                             {
    constexpr auto N = sizeof...(us);
    static_assert(N < NUM_BASES, "too many exponents");
    constexpr auto SHIFT = MAX_SHIFT - N * rat::BITS;
    constexpr word MASK  = bit_range<word>(0, rat::BITS - 1) << SHIFT;
    word const     e     = rat::encode(t) << SHIFT;
    return (e & MASK) | (encode(us...) & ~MASK);
  }

template<typename DBO>

static constexpr word vnix::units::basic_dim< DBO >::encode ( std::array< rat, NUM_BASES > const &  a )

inlinestaticprivate

Definition at line 70 of file dim.hpp.

                                                                  {
    word es = 0;
    for (uint_fast8_t i = 0; i < NUM_BASES; ++i) {
      auto const SHIFT = i * rat::BITS;
      word const MASK  = bit_range<word>(0, rat::BITS - 1) << SHIFT;
      word const e     = rat::encode(a[i]) << SHIFT;
      es |= (e & MASK);
    }
    return es;
  }

template<typename DBO>

constexpr word vnix::units::basic_dim< DBO >::encode ( ) const

inline

Encode data for this dim into a word.

Definition at line 104 of file dim.hpp.

{ return e_; }

Here is the caller graph for this function:

template<typename DBO>

constexpr rat vnix::units::basic_dim< DBO >::exp ( DBO  off ) const

inline

Rational exponent at specified offset.

Parameters

off	Offset of exponent.

Definition at line 108 of file dim.hpp.

                                   {
    constexpr auto mask = bit_range<word>(0, rat::BITS - 1);
    return rat::decode((e_ >> (off * rat::BITS)) & mask);
  }

Here is the caller graph for this function:

template<typename DBO>

constexpr bool vnix::units::basic_dim< DBO >::operator!= ( basic_dim< DBO > const &  d ) const

inline

Definition at line 229 of file dim.hpp.

{ return e_ != d.e_; }

Here is the caller graph for this function:

template<typename DBO>

constexpr basic_dim vnix::units::basic_dim< DBO >::operator* ( rat  f ) const

inline

Multiply exponents by rational factor.

This is called when a physical quantity is raised to a power.

Parameters

f

Factor.

Returns

Products.

Definition at line 211 of file dim.hpp.

{ return transform(mult(f)); }

Here is the caller graph for this function:

template<typename DBO>

constexpr basic_dim vnix::units::basic_dim< DBO >::operator+ ( basic_dim< DBO > const &  a ) const

inline

Add corresponding exponents.

This is called when two physical quantities are multiplied. Passing lambda in constexpr function requires C++17.

Parameters

a

Addends.

Returns

Sums.

Definition at line 194 of file dim.hpp.

                                                          {
    return combine(a, add);
  }

Here is the caller graph for this function:

template<typename DBO>

constexpr basic_dim vnix::units::basic_dim< DBO >::operator- ( basic_dim< DBO > const &  s ) const

inline

Subtract corresponding exponents.

This is called when one physical quantity is divided by another. Passing lambda in constexpr function requires C++17.

Parameters

s	Subtrahends.

Returns

Differences.

Definition at line 203 of file dim.hpp.

                                                          {
    return combine(s, sbtrct);
  }

Here is the caller graph for this function:

template<typename DBO>

constexpr basic_dim vnix::units::basic_dim< DBO >::operator/ ( rat  f ) const

inline

Divide exponents by rational factor.

This is called when a physical quantity is raised to a power.

Parameters

f

Factor.

Returns

Products.

Definition at line 217 of file dim.hpp.

{ return transform(divd(f)); }

Here is the caller graph for this function:

template<typename DBO>

constexpr basic_dim vnix::units::basic_dim< DBO >::operator/ ( rat::stype  f ) const

inline

Divide exponents by rational factor.

This is called when a physical quantity is raised to a power.

Parameters

f

Factor.

Returns

Products.

Definition at line 223 of file dim.hpp.

                                                  {
    return transform(divd(f));
  }

Here is the caller graph for this function:

template<typename DBO>

constexpr bool vnix::units::basic_dim< DBO >::operator== ( basic_dim< DBO > const &  d ) const

inline

Definition at line 227 of file dim.hpp.

{ return e_ == d.e_; }

Here is the caller graph for this function:

template<typename DBO>

constexpr rat vnix::units::basic_dim< DBO >::operator[] ( DBO  off ) const

inline

Rational exponent at specified offset.

Parameters

off	Offset of exponent.

Definition at line 115 of file dim.hpp.

{ return exp(off); }

Here is the caller graph for this function:

template<typename DBO>

static std::ostream& vnix::units::basic_dim< DBO >::print_unit ( std::ostream &  s, char const *  u, rat  e  )

inlinestatic

Print to output stream the symbolic contribution from a given unit.

Parameters

s	Output stream.
u	Abbreviation for unit.
e	Exponent of unit.

Definition at line 235 of file dim.hpp.

                                                                     {
    if (e.to_bool()) {
      s << " " << u;
      if (e != rat(1)) {
        s << "^";
        if (e.d() != 1) { s << "["; }
        s << e;
        if (e.d() != 1) { s << "]"; }
      }
    }
    return s;
  }

template<typename DBO>

static constexpr rat vnix::units::basic_dim< DBO >::sbtrct ( rat  x, rat  y  )

inlinestatic

Function used to subtract corresponding exponents.

Definition at line 159 of file dim.hpp.

{ return x - y; }

Here is the caller graph for this function:

template<typename DBO>

constexpr void vnix::units::basic_dim< DBO >::set ( DBO  off, rat  r  )

inline

Set rational exponent at specified offset.

Parameters

off	Offset of exponent.
r	Rational exponent.

Definition at line 120 of file dim.hpp.

                                     {
    unsigned const bit_off = off * rat::BITS;
    word const     expon   = rat::encode(r) << bit_off;
    auto const     mask    = bit_range<word>(0, rat::BITS - 1) << bit_off;
    e_                     = (e_ & ~mask) | (expon & mask);
  }

template<typename DBO>

template<typename F >

constexpr basic_dim vnix::units::basic_dim< DBO >::transform ( F  f ) const

inline

Transform each exponent according to a function.

Template Parameters

F	Type of function.

Parameters

f	Unary function operating on rational.

Returns

New exponents.

Definition at line 146 of file dim.hpp.

                                                                 {
    basic_dim r(word(0));
    for (auto b : off::array) {
      auto const os = DBO(b);
      r.set(os, f(exp(os)));
    }
    return r;
  }

Friends And Related Function Documentation

template<typename DBO>

std::ostream& operator<< ( std::ostream &  s, basic_dim< DBO >  d  )

friend

Print to to output stream.

Parameters

s	Reference to stream.
d	Dimension to print.

Definition at line 251 of file dim.hpp.

                                                            {
    for (auto i : DBO::array) { print_unit(s, DBO::sym[i], d[i]); }
    return s;
  }

Member Data Documentation

template<typename DBO>

word vnix::units::basic_dim< DBO >::e_

private

Storage for exponents.

Definition at line 38 of file dim.hpp.

---

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

• vnix/units/dim.hpp