namespace boostish
{
namespace math
{
	template<std::size_t M, std::size_t F> inline
	fixed<M,F>::fixed()
	{
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>::fixed( int n ) 
		: data(n << fractional_bits) 
	{
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>::fixed( float n ) 
		: data(static_cast<base_type>( n * one )) 
	{
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>::fixed( double n ) 
		: data(static_cast<base_type>( n * one ))  
	{
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>::fixed( const fixed &rhs ) 
		: data(rhs.data) 
	{
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>::fixed( detail::raw_fixed<base_type> raw )
		: data(raw.data) 
	{
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>& fixed<M,F>::operator = ( const fixed &rhs ) 
	{
		data = rhs.data;
		return *this;
	}

	template<std::size_t M, std::size_t F> inline
	bool fixed<M,F>::operator < ( const fixed &rhs ) const 
	{
		return data < rhs.data;
	}

	template<std::size_t M, std::size_t F> inline
	bool fixed<M,F>::operator == ( const fixed &rhs ) const 
	{
		return data == rhs.data;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>& fixed<M,F>::operator += ( const fixed &n ) 
	{
		data += n.data;
		return *this;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>& fixed<M,F>::operator -= ( const fixed &n ) 
	{
		data -= n.data;
		return *this;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>& fixed<M,F>::operator *= ( const fixed &n ) 
	{
		next_type t(static_cast<next_type>(data) * static_cast<next_type>(n.data));
		t >>= fractional_bits;
		data = static_cast<base_type>(t);
		return *this;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>& fixed<M,F>::operator /= ( const fixed &n ) 
	{
		next_type t(static_cast<next_type>(data));
		t <<= fractional_bits;
		t /= static_cast<next_type>(n.data);
		data = static_cast<base_type>(t);
		return *this;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>& fixed<M,F>::operator ++ ()
	{
		data += base_type(1) << fractional_bits;
		return *this;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>& fixed<M,F>::operator -- ()
	{
		data -= base_type(1) << fractional_bits;
		return *this;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>& fixed<M,F>::operator *= ( int n ) 
	{
		data *= n;
		return *this;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F>& fixed<M,F>::operator /= ( int n )
	{
		data /= n;
		return *this;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F> operator * ( fixed<M,F> lhs, int rhs )
	{
		return lhs *= rhs;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F> operator * ( int lhs, fixed<M,F> rhs )
	{
		return rhs *= lhs;
	}

	template<std::size_t M, std::size_t F> inline
	fixed<M,F> operator / ( fixed<M,F> lhs, int rhs )
	{
		return lhs /= rhs;
	}

	template<std::size_t M, std::size_t F> inline
	int to_integer( const fixed<M,F> &f )
	{
		return f.data >> fixed<M,F>::fractional_bits;
	}

	template<std::size_t M, std::size_t F> inline
	float to_float( const fixed<M,F> &f )
	{
		return static_cast<float>( f.data ) / float( fixed<M,F>::one );
	}

	template<std::size_t M, std::size_t F> inline
	double to_double( const fixed<M,F> &f )
	{
		return static_cast<double>( f.data ) / double( fixed<M,F>::one );
	}

} // end namespace math
} // end namespace method