Length.h

Go to the documentation of this file.

/* Copyright (C) 2002 - 2009, Bernd Speiser */

/* This file is part of Quantities.

PhysicalQuantities is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

PhysicalQuantities is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.
  
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
*/

#ifndef _Length_h
#define _Length_h

// Quantity includes
#include "Quantity/Variable.h"
#include "Quantity/Constant.h"
#include "Quantity/QuantityCluster.h"

namespace quantity {
  namespace length {

class Class;

class Unit;

/* declaration of Length units */
class MetreUnits;
class BohrUnit;
class AngstromUnit;
class MicronUnit;
class MilliMicronUnit;
class XUnit;
class FermiUnit;
class InchUnit;
class FootUnit;
class YardUnit;
class MileUnit;
class NauticalMileUnit;
class AstronomicalUnit;
class ParsecUnit;
class LightYearUnit;
class LightSecondUnit;

typedef unit::Prefixable<Unit, MetreUnits> Metres;

typedef unit::Prefixed<Metres> Metre;
typedef unit::Prefixed<Metres, unit::Deci> DeciMetre;
typedef unit::Prefixed<Metres, unit::Centi> CentiMetre;
typedef unit::Prefixed<Metres, unit::Milli> MilliMetre;
typedef unit::Prefixed<Metres, unit::Micro> MicroMetre;
typedef unit::Prefixed<Metres, unit::Nano> NanoMetre;
typedef unit::Prefixed<Metres, unit::Pico> PicoMetre;
typedef unit::Prefixed<Metres, unit::Kilo> KiloMetre;

typedef unit::NonPrefixable<Unit, BohrUnit> Bohr;

typedef unit::NonPrefixable<Unit, AngstromUnit> Angstrom;

typedef unit::NonPrefixable<Unit, MicronUnit> Micron;

typedef unit::NonPrefixable<Unit, MilliMicronUnit> MilliMicron;

typedef unit::NonPrefixable<Unit, XUnit> X;

typedef unit::NonPrefixable<Unit, FermiUnit> Fermi;

typedef unit::NonPrefixable<Unit, InchUnit> Inch;

typedef unit::NonPrefixable<Unit, FootUnit> Foot;

typedef unit::NonPrefixable<Unit, YardUnit> Yard;

typedef unit::NonPrefixable<Unit, MileUnit> Mile;

typedef unit::NonPrefixable<Unit, NauticalMileUnit> NauticalMile;

typedef unit::NonPrefixable<Unit, AstronomicalUnit> Astronomical;

typedef unit::NonPrefixable<Unit, ParsecUnit> Parsec;

typedef unit::NonPrefixable<Unit, LightYearUnit> LightYear;

typedef unit::NonPrefixable<Unit, LightSecondUnit> LightSecond;

typedef Loki::TL::Append<Metres::Units,
  LOKI_TYPELIST_15(Bohr, Angstrom, Micron, MilliMicron, X, Fermi, Inch,
             Foot, Yard, Mile, NauticalMile, Astronomical, Parsec,
                                 LightYear, LightSecond)>::Result Units;

/* declare some abbreviated length units */

typedef Metre m;
typedef MilliMetre mm;
typedef KiloMetre km;
typedef CentiMetre cm;

/* Length quantity */

typedef Quantity<Class> Quantity;
typedef quantity::Quantity<Class, int> IntQuantity;

class DerivedLength;

  } // end namespace length


  template<typename ST>
    struct Standard<length::Metres, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Metres, ST>::ratio = 1.0;

template<typename ST> const bool Standard<length::Metres, ST>::exact = true;


  template<typename ST>
    struct Standard<length::Bohr, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Bohr, ST>::ratio = 5.29177e-11;

template<typename ST> const bool Standard<length::Bohr, ST>::exact = false;


  template<typename ST>
    struct Standard<length::Angstrom, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Angstrom, ST>::ratio = 1.0e-10;

template<typename ST> const bool Standard<length::Angstrom, ST>::exact = true;


