units_goodie.tex

\begin{cpp}[\tiny]
#include "antioch/antioch_asserts.h"
#include "antioch/units.h"
#include "antioch/unit_defs.h"

namespace Antioch{

  template <typename CoeffType>
  class PhysicalQuantity{

    public:
        PhysicalQuantity();
        PhysicalQuantity(const CoeffType & value, const std::string & unit = std::string() );

        ~PhysicalQuantity();

        /* getter/setter */

        void set_value(const CoeffType & value);

        void set_unit(const std::string & unit);

        void set_unit(const Units<CoeffType> & unit);

        const CoeffType value() const;

        const std::string & unit() const;

        const Units<CoeffType> & unit_object() const;

        /* changers */

        void change_unit_to(const std::string &target);

        void change_unit_to_SI();

        /* operators */

        PhysicalQuantity<CoeffType> & operator+=(const PhysicalQuantity<CoeffType> &rhs);

        PhysicalQuantity<CoeffType> & operator-=(const PhysicalQuantity<CoeffType> &rhs);

        PhysicalQuantity<CoeffType> & operator*=(const PhysicalQuantity<CoeffType> &rhs);

        PhysicalQuantity<CoeffType> & operator/=(const PhysicalQuantity<CoeffType> &rhs);

        PhysicalQuantity<CoeffType>   operator* (const PhysicalQuantity<CoeffType> &rhs) const;

        PhysicalQuantity<CoeffType>   operator/ (const PhysicalQuantity<CoeffType> &rhs) const;

        PhysicalQuantity<CoeffType>   operator+ (const PhysicalQuantity<CoeffType> &rhs) const;

        PhysicalQuantity<CoeffType>   operator- (const PhysicalQuantity<CoeffType> &rhs) const;

    private:
        Units<CoeffType> _unit;
        CoeffType        _value;

  };

  template <typename CoeffType>
  PhysicalQuantity<CoeffType>::PhysicalQuantity():
        _unit(),
        _value(0.)
  {
     return;
  }

  template <typename CoeffType>
  PhysicalQuantity<CoeffType>::PhysicalQuantity(const CoeffType & value, const std::string & unit):
        _unit(unit),
        _value(value)
  {
     return;
  }

  template <typename CoeffType>
  PhysicalQuantity<CoeffType>::~PhysicalQuantity()
  {
     return;
  }

  template <typename CoeffType>
  void PhysicalQuantity<CoeffType>::set_value(const CoeffType & value)
  {
     _value = value;
  }

  template <typename CoeffType>
  void PhysicalQuantity<CoeffType>::set_unit(const std::string & unit)
  {
     _unit = unit;
  }

  template <typename CoeffType>
  void PhysicalQuantity<CoeffType>::set_unit(const Units<CoeffType> & unit)
  {
     _unit = unit;
  }

  template <typename CoeffType>
  const CoeffType PhysicalQuantity<CoeffType>::value() const
  {
     return _value;
  }

  template <typename CoeffType>
  const std::string & PhysicalQuantity<CoeffType>::unit() const
  {
     return _unit.symbol();
  }

  template <typename CoeffType>
  const Units<CoeffType> & PhysicalQuantity<CoeffType>::unit_object() const
  {
     return _unit;
  }

  template <typename CoeffType>
  void PhysicalQuantity<CoeffType>::change_unit_to(const std::string &target)
  {
      if(!_unit.is_homogeneous(target))antioch_error();
      CoeffType t = _unit.translator_to_some_unit(target);
      CoeffType v = _unit.factor_to_some_unit(target);
      _value = v * _value + t;
      _unit.set_unit(target);
  }

  template <typename CoeffType>
  void PhysicalQuantity<CoeffType>::change_unit_to_SI()
  {
      CoeffType t = _unit.get_SI_translator();
      CoeffType v = _unit.get_SI_factor();
      _value = v * _value + t;
      _unit.set_unit(_unit.get_SI_symb());
  }

  template <typename CoeffType>
  PhysicalQuantity<CoeffType> & 
        PhysicalQuantity<CoeffType>::operator+=(const PhysicalQuantity<CoeffType> &rhs)
  {
     if(!rhs.unit().is_homogeneous(this->unit()))antioch_error();
     this->set_value(this->value() + rhs.value());
     return *this;
  }

  template <typename CoeffType>
  PhysicalQuantity<CoeffType> & 
        PhysicalQuantity<CoeffType>::operator-=(const PhysicalQuantity<CoeffType> &rhs)
  {
     if(!rhs.unit().is_homogeneous(this->unit()))antioch_error();
     this->set_value(this->value() - rhs.value());
     return *this;
  }

  template <typename CoeffType>
  PhysicalQuantity<CoeffType> & 
        PhysicalQuantity<CoeffType>::operator*=(const PhysicalQuantity<CoeffType> &rhs)
  {
     this->set_value(this->value() * rhs.value());
     this->set_unit(this->unit() + rhs.unit());
     return *this;
  }

  template <typename CoeffType>
  PhysicalQuantity<CoeffType> &
        PhysicalQuantity<CoeffType>::operator/=(const PhysicalQuantity<CoeffType> &rhs)
  {
     this->set_value(this->value() / rhs.value());
     this->set_unit(this->unit() - rhs.unit());
     return *this;
  }

  template <typename CoeffType>
  PhysicalQuantity<CoeffType>
        PhysicalQuantity<CoeffType>::operator*(const PhysicalQuantity<CoeffType> &rhs) const
  {
     return (PhysicalQuantity<CoeffType>(*this) *= rhs);
  }

  template <typename CoeffType>
  PhysicalQuantity<CoeffType>
        PhysicalQuantity<CoeffType>::operator/(const PhysicalQuantity<CoeffType> &rhs) const
  {
     return (PhysicalQuantity<CoeffType>(*this) /= rhs);
  }

  template <typename CoeffType>
  PhysicalQuantity<CoeffType>
        PhysicalQuantity<CoeffType>::operator+(const PhysicalQuantity<CoeffType> &rhs) const
  {
     return (PhysicalQuantity<CoeffType>(*this) += rhs);
  }
  
  template <typename CoeffType>
  PhysicalQuantity<CoeffType>
        PhysicalQuantity<CoeffType>::operator-(const PhysicalQuantity<CoeffType> &rhs) const
  {
     return (PhysicalQuantity<CoeffType>(*this) -= rhs);
  }

}
\end{cpp}