Added conversion methods, casting capabilities and associated unit tests for the class.

Author: Geoffrey Hunter

CHANGELOG.md

@@ -8,6 +8,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Added
 - Added compile time check to `FpF` class to make sure template parameters are the same before doing multiplication.
+- Added README code to a new example folder (to make sure it compiles correctly).
+- Added conversion methods, casting capabilities and associated unit tests for the `FpF` class.
 
 ### Fixed
 - Removed reference to non-existant MFixedPoint library when linking the benchmark and unit test code.

include/MFixedPoint/FpF.hpp

@@ -139,7 +139,7 @@ inline int32_t fixinv(int32_t a)
 
 /// \brief		Converts from float to a raw 32-bit fixed-point number.
 /// \details	Do not write "myFpNum = FloatToRawFix32()"! This function outputs a raw
-///				number, so you would have to use the syntax "myFpNum.rawVal = FloatToRawFix32()".
+///				number, so you would have to use the syntax "myFpNum.rawVal_ = FloatToRawFix32()".
 /// \warning	Slow!
 template <uint8_t q>
 int32_t FloatToRawFix32(float f) {
@@ -148,7 +148,7 @@ int32_t FloatToRawFix32(float f) {
 
 /// \brief		Converts from double to a raw 32-bit fixed-point number.
 /// \details	Do not write "myFpNum = DoubleToRawFix32()"! This function outputs a raw
-///				number, so you would have to use the syntax "myFpNum.rawVal = DoubleToRawFix32()".
+///				number, so you would have to use the syntax "myFpNum.rawVal_ = DoubleToRawFix32()".
 /// \warning	Slow!
 template <uint8_t q>
 int32_t DoubleToRawFix32(double f) {
@@ -172,74 +172,84 @@ template <class BaseType, class OverflowType, uint8_t numFracBits>
 class FpF {
 
 	public:
-	
-	/// \brief		The fixed-point number is stored in this basic data type.
-	BaseType rawVal;			
+
+	//===============================================================================================//
+	//================================== CONSTRUCTORS/DESTRUCTORS ===================================//
+	//===============================================================================================//		
 
 	FpF()
 	{
 		#if(fpConfig_PRINT_DEBUG_GENERAL == 1)
 			//Port::DebugPrint("FP: New fixed-point object created.");
 		#endif
 	}
+
+	//===============================================================================================//
+	//========================================= GETTERS/SETTERS =====================================//
+	//===============================================================================================//
+	
+	/// \brief		Get the raw value (memory representation) of this fixed-point number,
+	BaseType GetRawVal() const {
+		return rawVal_;
+	}
 
 	FpF(int8_t i) :
-		rawVal((int32_t)i << numFracBits)	{}
+		rawVal_((int32_t)i << numFracBits)	{}
 
 	FpF(int16_t i) :
-		rawVal((int32_t)i << numFracBits)	{}
+		rawVal_((int32_t)i << numFracBits)	{}
 
 	FpF(int32_t i) :
-		rawVal(i << numFracBits) { }
+		rawVal_(i << numFracBits) { }
 
 	/// \brief		Constructor that accepts a float.
 	FpF(float f) :
-		rawVal((BaseType)(f * (float)(1 << numFracBits))) {}
+		rawVal_((BaseType)(f * (float)(1 << numFracBits))) {}
 
 
 	FpF(double f) :
-		rawVal((BaseType)(f * (double)(1 << numFracBits))) {}
+		rawVal_((BaseType)(f * (double)(1 << numFracBits))) {}
 
 	// Compound Arithmetic Overloads
 
 	FpF& operator += (FpF r) {
-		rawVal += r.rawVal;
+		rawVal_ += r.rawVal_;
 		return *this;
 	}
 
 	FpF& operator -= (FpF r) {
-		rawVal -= r.rawVal;
+		rawVal_ -= r.rawVal_;
 		return *this;
 	}
 
 	/// \brief		Overlaod for '*=' operator.
 	/// \details	Uses intermediatary casting to int64_t to prevent overflows.
 	FpF& operator *= (FpF r) {				
-		rawVal = FpFMultiply<BaseType, OverflowType, numFracBits>(rawVal, r.rawVal);
+		rawVal_ = FpFMultiply<BaseType, OverflowType, numFracBits>(rawVal_, r.rawVal_);
 		return *this;
 	}
 
 	/// \brief		Overlaod for '/=' operator.
 	/// \details	Uses intermediatary casting to int64_t to prevent overflows.
 	FpF& operator /= (FpF r) {
-		rawVal = fixdiv<numFracBits>(rawVal, r.rawVal);
+		rawVal_ = fixdiv<numFracBits>(rawVal_, r.rawVal_);
 		return *this;
 	}
 
 	/// \brief		Overlaod for '%=' operator.
 	FpF& operator %= (FpF r) {
-		rawVal %= r.rawVal;
+		rawVal_ %= r.rawVal_;
 		return *this;
 	}
 
 
 	FpF& operator *= (int32_t r) {
-		rawVal *= r;
+		rawVal_ *= r;
 		return *this;
 	}
 
 	FpF& operator /= (int32_t r) { 
-		rawVal /= r;
+		rawVal_ /= r;
 		return *this;
 	}
 
@@ -248,7 +258,7 @@ class FpF {
 	/// \brief		Overload for '-itself' operator.
 	FpF operator - () const	{
 		FpF x;
-		x.rawVal = -rawVal;
+		x.rawVal_ = -rawVal_;
 		return x;
 	}
 
@@ -304,7 +314,7 @@ class FpF {
 
 	bool operator == (FpF r) const
 	{
-		return rawVal == r.rawVal;
+		return rawVal_ == r.rawVal_;
 	}
 
 	bool operator != (const FpF &r)
@@ -314,61 +324,77 @@ class FpF {
 
 	bool operator <  (const FpF &r)
 	{
-		return rawVal < r.rawVal;
+		return rawVal_ < r.rawVal_;
 	}
 
 	bool operator >  (const FpF &r)
 	{
-		return rawVal > r.rawVal;
+		return rawVal_ > r.rawVal_;
 	}
 
 	bool operator <= (FpF r) const
 	{
-		return rawVal <= r.rawVal;
+		return rawVal_ <= r.rawVal_;
 	}
 
 	bool operator >= (FpF r) const
 	{
-		return rawVal >= r.rawVal;
+		return rawVal_ >= r.rawVal_;
 	}
 
 	/// \defgroup From FpF Conversion Overloads (casts)
 	/// \{
-	
+
+
+	/// \brief		Converts the fixed-point number into an integer.
+	/// \details	Always rounds to negative infinity (66.3 becomes 66, -66.3 becomes -67).
+	/// \tparam		IntType		The return integer type.
+	template <class IntType>
+	IntType ToInt() const {
+		// Right-shift to get rid of all the decimal bits
+		// This rounds towards negative infinity
+		return (IntType)(rawVal_ >> numFracBits);
+	}
+
+	/// \brief		Converts the fixed-point number to a float.
+	float ToFloat() const {
+		return (float)rawVal_ / (float)(1 << numFracBits);
+	}
+
 	/// \brief		Converts the fixed-point number to a double.
 	double ToDouble() const {
-		return (double)rawVal / (double)(1 << numFracBits);
+		return (double)rawVal_ / (double)(1 << numFracBits);
 	}
 
 	/// \brief		Conversion operator from fixed-point to int16_t.
 	/// \warning	Possible loss of accuracy from conversion from
 	///				int32_t to int16_t.
 	operator int16_t() {
 		// Right-shift to get rid of all the decimal bits (truncate)
-		return (int16_t)(rawVal >> numFracBits);
+		return (int16_t)(rawVal_ >> numFracBits);
 	}
 
 	/// \brief		Conversion operator from fixed-point to int32_t.
 	operator int32_t() {
 		// Right-shift to get rid of all the decimal bits (truncate)
-		return (rawVal >> numFracBits);
+		return (rawVal_ >> numFracBits);
 	}
 
 	/// \brief		Conversion operator from fixed-point to int64_t.
 	operator int64_t() {
 		// Right-shift to get rid of all the decimal bits (truncate)
-		return (int64_t)(rawVal >> numFracBits);
+		return (int64_t)(rawVal_ >> numFracBits);
 	}
 
 	/// \brief		Conversion operator from fixed-point to float.
 	operator float() { 
-		return (float)rawVal / (float)(1 << numFracBits);
+		return (float)rawVal_ / (float)(1 << numFracBits);
 	}
 
 	/// \brief		Conversion operator from fixed-point to double.
 	/// \note		Similar to float conversion.
 	operator double() { 
-		return (double)rawVal / (double)(1 << numFracBits);
+		return (double)rawVal_ / (double)(1 << numFracBits);
 	}
 
 	/// \}
@@ -402,30 +428,35 @@ class FpF {
 	}
 
 	bool operator >  (int32_t r) const {
-		return rawVal > (r << numFracBits);
+		return rawVal_ > (r << numFracBits);
 	}
 
 	bool operator >=  (int32_t r) const {
-		return rawVal >= (r << numFracBits);
+		return rawVal_ >= (r << numFracBits);
 	}
 
 	bool operator <  (int32_t r) const {
-		return rawVal < (r << numFracBits);
+		return rawVal_ < (r << numFracBits);
 	}
 
 	bool operator <=  (int32_t r) const	{
-		return rawVal < (r << numFracBits);
+		return rawVal_ < (r << numFracBits);
 	}
 
 	bool operator ==  (int32_t r) const	{
-		return rawVal == (r << numFracBits);
+		return rawVal_ == (r << numFracBits);
 	}
 
 	bool operator !=  (int32_t r) const	{
-		return rawVal != (r << numFracBits);
+		return rawVal_ != (r << numFracBits);
 	}
 
 	/// \}
+
+	private:
+
+	/// \brief		The fixed-point number is stored in this basic data type.
+	BaseType rawVal_;
 
 };
 
@@ -492,7 +523,7 @@ using FpF64 = FpF<int64_t, int64_t, numFracBits>;
 // inline FpF<numFracBits> abs(FpF<numFracBits> a)
 // { 
 // 	FpF<numFracBits> r; 
-// 	r.rawVal = a.rawVal > 0 ? a.rawVal : -a.rawVal; 
+// 	r.rawVal_ = a.rawVal_ > 0 ? a.rawVal_ : -a.rawVal_; 
 // 	return r; 
 // }
 
@@ -502,15 +533,15 @@ using FpF64 = FpF<int64_t, int64_t, numFracBits>;
 // inline FpF<16> sin(FpF<16> a)
 // {
 // 	FpF<16> r;
-// 	r.rawVal = fixsin16(a.rawVal);
+// 	r.rawVal_ = fixsin16(a.rawVal_);
 // 	return r;
 // }
 
 // template <>
 // inline FpF<16> cos(FpF<16> a)
 // {
 // 	FpF<16> r;
-// 	r.rawVal = fixcos16(a.rawVal);
+// 	r.rawVal_ = fixcos16(a.rawVal_);
 // 	return r;
 // }
 
@@ -519,23 +550,23 @@ using FpF64 = FpF<int64_t, int64_t, numFracBits>;
 // inline FpF<16> sqrt(FpF<16> a)
 // {
 // 	FpF<16> r;
-// 	r.rawVal = fixsqrt16(a.rawVal);
+// 	r.rawVal_ = fixsqrt16(a.rawVal_);
 // 	return r;
 // }
 
 // template <>
 // inline FpF<16> rsqrt(FpF<16> a)
 // {
 // 	FpF<16> r;
-// 	r.rawVal = fixrsqrt16(a.rawVal);
+// 	r.rawVal_ = fixrsqrt16(a.rawVal_);
 // 	return r;
 // }
 
 // template <>
 // inline FpF<16> inv(FpF<16> a)
 // {
 // 	FpF<16> r;
-// 	r.rawVal = fixinv<16>(a.rawVal);
+// 	r.rawVal_ = fixinv<16>(a.rawVal_);
 // 	return r;
 // }
 
@@ -548,9 +579,9 @@ using FpF64 = FpF<int64_t, int64_t, numFracBits>;
 // {
 // 	long long result = 0;
 // 	for (int32_t i = 0; i < count; ++i)
-// 		result += static_cast<long long>(a[i].rawVal) * b[i].rawVal;
+// 		result += static_cast<long long>(a[i].rawVal_) * b[i].rawVal_;
 // 	FpF<numFracBits> r;
-// 	r.rawVal = static_cast<int32_t>(result >> numFracBits);
+// 	r.rawVal_ = static_cast<int32_t>(result >> numFracBits);
 // 	return r;
 // }
 

include/MFixedPoint/FpS.hpp

@@ -396,7 +396,7 @@ class FpS {
 	///				constructor).
 	uint8_t numFracBits_;
 
-};
+}; // class FpS
 
 //===============================================================================================//
 //========================================= SPECIALIZATIONS =====================================//