double_with_unit.h

Go to the documentation of this file.

#ifndef DOUBLE_WITH_UNIT_H
#define DOUBLE_WITH_UNIT_H
#include "printable.h"
#include "unit.h"
#include <cmath>

namespace FullPhysics {
  class SpectralDomain;
/****************************************************************/
class DoubleWithUnit : public Printable<DoubleWithUnit>,
                       boost::ordered_field_operators<DoubleWithUnit> {
public:
  DoubleWithUnit() {}
  DoubleWithUnit(double V, const Unit& U)
    : value(V), units(U) {}
  DoubleWithUnit(double V, const std::string& U)
    : value(V), units(U) {}
  DoubleWithUnit(double V)
    : value(V), units(units::dimensionless) {}
  double value;
  Unit units;

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
  inline  DoubleWithUnit& operator*=(const DoubleWithUnit& D)
  { value *= D.value; units *= D.units; return *this;}
  inline DoubleWithUnit& operator/=(const DoubleWithUnit& D)
  { value /= D.value; units /= D.units; return *this;}
  inline DoubleWithUnit& operator+=(const DoubleWithUnit& D)
  { value += D.value * FullPhysics::conversion(D.units, units); return *this;}
  inline DoubleWithUnit& operator-=(const DoubleWithUnit& D)
  { value -= D.value * FullPhysics::conversion(D.units, units); return *this;}

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------

  inline DoubleWithUnit convert(const Unit& R) const
  { return DoubleWithUnit(value * FullPhysics::conversion(units, R), R); }

//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
    
  inline DoubleWithUnit convert_wave(const Unit& R) const
  {
    if(units.is_commensurate(R))
      return convert(R);
    else
      return (1.0 / *this).convert(R);
  }

  DoubleWithUnit convert_wave(const Unit& R, 
                              const SpectralDomain& Pixel_grid) const;

  void print(std::ostream& Os) const 
  { Os << value << " " << units.name(); }

};

//-----------------------------------------------------------------------
// Compare DoubleWithUnits
//-----------------------------------------------------------------------
inline bool operator<(const FullPhysics::DoubleWithUnit& A, const FullPhysics::DoubleWithUnit& B)
{ return A.value < B.convert(A.units).value; }

//-----------------------------------------------------------------------
inline bool operator==(const FullPhysics::DoubleWithUnit& A, const FullPhysics::DoubleWithUnit& B)
{ return A.value == B.convert(A.units).value; }


}


//-----------------------------------------------------------------------
//-----------------------------------------------------------------------
namespace std {
  // Math functions are in std:: namespace.
  inline FullPhysics::DoubleWithUnit floor(const FullPhysics::DoubleWithUnit& x) 
  {
    return FullPhysics::DoubleWithUnit(::floor(x.value), x.units);
  }

  inline FullPhysics::DoubleWithUnit ceil(const FullPhysics::DoubleWithUnit& x) 
  {
    return FullPhysics::DoubleWithUnit(::ceil(x.value), x.units);
  }

  inline FullPhysics::DoubleWithUnit round(const FullPhysics::DoubleWithUnit& x) 
  {
    return FullPhysics::DoubleWithUnit(::round(x.value), x.units);
  }

  inline FullPhysics::DoubleWithUnit min(const FullPhysics::DoubleWithUnit& x, const FullPhysics::DoubleWithUnit& y) 
  {
    return FullPhysics::DoubleWithUnit(std::min(x.value, y.value), x.units);
  }

  inline FullPhysics::DoubleWithUnit max(const FullPhysics::DoubleWithUnit& x, const FullPhysics::DoubleWithUnit& y) 
  {
    return FullPhysics::DoubleWithUnit(std::max(x.value, y.value), x.units);
  }

}

#endif