  template<typename ST>
    struct Standard<length::Micron, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Micron, ST>::ratio = 1.0e-6;

template<typename ST> const bool Standard<length::Micron, ST>::exact = true;


  template<typename ST>
    struct Standard<length::MilliMicron, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::MilliMicron, ST>::ratio = 1.0e-9;

template<typename ST> const bool Standard<length::MilliMicron, ST>::exact = true;


  template<typename ST>
    struct Standard<length::X, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::X, ST>::ratio = 1.002e-13;

template<typename ST> const bool Standard<length::X, ST>::exact = false;


  template<typename ST>
    struct Standard<length::Fermi, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Fermi, ST>::ratio = 1.0e-15;

template<typename ST> const bool Standard<length::Fermi, ST>::exact = true;


  template<typename ST>
    struct Standard<length::Inch, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Inch, ST>::ratio = 2.54e-2;

template<typename ST> const bool Standard<length::Inch, ST>::exact = true;


  template<typename ST>
    struct Standard<length::Foot, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Foot, ST>::ratio = 0.3048;

template<typename ST> const bool Standard<length::Foot, ST>::exact = true;


  template<typename ST>
    struct Standard<length::Yard, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Yard, ST>::ratio = 0.9144;

template<typename ST> const bool Standard<length::Yard, ST>::exact = true;


  template<typename ST>
    struct Standard<length::Mile, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Mile, ST>::ratio = 1609.344;

template<typename ST> const bool Standard<length::Mile, ST>::exact = true;


  template<typename ST>
    struct Standard<length::NauticalMile, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::NauticalMile, ST>::ratio = 1852.;

template<typename ST> const bool Standard<length::NauticalMile, ST>::exact = true;


  template<typename ST>
    struct Standard<length::Astronomical, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Astronomical, ST>::ratio = 1.49600e11;

template<typename ST> const bool Standard<length::Astronomical, ST>::exact = true;


  template<typename ST>
    struct Standard<length::Parsec, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::Parsec, ST>::ratio = 3.08568e16;

template<typename ST> const bool Standard<length::Parsec, ST>::exact = false;


  template<typename ST>
    struct Standard<length::LightYear, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::LightYear, ST>::ratio = 9.460528e15;

template<typename ST> const bool Standard<length::LightYear, ST>::exact = false;


  template<typename ST>
    struct Standard<length::LightSecond, ST>
    {
      static const ST ratio;
      static const bool exact;
    };

template<typename ST> const ST Standard<length::LightSecond, ST>::ratio = 299792458.;

template<typename ST> const bool Standard<length::LightSecond, ST>::exact = true;

template<>
  struct QuantityTraits<length::Class>
  {
    typedef
      dimension::Dimension<BSUtilities::Rational<1>,
        BSUtilities::Rational<0>, BSUtilities::Rational<0>,
          BSUtilities::Rational<0>, BSUtilities::Rational<0>,
            BSUtilities::Rational<0>, BSUtilities::Rational<0> > Dimension;
    typedef length::Unit UnitType;
    typedef length::Units UnitList;
    typedef length::Metre DefaultUnit;

    typedef length::DerivedLength DefaultDerivedQuantityType;

    static const std::string NameString;
    static const std::string SymbolString;

  };

// the derived quantity traits template for Metre Length
template<>
  struct DerivedQuantityTraits<length::Class, length::DerivedLength>
  {
    static const bool OverwriteName = false;
    static const bool OverwriteSymbol = false;

    static const std::string NameString;
    static const std::string SymbolString;

  };

typedef Variable<length::Quantity> Length;

typedef Variable<length::IntQuantity> IntLength;

typedef Constant<length::Quantity> LengthConstant;

typedef QuantityVector<Variable, length::Quantity> LengthVector;

}

#endif /* _Length_h */

---