Merge branch 'develop'

Author: Geoffrey Hunter

CHANGELOG.md

@@ -6,6 +6,21 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+## [v8.0.0-beta.2] - 2018-01-11
+
+### 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.
+- Fixed failing `sudo make install` command.
+- Fixed failing FpF multiplication.
+- Fixed bug where `FpF` constructor accepting a double was first converting value to a float.
+- Example in README now compiles correctly.
+- Fixed bug where bit-shifting was overflowing in fixed-point constructors from doubles because '1' was not being cast to BaseType first.
+
 ## [v8.0.0-beta.1] - 2018-01-09
 
 ### Added
@@ -34,3 +49,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 ### Changed
 - Changed the `Fp` namespace to `MFixedPoint` (to reflect actual project name), closes #86.
 - Modified header guard macros to include the text `MN_MFIXEDPOINT_...` (to include organization/project name).
+
+[Unreleased]: https://github.com/mbedded-ninja/CppTemplate/compare/v8.0.0-beta.2...HEAD
+[v8.0.0-beta.2]: https://github.com/mbedded-ninja/CppTemplate/compare/v8.0.0-beta.1...v8.0.0-beta.2
+[v8.0.0-beta.1]: https://github.com/mbedded-ninja/CppTemplate/compare/v7.0.1...v8.0.0-beta.1
+[v7.0.1]: https://github.com/mbedded-ninja/CppTemplate/compare/v7.0.0...v7.0.1

CMakeLists.txt

@@ -64,5 +64,10 @@ if(BUILD_TESTS)
 endif()
 add_subdirectory(benchmark)
 
+add_subdirectory(example)
+
+# On Linux, "sudo make install" will typically copy the 
+# folder into /usr/local/include
+install(DIRECTORY ${CMAKE_SOURCE_DIR}/include/MFixedPoint DESTINATION include)
 
 

README.rst

@@ -127,11 +127,6 @@ This library has been tested on:
 - Linux (Ubuntu)
 - A CodeAnywhere "DevBox"
 
-Configuration
-=============
-
-Configuration settings are in :code:`include/Config.hpp`. This file allows you to turn on/off debug message printing (which itself is port-specific, and defined in :code:`include/Port.hpp/cpp`).
-
 Compiling
 =========
 
@@ -149,55 +144,74 @@ The cmake method will build the fixed point library and automatically runs all u
 	~/MFixedPoint/build$ cmake ..
 	~/MFixedPoint/build$ make
 	
-You can then the tests by calling:
+You can run the tests manually by calling:
 
 .. code:: bash
 
 	~/MFixedPoint/build$ ./test/MFixedPointTests
 
-Usage
-=====
+Examples
+========
 
 See the unit tests in :code:`test/` for more usage examples!
 
 .. code:: cpp
 
