/***********************************
 * (C) 2008 by Tomasz bla Fortuna <bla@thera.be>.
 * License: GPL3+ (See Docs/LICENSE)
 *
 * Implementation of signed 16 bit fixed-point numbers
 ********************/

#include <math.h>

namespace RealType {

	/* Compile-time power template */
	template<Int E>
	struct Pow2 {
		enum {r = 2 * Pow2<E-1>::r};
	};

	template<>
	struct Pow2<0> {
		enum {r = 1};
	};


	/* Fixed-point number and operations template.
	 * 
	 * T2 should be a type bigger than T
	 * IPart - bits of integer part
	 * FPart - bits of fractional part */
	template<typename T, typename T2, char IPart, char FPart>
	union Fixed {
		typedef Fixed<T, T2, IPart, FPart> MyType;
	private:
		T n;
		struct Parts {
			T Fraction : FPart;
			T Integer : IPart;
		} P;

	public:
		/* To create using binary representation use this constructor
		 * and then change n */
		Fixed() : n(T()) {};


		/* This creates from integers... */
		Fixed(T A) : n(A<<FPart) {} 

		/* This from constants _only_ */
		Fixed(T I, Float F)
			: n( (T) ( (I << FPart) +
				   (F + 1.0/Pow2<FPart+1>::r) *
				   Pow2<FPart>::r)) {}

		/* Getters */
		inline T Integer() { return P.Integer; }
		inline T Fract() { return P.Fraction * 100 / Pow2<FPart>::r; }
		inline T operator*() { return n; }

		/* Operations */
		inline MyType operator+(const MyType &A) {
			return MyType(n+A.n);
		}

		inline MyType operator+(const T A) {
			return MyType(n + (A << FPart));
		}

		inline MyType operator-(const MyType &A) {
			return MyType(n-A.n);
		}

		inline MyType operator-(const T A) {
			return MyType(n - (A << FPart));
		}

		inline MyType operator*(const MyType A) {
			MyType tmp;
      			tmp.n = (((T2)
				(n * A.n +
				 Pow2<FPart-1>::r )) >> FPart);
			 return tmp; 
		}

		inline MyType operator/(const MyType A) {
			MyType tmp;
			tmp.n = ((T2)((n << (FPart+1)) / A.n) + 1 ) / 2;
			return tmp;
		}

		/* 'in-place' */
		inline void operator+=(const MyType &A) {
			n += A.n;
		}

		inline void operator+=(const T A) {
			n += A << FPart;
		}

		inline void operator-=(const MyType &A) {
			n -= A.n;
		}

		inline void operator-=(const T A) {
			n -= A << FPart;
		}

		inline void operator*=(const MyType A) {
			n = (((T2)(n * A.n +
				 Pow2<FPart-1>::r )) >> FPart);
		}

		inline void operator/=(const MyType A) {
			n = ((T2)((n << (FPart+1)) / A.n) + 1 ) / 2;
		}
		
		void Debug() {
			printf("(%d = %hd,%hu)", n, Integer(), Fract());
		}
	};

	/* Semi-compatible floating-point class for tests
	 * T - floating point type
	 * T2 - simulated integer /holder/ */
	template<typename T, typename T2>
	struct Float {
		typedef Float<T, T2> MyType;
		T D;

		Float() {}
		Float(T I, T F)	: D(I+F) {}
		Float(T A) : D(A) {}

		inline operator T&() { return D; }
		inline operator const T&() const { return D; }

//		inline T operator*() { return D; }

		inline T2 Integer() {
			return (T2)D;
		}

		inline T2 Fract() {
			return (T2)((D - Integer()) * 100000);
		}

/*		void Debug() {
			printf("(FP = %5.10f)", D);
		} */
	};
}

/* Create fixed */
/* 16 bit implementation */
//typedef RealType::Fixed<Int, Long, 9, 7> Real;

/* 32 bit implementation */
//typedef RealType::Fixed<int32_t, int64_t, 22, 10> Real;

/* Floating-point implementation */
typedef RealType::Float<Float, int16_t> Real;