Merge pull request #25 from maruncz/master

Added CMakeLists.txt and some fixes

8 files changed, 294 insertions, 95 deletions

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..a6cb559
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1,160 @@
+# This file is used to ignore files which are generated
+# ----------------------------------------------------------------------------
+
+*~
+*.autosave
+*.a
+*.core
+*.moc
+*.o
+*.obj
+*.orig
+*.rej
+*.so
+*.so.*
+*_pch.h.cpp
+*_resource.rc
+*.qm
+.#*
+*.*#
+core
+!core/
+tags
+.DS_Store
+.directory
+*.debug
+Makefile*
+*.prl
+*.app
+moc_*.cpp
+ui_*.h
+qrc_*.cpp
+Thumbs.db
+*.res
+*.rc
+/.qmake.cache
+/.qmake.stash
+
+# qtcreator generated files
+*.pro.user*
+
+# xemacs temporary files
+*.flc
+
+# Vim temporary files
+.*.swp
+
+# Visual Studio generated files
+*.ib_pdb_index
+*.idb
+*.ilk
+*.pdb
+*.sln
+*.suo
+*.vcproj
+*vcproj.*.*.user
+*.ncb
+*.sdf
+*.opensdf
+*.vcxproj
+*vcxproj.*
+
+# MinGW generated files
+*.Debug
+*.Release
+
+# Python byte code
+*.pyc
+
+# Binaries
+# --------
+*.dll
+*.exe
+
+# Prerequisites
+*.d
+
+# Compiled Object files
+*.slo
+*.lo
+*.o
+*.obj
+
+# Precompiled Headers
+*.gch
+*.pch
+
+# Compiled Dynamic libraries
+*.so
+*.dylib
+*.dll
+
+# Fortran module files
+*.mod
+*.smod
+
+# Compiled Static libraries
+*.lai
+*.la
+*.a
+*.lib
+
+# Executables
+*.exe
+*.out
+*.app
+
+# C++ objects and libs
+*.slo
+*.lo
+*.o
+*.a
+*.la
+*.lai
+*.so
+*.so.*
+*.dll
+*.dylib
+
+# Qt-es
+object_script.*.Release
+object_script.*.Debug
+*_plugin_import.cpp
+/.qmake.cache
+/.qmake.stash
+*.pro.user
+*.pro.user.*
+*.qbs.user
+*.qbs.user.*
+*.moc
+moc_*.cpp
+moc_*.h
+qrc_*.cpp
+ui_*.h
+*.qmlc
+*.jsc
+Makefile*
+*build-*
+*.qm
+*.prl
+
+# Qt unit tests
+target_wrapper.*
+
+# QtCreator
+*.autosave
+
+# QtCreator Qml
+*.qmlproject.user
+*.qmlproject.user.*
+
+# QtCreator CMake
+CMakeLists.txt.user*
+
+# QtCreator 4.8< compilation database 
+compile_commands.json
+
+# QtCreator local machine specific files for imported projects
+*creator.user*
+
+*_qmlcache.qrc
diff --git a/CMakeLists.txt b/CMakeLists.txt
new file mode 100644
index 0000000..75b7322
--- /dev/null
+++ b/CMakeLists.txt
@@ -0,0 +1,28 @@
+cmake_minimum_required(VERSION 3.5)
+
+project(libfixmath LANGUAGES CXX C)
+
+set(CMAKE_C_STANDARD 11)
+set(CMAKE_C_STANDARD_REQUIRED ON)
+set(CMAKE_C_FLAGS "-Wall -pedantic -Wextra")
+
+set(CMAKE_CXX_STANDARD 20)
+set(CMAKE_CXX_STANDARD_REQUIRED ON)
+set(CMAKE_CXX_FLAGS "-Wall -pedantic -Wextra")
+
+file(GLOB libfixmath-srcs libfixmath/*.h libfixmath/*.hpp libfixmath/*.c)
+file(GLOB contrib-srcs contrib/*.c)
+file(GLOB fixsingen-srcs fixsingen/*.c)
+file(GLOB fixtest-srcs fixtest/*.c fixtest/*.h)
+
+add_library(libfixmath STATIC ${libfixmath-srcs} ${contrib-srcs})
+target_include_directories(libfixmath PRIVATE ${CMAKE_SOURCE_DIR})
+
+add_executable(fixtest ${fixtest-srcs})
+target_link_libraries(fixtest PRIVATE libfixmath m)
+target_include_directories(fixtest PRIVATE ${CMAKE_SOURCE_DIR})
+
+
+add_executable(fixsingen ${fixsingen-srcs})
+target_link_libraries(fixsingen PRIVATE libfixmath m)
+target_include_directories(fixsingen PRIVATE ${CMAKE_SOURCE_DIR})
diff --git a/contrib/fix16_fft.c b/contrib/fix16_fft.c
index a3709ba..8259083 100644
--- a/contrib/fix16_fft.c
+++ b/contrib/fix16_fft.c
@@ -9,7 +9,7 @@
  */
 
 #include <stdint.h>
-#include <fix16.h>
+#include <libfixmath/fix16.h>
 
 // You can change the input datatype and intermediate scaling here.
 // By default, the output is divided by the transform length to get a normalized FFT.
diff --git a/fixtest/hiclock.c b/fixtest/hiclock.c
index 94ed735..5ce58df 100644
--- a/fixtest/hiclock.c
+++ b/fixtest/hiclock.c
@@ -1,25 +1,28 @@
 #include "hiclock.h"

+#include <stddef.h>

 

 #if defined(__WIN32) || defined(__WIN64)

 LONGLONG HICLOCKS_PER_SEC = 0;

 

-void hiclock_init() {

+void hiclock_init()

+{

 	LARGE_INTEGER freq;

 	QueryPerformanceFrequency(&freq);

 	HICLOCKS_PER_SEC = freq.QuadPart;

 }

 #endif

 

-hiclock_t hiclock() {

-	#if defined(__unix__)

-	timeval clocks;

+hiclock_t hiclock()

+{

+#if defined(__unix__)

+	struct timeval clocks;

 	gettimeofday(&clocks, NULL);

 	return ((uint64_t)clocks.tv_sec * 1000000ULL) + clocks.tv_usec;

-	#elif defined(__WIN32) || defined(__WIN64)

+#elif defined(__WIN32) || defined(__WIN64)

 	LARGE_INTEGER clocks;

 	QueryPerformanceCounter(&clocks);

 	return clocks.QuadPart;

-	#else

+#else

 	return clock();

-	#endif

+#endif

 }

diff --git a/fixtest/main.c b/fixtest/main.c
index e4f105a..5f6dd92 100644
--- a/fixtest/main.c
+++ b/fixtest/main.c
@@ -1,87 +1,96 @@
+#include "hiclock.h"

+#include <inttypes.h>

+#include <libfixmath/fixmath.h>

+#include <math.h>

 #include <stdio.h>

 #include <stdlib.h>

-#include <math.h>

 #include <time.h>

-#include <inttypes.h>

-

-#include <libfixmath/fixmath.h>

-

-#include "hiclock.h"

-

-//#define fix_func      fix16_exp

-//#define fix_func_str "fix16_exp"

-//#define flt_func      expf

-//#define flt_func_str "expf"

 

-//#define fix_func      fix16_atan

-//#define fix_func_str "fix16_atan"

-//#define flt_func      atanf

-//#define flt_func_str "atanf"

-

-#define fix_func      fix16_sin

+#define EXP

+//#define ATAN

+//#define SIN

+//#define SQRT

+

+#ifdef EXP

+#define fix_func     fix16_exp

+#define fix_func_str "fix16_exp"

+#define flt_func     expf

+#define flt_func_str "expf"

+#endif

+

+#ifdef ATAN

+#define fix_func     fix16_atan

+#define fix_func_str "fix16_atan"

+#define flt_func     atanf

+#define flt_func_str "atanf"

+#endif

+

+#ifdef SIN

+#define fix_func     fix16_sin

 #define fix_func_str "fix16_sin"

-#define flt_func      sinf

+#define flt_func     sinf

 #define flt_func_str "sinf"

+#endif

 

-//#define fix_func      fix16_sqrt

-//#define fix_func_str "fix16_sqrt"

-//#define flt_func      sqrtf

-//#define flt_func_str "sqrtf"

-

-

+#ifdef SQRT

+#define fix_func     fix16_sqrt

+#define fix_func_str "fix16_sqrt"

+#define flt_func     sqrtf

+#define flt_func_str "sqrtf"

+#endif

 

-int main(int argc, char** argv) {

-    printf("libfixmath test tool\n");

+int main(int argc, char **argv)

+{

+	printf("libfixmath test tool\n");

 

-    hiclock_init();

+	hiclock_init();

 

-	uintptr_t args = (1 <<  8);

-	uintptr_t iter = (1 <<  8);

-	uintptr_t pass = (1 <<  8);

+	uintptr_t args = (1 << 8);

+	uintptr_t iter = (1 << 8);

+	uintptr_t pass = (1 << 8);

 

 	uintptr_t i;

 	srand(time(NULL));

 

 	hiclock_t fix_duration = 0;

 	hiclock_t flt_duration = 0;

-	fix16_t   fix_error = 0;

+	fix16_t   fix_error	= 0;

 

 	uintptr_t k;

-	for(k = 0; k < pass; k++) {

+	for (k = 0; k < pass; k++)

+	{

 		fix16_t fix_args[args];

-		for(i = 0; i < args; i++)

-			fix_args[i] = (rand() ^ (rand() << 16));

-		fix16_t fix_result[args];

+		for (i = 0; i < args; i++) fix_args[i] = (rand() ^ (rand() << 16));

+		fix16_t   fix_result[args];

 		hiclock_t fix_start = hiclock();

-		for(i = 0; i < iter; i++) {

+		for (i = 0; i < iter; i++)

+		{

 			uintptr_t j;

-			for(j = 0; j < args; j++)

-				fix_result[j] = fix_func(fix_args[j]);

+			for (j = 0; j < args; j++) fix_result[j] = fix_func(fix_args[j]);

 		}

 		hiclock_t fix_end = hiclock();

 

-		float   flt_args[args];

-		for(i = 0; i < args; i++)

-			flt_args[i] = fix16_to_float(fix_args[i]);

-		float   flt_result[args];

+		float flt_args[args];

+		for (i = 0; i < args; i++) flt_args[i] = fix16_to_float(fix_args[i]);

+		float flt_result[args];

 		hiclock_t flt_start = hiclock();

-		for(i = 0; i < iter; i++) {

+		for (i = 0; i < iter; i++)

+		{

 			uintptr_t j;

-			for(j = 0; j < args; j++)

-				flt_result[j] = flt_func(flt_args[j]);

+			for (j = 0; j < args; j++) flt_result[j] = flt_func(flt_args[j]);

 		}

 		hiclock_t flt_end = hiclock();

 

-		for(i = 0; i < args; i++)

+		for (i = 0; i < args; i++)

 			fix_error += abs(fix16_from_float(flt_result[i]) - fix_result[i]);

 		flt_duration += (flt_end - flt_start);

 		fix_duration += (fix_end - fix_start);

 	}

 

-	printf("%16s: %08"PRIuHICLOCK" @ %"PRIu32"Hz\n", flt_func_str, flt_duration, HICLOCKS_PER_SEC);

-	printf("%16s: %08"PRIuHICLOCK" @ %"PRIu32"Hz\n", fix_func_str, fix_duration, HICLOCKS_PER_SEC);

-	printf("      Difference: %08"PRIiHICLOCK" (% 3.2f%%)\n", (flt_duration - fix_duration), ((fix_duration * 100.0) / flt_duration));

+	printf("%16s: %08" PRIuHICLOCK " @ %" PRIu32 "Hz\n", flt_func_str, flt_duration, HICLOCKS_PER_SEC);

+	printf("%16s: %08" PRIuHICLOCK " @ %" PRIu32 "Hz\n", fix_func_str, fix_duration, HICLOCKS_PER_SEC);

+	printf("      Difference: %08" PRIiHICLOCK " (% 3.2f%%)\n", (flt_duration - fix_duration), ((fix_duration * 100.0) / flt_duration));

 	printf("           Error: %f%%\n", ((fix16_to_dbl(fix_error) * 100.0) / (args * pass)));

 

-    return EXIT_SUCCESS;

+	return EXIT_SUCCESS;

 }

diff --git a/images/error_analysis.ods b/images/error_analysis.ods
index e410dd3..e2d7e90 100644
--- a/images/error_analysis.ods
+++ b/images/error_analysis.ods
diff --git a/libfixmath/fix16.hpp b/libfixmath/fix16.hpp
index dc8a5b7..7330c60 100644
--- a/libfixmath/fix16.hpp
+++ b/libfixmath/fix16.hpp
@@ -105,41 +105,41 @@ class Fix16 {
 		const Fix16 sdiv(const int16_t other) const { Fix16 ret = fix16_sdiv(value, fix16_from_int(other));   return ret; }

 #endif

 

-		const int operator==(const Fix16 &other)  const { return (value == other.value);             }

-		const int operator==(const fix16_t other) const { return (value == other);                   }

-		const int operator==(const double other)  const { return (value == fix16_from_dbl(other));   }

-		const int operator==(const float other)   const { return (value == fix16_from_float(other)); }

-		const int operator==(const int16_t other) const { return (value == fix16_from_int(other));   }

-

-		const int operator!=(const Fix16 &other)  const { return (value != other.value);             }

-		const int operator!=(const fix16_t other) const { return (value != other);                   }

-		const int operator!=(const double other)  const { return (value != fix16_from_dbl(other));   }

-		const int operator!=(const float other)   const { return (value != fix16_from_float(other)); }

-		const int operator!=(const int16_t other) const { return (value != fix16_from_int(other));   }

-

-		const int operator<=(const Fix16 &other)  const { return (value <= other.value);             }

-		const int operator<=(const fix16_t other) const { return (value <= other);                   }

-		const int operator<=(const double other)  const { return (value <= fix16_from_dbl(other));   }

-		const int operator<=(const float other)   const { return (value <= fix16_from_float(other)); }

-		const int operator<=(const int16_t other) const { return (value <= fix16_from_int(other));   }

-

-		const int operator>=(const Fix16 &other)  const { return (value >= other.value);             }

-		const int operator>=(const fix16_t other) const { return (value >= other);                   }

-		const int operator>=(const double other)  const { return (value >= fix16_from_dbl(other));   }

-		const int operator>=(const float other)   const { return (value >= fix16_from_float(other)); }

-		const int operator>=(const int16_t other) const { return (value >= fix16_from_int(other));   }

-

-		const int operator< (const Fix16 &other)  const { return (value <  other.value);             }

-		const int operator< (const fix16_t other) const { return (value <  other);                   }

-		const int operator< (const double other)  const { return (value <  fix16_from_dbl(other));   }

-		const int operator< (const float other)   const { return (value <  fix16_from_float(other)); }

-		const int operator< (const int16_t other) const { return (value <  fix16_from_int(other));   }

-

-		const int operator> (const Fix16 &other)  const { return (value >  other.value);             }

-		const int operator> (const fix16_t other) const { return (value >  other);                   }

-		const int operator> (const double other)  const { return (value >  fix16_from_dbl(other));   }

-		const int operator> (const float other)   const { return (value >  fix16_from_float(other)); }

-		const int operator> (const int16_t other) const { return (value >  fix16_from_int(other));   }

+		int operator==(const Fix16 &other)  const { return (value == other.value);             }

+		int operator==(const fix16_t other) const { return (value == other);                   }

+		int operator==(const double other)  const { return (value == fix16_from_dbl(other));   }

+		int operator==(const float other)   const { return (value == fix16_from_float(other)); }

+		int operator==(const int16_t other) const { return (value == fix16_from_int(other));   }

+

+		int operator!=(const Fix16 &other)  const { return (value != other.value);             }

+		int operator!=(const fix16_t other) const { return (value != other);                   }

+		int operator!=(const double other)  const { return (value != fix16_from_dbl(other));   }

+		int operator!=(const float other)   const { return (value != fix16_from_float(other)); }

+		int operator!=(const int16_t other) const { return (value != fix16_from_int(other));   }

+

+		int operator<=(const Fix16 &other)  const { return (value <= other.value);             }

+		int operator<=(const fix16_t other) const { return (value <= other);                   }

+		int operator<=(const double other)  const { return (value <= fix16_from_dbl(other));   }

+		int operator<=(const float other)   const { return (value <= fix16_from_float(other)); }

+		int operator<=(const int16_t other) const { return (value <= fix16_from_int(other));   }

+

+		int operator>=(const Fix16 &other)  const { return (value >= other.value);             }

+		int operator>=(const fix16_t other) const { return (value >= other);                   }

+		int operator>=(const double other)  const { return (value >= fix16_from_dbl(other));   }

+		int operator>=(const float other)   const { return (value >= fix16_from_float(other)); }

+		int operator>=(const int16_t other) const { return (value >= fix16_from_int(other));   }

+

+		int operator< (const Fix16 &other)  const { return (value <  other.value);             }

+		int operator< (const fix16_t other) const { return (value <  other);                   }

+		int operator< (const double other)  const { return (value <  fix16_from_dbl(other));   }

+		int operator< (const float other)   const { return (value <  fix16_from_float(other)); }

+		int operator< (const int16_t other) const { return (value <  fix16_from_int(other));   }

+

+		int operator> (const Fix16 &other)  const { return (value >  other.value);             }

+		int operator> (const fix16_t other) const { return (value >  other);                   }

+		int operator> (const double other)  const { return (value >  fix16_from_dbl(other));   }

+		int operator> (const float other)   const { return (value >  fix16_from_float(other)); }

+		int operator> (const int16_t other) const { return (value >  fix16_from_int(other));   }

 

 		Fix16  sin() const { return Fix16(fix16_sin(value));  }

 		Fix16  cos() const { return Fix16(fix16_cos(value));  }

diff --git a/libfixmath/fix16_exp.c b/libfixmath/fix16_exp.c
index 747e77d..e804da1 100644
--- a/libfixmath/fix16_exp.c
+++ b/libfixmath/fix16_exp.c
@@ -15,8 +15,7 @@ fix16_t fix16_exp(fix16_t inValue) {
 	if(inValue <= -772243  ) return 0;

 

 	#ifndef FIXMATH_NO_CACHE

-	fix16_t tempIndex = (inValue ^ (inValue >> 16));

-	tempIndex = (inValue ^ (inValue >> 4)) & 0x0FFF;

+    fix16_t tempIndex = (inValue ^ (inValue >> 4)) & 0x0FFF;

 	if(_fix16_exp_cache_index[tempIndex] == inValue)

 		return _fix16_exp_cache_value[tempIndex];

 	#endif