-	// Include the API header which provides access to all of the fixed-point
-	// data types
-	#include "MFixedPoint/api/MFixedPointApi.hpp"
+	// System includes
+	#include <iostream>
+
+	// 3rd party includes
+	#include "MFixedPoint/FpS.hpp"
+	#include "MFixedPoint/FpF.hpp"
+
+	using namespace mn::MFixedPoint;
+
+	int main() {
+
+		//================================================================================================//
+		//================================= Slow Fixed-Point Numbers (FpS) ===============================//
+		//================================================================================================//
+
+		// Creating a 32-bit "slow" fixed-point number (notice the slightly different syntax to FpF)
+		FpS32 fpSNum1(12.23, 12);
+		std::cout << "fpSNum1 = " << (double)fpSNum1 << std::endl;
+
+		FpS32 fpSNum2(5.12, 16);
+		std::cout << "fpSNum2 = " << (double)fpSNum2 << std::endl;
+		
+		std::cout << "fpSNum1 + fpSNum2 = " << (double)(fpSNum1 + fpSNum2) << std::endl;
+		std::cout << "fpSNum1 - fpSNum2 = " << (double)(fpSNum1 - fpSNum2) << std::endl;
+		std::cout << "fpSNum1 * fpSNum2 = " << (double)(fpSNum1 * fpSNum2) << std::endl;
+		std::cout << "fpSNum1 / fpSNum2 = " << (double)(fpSNum1 / fpSNum2) << std::endl;
+		std::cout << "fpSNum1 % fpSNum2 = " << (double)(fpSNum1 % fpSNum2) << std::endl;
+
+		//================================================================================================//
+		//================================= Fast Fixed-Point Numbers (FpF) ===============================//
+		//================================================================================================//
 
-	int main()
-	{
 		// Create two 32-bit fast fixed-point numbers with 24 decimal bits and 8 fractional bits.
 		// This constructor converts from doubles
-		Fp32f<8> aFpNum1 = Fp32f<8>(3.2);
-		Fp32f<8> aFpNum2 = Fp32f<8>(0.6);
+		FpF32<8> fpNum1(3.2);
+		FpF32<8> fpNum2(0.6);
 		
 		// Performing a quick fixed-point addition
-		Fp32f<8> aFpNum3 = aFpNum1 + aFpNum2;
+		auto fpNum3 = fpNum1 + fpNum2;
 		
 		// Performing a quick fixed-point multiplication
-		Fp32f<8> aFpNm4 = aFpNum1 * aFpNum2;
+		auto fpNum4 = fpNum1 * fpNum2;
 		
 		// Printing the result as a double, using the Fix32ToDouble() method
 		// Note that if you use slow fixed-point data type instead, you can 
 		// directly cast one to a double 
-		std::cout << "My fast 32-bit fixed-point number = " << Fix32ToDouble(aFpNum4);
+		std::cout << "My fast 32-bit fixed-point number = " << (double)fpNum4;
 		
 		// Converting between different precisions. Requires access to raw value just like
 		// when doing fixed-point to double conversion.
-		Fp32f<20> aHigherPrecisionNum = Fp32f<20>(7.5);
-		Fp32f<12> aLowerPrecisionNum.rawVal = aHigherPrecisionNum.rawVal >> (20 - 12);
+		FpF32<20> aHigherPrecisionNum(7.5);
+		// FpF32<12> aLowerPrecisionNum.rawVal = aHigherPrecisionNum.rawVal >> (20 - 12);
 		
 		// You can use 64-bit fixed point numbers in exactly the same way!
-		Fp64f<48> aFp64Num = Fp64f<48>(4.58676);
-		
-		// Creating a 32-bit slow fixed-point number (notice the slightly different syntax)
-		Fp32s mySlowFp32Num = Fp32s(12.23, 12);
-		
-		// You can cast slow 32-bit fixed-point numbers back to doubles
-		// (you can't do this with the fast fixed-point data types)
-		std::cout << "My slow 32-bit fixed-point number = " << (double)mySlowFp32Num; 
+		FpF64<48> aFp64Num(4.58676);
 		
 		return 0;
 	}

benchmark/CMakeLists.txt

@@ -5,7 +5,7 @@ file(GLOB_RECURSE MFixedPoint_Benchmark_SRC
 add_executable (MFixedPoint_Benchmark ${MFixedPoint_Benchmark_SRC})
 target_compile_options(MFixedPoint_Benchmark PUBLIC -Wall)
 
-target_link_libraries(MFixedPoint_Benchmark LINK_PUBLIC MFixedPoint)
+# target_link_libraries(MFixedPoint_Benchmark LINK_PUBLIC MFixedPoint)
 
 add_custom_target(
     fake_target_to_run_benchmark ALL

example/CMakeLists.txt

@@ -0,0 +1,4 @@
+
+
+add_executable(ReadmeExample ReadmeExample.cpp)
+

example/ReadmeExample.cpp

@@ -0,0 +1,68 @@
+///
+/// \file 				ReadmeExample.cpp
+/// \author 			Geoffrey Hunter <[email protected]> (www.mbedded.ninja)
+/// \edited 			n/a
+/// \created			2018-01-10
+/// \last-modified		2017-01-11
+/// \brief 				Contains the example code that is shown in the README.
+/// \details
+///						See README.rst in root dir for more info.
+
+// System includes
+#include <iostream>
+
+// 3rd party includes
+#include "MFixedPoint/FpS.hpp"
+#include "MFixedPoint/FpF.hpp"
+
+using namespace mn::MFixedPoint;
+
+int main() {
+
+    //================================================================================================//
+    //================================= Slow Fixed-Point Numbers (FpS) ===============================//
+    //================================================================================================//
+
+    // Creating a 32-bit "slow" fixed-point number (notice the slightly different syntax to FpF)
+    FpS32 fpSNum1(12.23, 12);
+    std::cout << "fpSNum1 = " << (double)fpSNum1 << std::endl;
+
+    FpS32 fpSNum2(5.12, 16);
+    std::cout << "fpSNum2 = " << (double)fpSNum2 << std::endl;
+    
+    std::cout << "fpSNum1 + fpSNum2 = " << (double)(fpSNum1 + fpSNum2) << std::endl;
+    std::cout << "fpSNum1 - fpSNum2 = " << (double)(fpSNum1 - fpSNum2) << std::endl;
+    std::cout << "fpSNum1 * fpSNum2 = " << (double)(fpSNum1 * fpSNum2) << std::endl;
+    std::cout << "fpSNum1 / fpSNum2 = " << (double)(fpSNum1 / fpSNum2) << std::endl;
+    std::cout << "fpSNum1 % fpSNum2 = " << (double)(fpSNum1 % fpSNum2) << std::endl;
+
+    //================================================================================================//
+    //================================= Fast Fixed-Point Numbers (FpF) ===============================//
+    //================================================================================================//
+
+    // Create two 32-bit fast fixed-point numbers with 24 decimal bits and 8 fractional bits.
+    // This constructor converts from doubles
+    FpF32<8> fpNum1(3.2);
+    FpF32<8> fpNum2(0.6);
+    
+    // Performing a quick fixed-point addition
+    auto fpNum3 = fpNum1 + fpNum2;
+    
+    // Performing a quick fixed-point multiplication
+    auto fpNum4 = fpNum1 * fpNum2;
+    
+    // Printing the result as a double, using the Fix32ToDouble() method
+    // Note that if you use slow fixed-point data type instead, you can 
+    // directly cast one to a double 
+    std::cout << "My fast 32-bit fixed-point number = " << (double)fpNum4;
+    
+    // Converting between different precisions. Requires access to raw value just like
+    // when doing fixed-point to double conversion.
+    FpF32<20> aHigherPrecisionNum(7.5);
+    // FpF32<12> aLowerPrecisionNum.rawVal = aHigherPrecisionNum.rawVal >> (20 - 12);
+    
+    // You can use 64-bit fixed point numbers in exactly the same way!
+    FpF64<48> aFp64Num(4.58676);
+    
+    return 0;
+}