// DimensionedValue
#ifndef _DIMENSIONED_VALUE_H_INCLUDED
#define _DIMENSIONED_VALUE_H_INCLUDED
#include <ostream>
using std::ostream;

// class DimensionedUnit is used to output the unit
template <int L, int M, int T, int C>
class DimensionedUnit {
		static bool printUnit(bool showDot, ostream& os, char* unit, int dim) {
				if(dim!=0) {
						if(showDot) {
								os<<'\xb7';
						}
						os<<unit;
						if(dim!=1) {
								os<<dim;
						}
						showDot=true;
				}
				return showDot;
		}
		
		public:
		static void printOn(ostream& os) {
				bool showDot=false;
				showDot = printUnit(showDot,os,"m",L);
				showDot = printUnit(showDot,os,"Kg",M);
				showDot = printUnit(showDot,os,"s",T);
				printUnit(showDot,os,"A",C);
		}
		
		static bool unitsAreDerived() { return false; }
};

// Specializations for standard units
template<>
class DimensionedUnit<0,0,-1,0> {
	static void printOn(ostream& os) {
		os<<"Hz";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<1,1,-2,0> {
	static void printOn(ostream& os) {
		os<<"N";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<-1,1,-2,0> {
	static void printOn(ostream& os) {
		os<<"Pa";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<-1,1,-1,0> {
	static void printOn(ostream& os) {
		os<<"Pa\xb7s";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<2,1,-2,0> {
	static void printOn(ostream& os) {
		os<<"J";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<2,1,-3,0> {
	static void printOn(ostream& os) {
		os<<"W";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<0,0,1,1> {
	static void printOn(ostream& os) {
		os<<"C";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<2,1,-3,-1> {
	static void printOn(ostream& os) {
		os<<"V";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<-2,-1,4,2> {
	static void printOn(ostream& os) {
		os<<"F";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<2,1,-3,-2> {
	static void printOn(ostream& os) {
		os<<"Ohm";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<-2,-1,3,2> {
	static void printOn(ostream& os) {
		os<<"S";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<2,1,-2,-1> {
	static void printOn(ostream& os) {
		os<<"Wb";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<0,1,-2,-1> {
	static void printOn(ostream& os) {
		os<<"T";
	}
	static bool unitsAreDerived() { return true; }
};

template<>
class DimensionedUnit<2,1,-2,-2> {
	static void printOn(ostream& os) {
		os<<"H";
	}
	static bool unitsAreDerived() { return true; }
};

// class DimensionedValue holds values that are dimensioned
template <int L, int M, int T, int C>
class DimensionedValue {
  double v;

  public:

  DimensionedValue(double val) : v(val) {}

  inline double magnitude() { return v; }

/*  inline DimensionedValue operator*(double d) {
     return DimensionedValue(magnitude()*d);
  }*/
  
  template<int L2, int M2, int T2, int C2> DimensionedValue<L+L2,M+M2,T+T2,C+C2> operator*(DimensionedValue<L2,M2,T2,C2> other) {
     return DimensionedValue<L+L2,M+M2,T+T2,C+C2>(magnitude()*other.magnitude());
  }

  template<int L2, int M2, int T2, int C2> DimensionedValue<L-L2,M-M2,T-T2,C-C2> operator/(DimensionedValue<L2,M2,T2,C2> other) {
     return DimensionedValue<L-L2,M-M2,T-T2,C-C2>(magnitude()/other.magnitude());
  }

  DimensionedValue operator+(DimensionedValue other) {
     return DimensionedValue(magnitude()+other.magnitude());
  }   

  DimensionedValue operator-(DimensionedValue other) {
     return DimensionedValue(magnitude()-other.magnitude());
  } 
  
  void printOn(ostream& os) {
		  os<<magnitude()<<' ';
		  DimensionedUnit<L,M,T,C>::printOn(os);
  }
  
  bool unitsAreDerived() { return DimensionedUnit<L,M,T,C>::unitsAreDerived(); }

  static const int mExponent;
  static const int kExponent;
  static const int sExponent;
  static const int aExponent;
};

template <int L, int M, int T, int C>
const int DimensionedValue<L,M,T,C>::mExponent = L;

template <int L, int M, int T, int C>
const int DimensionedValue<L,M,T,C>::kExponent = M;

template <int L, int M, int T, int C>
const int DimensionedValue<L,M,T,C>::sExponent = T;

template <int L, int M, int T, int C>
const int DimensionedValue<L,M,T,C>::aExponent = C;


template <int L, int M, int T, int C>
static ostream& operator<<(ostream& os, DimensionedValue<L,M,T,C> u) {
		u.printOn(os);
		return os;
}

template <int L, int M, int T, int C>
static DimensionedValue<L,M,T,C> operator*(double d,DimensionedValue<L,M,T,C> u) {
     return DimensionedValue<L,M,T,C>(d*u.magnitude());
}

// Standard names
typedef DimensionedValue<0,0,0,0> unity;
typedef DimensionedValue<1,0,0,0> length;
typedef DimensionedValue<0,1,0,0> mass;
typedef DimensionedValue<0,0,1,0> time_; // avoid conflict with "time" in "time.h"
typedef DimensionedValue<0,0,0,1> current;
typedef DimensionedValue<2,0,0,0> area;
typedef DimensionedValue<3,0,0,0> volume;
typedef DimensionedValue<1,0,-1,0> velocity;
typedef DimensionedValue<1,0,-2,0> acceleration;
typedef DimensionedValue<1,1,-1,0> momentum;
typedef DimensionedValue<2,1,-1,0> angular_momentum;
typedef DimensionedValue<0,0,-1,0> frequency;
typedef DimensionedValue<1,1,-2,0> force;
typedef DimensionedValue<-1,1,-2,0> pressure;
typedef DimensionedValue<-1,1,-1,0> viscosity;
typedef DimensionedValue<2,1,-2,0> energy;
typedef DimensionedValue<2,1,-3,0> power;
typedef DimensionedValue<0,0,1,1> charge;
typedef DimensionedValue<2,1,-3,-1> potential;
typedef DimensionedValue<-2,-1,4,2> capacitance;
typedef DimensionedValue<2,1,-3,-2> resistance;
typedef DimensionedValue<-2,-1,3,2> conductance;
typedef DimensionedValue<2,1,-2,-1> magnetic_flux;
typedef DimensionedValue<0,1,-2,-1> magnetic_flux_density;
typedef DimensionedValue<2,1,-2,-2> inductance;

// Standard units & English units
const length meter=1;
const length inch=0.0254;
const length foot=12*inch;
const length feet=foot;
const length yard=3*feet;
const length mile=5280*feet;

const mass kilogram=1;
const mass gram=1e-3;

const time_ second=1;
const time_ minute=60;
const time_ hour=60*minute;
const time_ day=24*hour;
const frequency hertz=1;

const current ampere=1; 

const force newton=1;

const pressure pascal_=1; //pascal is a keyword in VC++

const viscosity poiseuille=1;

const energy joule=1;

const power watt=1;

const charge coulomb=1;

const potential volt=1;

const capacitance farad=1;

const resistance ohm=1;

const conductance siemens=1;

const magnetic_flux weber=1;

const magnetic_flux_density tesla=1;

const inductance henry=1;

// Standard qualifiers
const double yotta=1e24;
const double zetta=1e21;
const double exa=1e18;
const double peta=1e15;
const double tera=1e12;
const double giga=1e9;
const double mega=1e6;
const double kilo=1e3;
const double hecto=1e2;
const double deka=10;
const double deci=1e-1;
const double centi=1e-2;
const double milli=1e-3;
const double micro=1e-6;
const double nano=1e-9;
const double pico=1e-12;
const double femto=1e-15;
const double atto=1e-18;
const double zepto=1e-21;
const double yocto=1e-24;

#endif