From f86d73ceb320796a320498f15c48c6306a1f3eae Mon Sep 17 00:00:00 2001
From: KimNayoung <skdud1201@ajou.ac.kr>
Date: Sat, 5 Feb 2022 02:07:12 +0900
Subject: [PATCH] project
---
extra/fx_head.h | 79 ++++++++++++++++
extra/fx_s17_14.c | 104 +++++++++++++++++++++
extra/fx_s17_14.h | 37 ++++++++
extra/practice.c | 48 ++++++++++
extra/result.txt | 156 ++++++++++++++++++++++++++++++++
extra/test | Bin 0 -> 13752 bytes
extra/test.c | 36 ++++++++
fx_s17_14/Makefile | 17 ++++
fx_s17_14/fx_head.h | 79 ++++++++++++++++
fx_s17_14/fx_s17_14.c | 104 +++++++++++++++++++++
fx_s17_14/fx_s17_14.h | 37 ++++++++
fx_s17_14/project_main.c | 77 ++++++++++++++++
overflow/fx_head.h | 79 ++++++++++++++++
overflow/fx_s17_14.c | 104 +++++++++++++++++++++
overflow/fx_s17_14.h | 37 ++++++++
overflow/testcodemul.c | 22 +++++
precisiontest/fx_head.h | 79 ++++++++++++++++
precisiontest/fx_s17_14.c | 104 +++++++++++++++++++++
precisiontest/fx_s17_14.h | 37 ++++++++
precisiontest/testcodediv.c | 21 +++++
precisiontest/testcodemul.c | 21 +++++
speedtest/fx_head.h | 79 ++++++++++++++++
speedtest/fx_s17_14.c | 104 +++++++++++++++++++++
speedtest/fx_s17_14.h | 37 ++++++++
speedtest/testcodediv.c | 22 +++++
speedtest/testcodediv.txt | 162 +++++++++++++++++++++++++++++++++
speedtest/testcodemul.c | 22 +++++
speedtest/testcodemul.txt | 162 +++++++++++++++++++++++++++++++++
speedtest/testdiv_32.txt | 175 ++++++++++++++++++++++++++++++++++++
speedtest/testdiv_64.txt | 162 +++++++++++++++++++++++++++++++++
speedtest/testmul_32.txt | 162 +++++++++++++++++++++++++++++++++
speedtest/testmul_64.txt | 162 +++++++++++++++++++++++++++++++++
32 files changed, 2527 insertions(+)
create mode 100644 extra/fx_head.h
create mode 100644 extra/fx_s17_14.c
create mode 100644 extra/fx_s17_14.h
create mode 100644 extra/practice.c
create mode 100644 extra/result.txt
create mode 100755 extra/test
create mode 100644 extra/test.c
create mode 100644 fx_s17_14/Makefile
create mode 100644 fx_s17_14/fx_head.h
create mode 100644 fx_s17_14/fx_s17_14.c
create mode 100644 fx_s17_14/fx_s17_14.h
create mode 100644 fx_s17_14/project_main.c
create mode 100644 overflow/fx_head.h
create mode 100644 overflow/fx_s17_14.c
create mode 100644 overflow/fx_s17_14.h
create mode 100644 overflow/testcodemul.c
create mode 100644 precisiontest/fx_head.h
create mode 100644 precisiontest/fx_s17_14.c
create mode 100644 precisiontest/fx_s17_14.h
create mode 100644 precisiontest/testcodediv.c
create mode 100644 precisiontest/testcodemul.c
create mode 100644 speedtest/fx_head.h
create mode 100644 speedtest/fx_s17_14.c
create mode 100644 speedtest/fx_s17_14.h
create mode 100644 speedtest/testcodediv.c
create mode 100644 speedtest/testcodediv.txt
create mode 100644 speedtest/testcodemul.c
create mode 100644 speedtest/testcodemul.txt
create mode 100644 speedtest/testdiv_32.txt
create mode 100644 speedtest/testdiv_64.txt
create mode 100644 speedtest/testmul_32.txt
create mode 100644 speedtest/testmul_64.txt
diff --git a/extra/fx_head.h b/extra/fx_head.h
new file mode 100644
index 0000000..6d9bd26
--- /dev/null
+++ b/extra/fx_head.h
@@ -0,0 +1,79 @@
+#pragma once
+
+// Fixed with signed long long
+#define FX_S28_35 ((1<<16) | (28<<8) | (35))
+#define FX_S29_34 ((1<<16) | (29<<8) | (34))
+#define FX_S30_33 ((1<<16) | (30<<8) | (33))
+#define FX_S31_32 ((1<<16) | (31<<8) | (32))
+#define FX_S32_31 ((1<<16) | (32<<8) | (31))
+#define FX_S33_30 ((1<<16) | (33<<8) | (30))
+#define FX_S34_29 ((1<<16) | (34<<8) | (29))
+#define FX_S35_28 ((1<<16) | (35<<8) | (28))
+// Fixed with unsigned long long
+#define FX_U29_35 ((0<<16) | (29<<8) | (35))
+#define FX_U30_34 ((0<<16) | (30<<8) | (34))
+#define FX_U31_33 ((0<<16) | (31<<8) | (33))
+#define FX_U32_32 ((0<<16) | (32<<8) | (32))
+#define FX_U33_31 ((0<<16) | (33<<8) | (31))
+#define FX_U34_30 ((0<<16) | (34<<8) | (30))
+#define FX_U35_29 ((0<<16) | (35<<8) | (29))
+#define FX_U36_28 ((0<<16) | (36<<8) | (28))
+// Fixed with signed int
+#define FX_S12_19 ((1<<16) | (12<<8) | (19))
+#define FX_S13_18 ((1<<16) | (13<<8) | (18))
+#define FX_S14_17 ((1<<16) | (14<<8) | (17))
+#define FX_S15_16 ((1<<16) | (15<<8) | (16))
+#define FX_S16_15 ((1<<16) | (16<<8) | (15))
+#define FX_S17_14 ((1<<16) | (17<<8) | (14))
+#define FX_S18_13 ((1<<16) | (18<<8) | (13))
+#define FX_S19_12 ((1<<16) | (19<<8) | (12))
+// Fixed with unsigned int
+#define FX_S13_19 ((0<<16) | (13<<8) | (19))
+#define FX_S14_18 ((0<<16) | (14<<8) | (18))
+#define FX_S15_17 ((0<<16) | (15<<8) | (17))
+#define FX_S16_16 ((0<<16) | (16<<8) | (16))
+#define FX_S17_15 ((0<<16) | (17<<8) | (15))
+#define FX_S18_14 ((0<<16) | (18<<8) | (14))
+#define FX_S19_13 ((0<<16) | (19<<8) | (13))
+#define FX_S20_12 ((0<<16) | (20<<8) | (12))
+// Fixed with signed short
+#define FX_S04_11 ((1<<16) | (4<<8) | (11))
+#define FX_S05_10 ((1<<16) | (5<<8) | (10))
+#define FX_S06_09 ((1<<16) | (6<<8) | (9))
+#define FX_S07_08 ((1<<16) | (7<<8) | (8))
+#define FX_S08_07 ((1<<16) | (8<<8) | (7))
+#define FX_S09_06 ((1<<16) | (9<<8) | (6))
+#define FX_S10_05 ((1<<16) | (10<<8) | (5))
+#define FX_S11_04 ((1<<16) | (11<<8) | (4))
+// Fixed with unsigned short
+#define FX_S05_11 ((0<<16) | (5<<8) | (11))
+#define FX_S06_10 ((0<<16) | (6<<8) | (10))
+#define FX_S07_09 ((0<<16) | (7<<8) | (9))
+#define FX_S08_08 ((0<<16) | (8<<8) | (8))
+#define FX_S09_07 ((0<<16) | (9<<8) | (7))
+#define FX_S10_06 ((0<<16) | (10<<8) | (6))
+#define FX_S11_05 ((0<<16) | (11<<8) | (5))
+#define FX_S12_04 ((0<<16) | (12<<8) | (4))
+// Fixed with signed char
+#define FX_S00_07 ((1<<16) | (0<<8) | (7))
+#define FX_S01_06 ((1<<16) | (1<<8) | (6))
+#define FX_S02_05 ((1<<16) | (2<<8) | (5))
+#define FX_S03_04 ((1<<16) | (3<<8) | (4))
+#define FX_S04_03 ((1<<16) | (4<<8) | (3))
+#define FX_S05_02 ((1<<16) | (5<<8) | (2))
+#define FX_S06_01 ((1<<16) | (6<<8) | (1))
+// #define FX_S07_00 ((1<<16) | (7<<8) | (0)) // It is same as unsigned char
+// Fixed with unsigned char
+#define FX_S00_08 ((0<<16) | (0<<8) | (8))
+#define FX_S01_07 ((0<<16) | (1<<8) | (7))
+#define FX_S02_06 ((0<<16) | (2<<8) | (6))
+#define FX_S03_05 ((0<<16) | (3<<8) | (5))
+#define FX_S04_04 ((0<<16) | (4<<8) | (4))
+#define FX_S05_03 ((0<<16) | (5<<8) | (3))
+#define FX_S06_02 ((0<<16) | (6<<8) | (2))
+#define FX_S07_01 ((0<<16) | (7<<8) | (1))
+// Operation Preference
+#define FX_OP_FLOAT 1
+#define FX_OP_PRECISION 2
+#define FX_OP_FAIR 3
+#define FX_OP_PERFORMANCE 4
diff --git a/extra/fx_s17_14.c b/extra/fx_s17_14.c
new file mode 100644
index 0000000..88bf98c
--- /dev/null
+++ b/extra/fx_s17_14.c
@@ -0,0 +1,104 @@
+#include "fx_head.h"
+#include "fx_s17_14.h"
+
+#define fxADD(a,b) ((a)+(b))
+#define fxSUB(a,b) ((a)-(b))
+#define FX_Q_NUM_H (FX_Q_NUM/2)
+#define FX_Q_NUM_HA (FX_Q_NUM_H-FX_Q_NUM_H/2)
+#define FX_Q_NUM_HB (FX_Q_NUM_H/2)
+/*
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+*/
+
+// float function
+fixed fxAdd_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) + toDouble(b));
+}
+
+fixed fxSub_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) - toDouble(b));
+}
+
+fixed fxMul_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) * toDouble(b));
+}
+
+fixed fxDiv_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) / toDouble(b));
+}
+
+// precision function
+fixed fxAdd_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) + toFloat(b));
+}
+
+fixed fxSub_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) - toFloat(b));
+}
+
+fixed fxMul_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la * lb) >> FX_Q_NUM;
+}
+
+fixed fxDiv_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la << FX_Q_NUM) / lb;
+}
+
+// fair function
+fixed fxAdd_fair(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_fair(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la >> FX_Q_NUM_HA) * (lb >> FX_Q_NUM_HB)) >> FX_Q_NUM_H;
+}
+
+fixed fxDiv_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / lb) << FX_Q_NUM_H;
+}
+
+// performance function
+fixed fxAdd_performance(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_performance(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la>>FX_Q_NUM_H)*(lb>>FX_Q_NUM_H);
+}
+
+fixed fxDiv_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / (lb >> FX_Q_NUM_H));
+}
diff --git a/extra/fx_s17_14.h b/extra/fx_s17_14.h
new file mode 100644
index 0000000..c7900f1
--- /dev/null
+++ b/extra/fx_s17_14.h
@@ -0,0 +1,37 @@
+#include "fx_head.h"
+#include <math.h>
+
+#define FX_POINT FX_S17_14
+
+#define FX_Q_NUM (FX_POINT & 0xFF) // 14
+
+// If you want calculate with high precision set 64
+#define FX_SYSTEM_INTEGER 64 // 32 or 64
+#define FX_SYSTEM_FLOAT 64 // 32 or 64
+
+#define FX_DATA_TYPE signed int
+
+
+typedef int fx_s17_14;
+typedef fx_s17_14 fixed;
+
+#define fromDouble(d) ((fixed)((d)*DOUBLE_Q_VALUE))
+#define toDouble(d) ((double)(d)*DOUBLE_1_Q_VALUE)
+#define fromFloat(d) ((fixed)((d)*FLOAT_Q_VALUE))
+#define toFloat(d) ((float)(d)*FLOAT_1_Q_VALUE)
+
+// CONSTANTS
+#define FLOAT_Q_VALUE (float)(1<<FX_Q_NUM)
+#define DOUBLE_Q_VALUE (double)(1<<FX_Q_NUM)
+#define FLOAT_1_Q_VALUE (float)(1.0f/FLOAT_Q_VALUE)
+#define DOUBLE_1_Q_VALUE (double)(1.0f/DOUBLE_Q_VALUE)
+#define FX_PI fromDOUBLE(M_PI)
+
+// One of FX_OP_FLOAT, FX_OP_PRECISION, FX_OP_FAIR, FX_OP_PERFORMANCE
+#define FX_OP_PREFERENCE FX_OP_FLOAT
+
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+
diff --git a/extra/practice.c b/extra/practice.c
new file mode 100644
index 0000000..dbfec7b
--- /dev/null
+++ b/extra/practice.c
@@ -0,0 +1,48 @@
+#include <stdio.h>
+// #### #### #### #### . #### #### #### ####
+// S 15 . 16
+#define FX_Q_NUM 16
+#define FX_2_MINUS_16 1.52587890625e-05F
+#define FX_2_PLUS_16 (1<<16)
+#define FX_S_15_16 11516
+#define FX_SYSTEM FX_S_15_16
+
+typedef int fixed32;
+
+fixed32 fromFloat(float fa)
+{
+ return (fixed32) (fa * FX_2_PLUS_16);
+}
+
+float toFloat(fixed32 xa)
+{
+ return ((float) (xa)) * FX_2_MINUS_16;
+}
+
+fixed32 fxAdd(fixed32 a, fixed32 b)
+{
+ return fromFloat(toFloat(a)+toFloat(b));
+}
+
+
+fixed32 fxAdd2(fixed32 a, fixed32 b)
+{
+ return a+b;
+}
+
+int main()
+{
+ int i = 0;
+ int ia, ib, ic, ic2;
+ float fa;
+ // fscanf(stdin, "%d %d", &ia, &ib);
+ for (i = 0; i < 5000000; i++){
+ ic = fxAdd(i, i);
+ ic2 = fxAdd2(i, i);
+ fprintf(stdout, "%f + %f : %f, %f diff = %d \n", toFloat(i), toFloat(i), toFloat(ic), toFloat(ic2), ic-ic2);
+ }
+
+ // fprintf(stdout, "%d + %d : %d \n", ia, ib, ic);
+ // fprintf(stdout, "%f + %f : %f \n", toFloat(ia), toFloat(ib), toFloat(ic));
+ // fprintf(stdout, "%d + %d : %d \n", ia, ib, ic);
+}
diff --git a/extra/result.txt b/extra/result.txt
new file mode 100644
index 0000000..e1ba5ce
--- /dev/null
+++ b/extra/result.txt
@@ -0,0 +1,156 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ no time accumulated
+
+ % cumulative self self total
+ time seconds seconds calls Ts/call Ts/call name
+ 0.00 0.00 0.00 1 0.00 0.00 fxAdd_float
+ 0.00 0.00 0.00 1 0.00 0.00 fxDiv_float
+ 0.00 0.00 0.00 1 0.00 0.00 fxMul_float
+ 0.00 0.00 0.00 1 0.00 0.00 fxSub_float
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) no time propagated
+
+index % time self children called name
+ 0.00 0.00 1/1 main [22]
+[1] 0.0 0.00 0.00 1 fxAdd_float [1]
+-----------------------------------------------
+ 0.00 0.00 1/1 main [22]
+[2] 0.0 0.00 0.00 1 fxDiv_float [2]
+-----------------------------------------------
+ 0.00 0.00 1/1 main [22]
+[3] 0.0 0.00 0.00 1 fxMul_float [3]
+-----------------------------------------------
+ 0.00 0.00 1/1 main [22]
+[4] 0.0 0.00 0.00 1 fxSub_float [4]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [1] fxAdd_float [3] fxMul_float
+ [2] fxDiv_float [4] fxSub_float
diff --git a/extra/test b/extra/test
new file mode 100755
index 0000000000000000000000000000000000000000..352edc9e64a61b84fcdcdef71dc95976b37c682e
GIT binary patch
literal 13752
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
literal 0
HcmV?d00001
diff --git a/extra/test.c b/extra/test.c
new file mode 100644
index 0000000..a1ca9ca
--- /dev/null
+++ b/extra/test.c
@@ -0,0 +1,36 @@
+#include "fx_s17_14.h"
+#include <stdio.h>
+
+int main()
+{
+ double a,b;
+
+ fscanf(stdin, "%lf %lf", &a, &b);
+
+ fprintf(stdout, "\n");
+
+ fprintf(stdout, "fxAdd_float : a + b = %.15lf \n", toDouble(fxAdd_float(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxSub_float : a - b = %.15lf \n", toDouble(fxSub_float(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxMul_float : a * b = %.15lf \n", toDouble(fxMul_float(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxDiv_float : a / b = %.15lf \n", toDouble(fxDiv_float(fromDouble(a), fromDouble(b))));
+
+ fprintf(stdout, "------------------------------------------- \n");
+ fprintf(stdout, "fxAdd_precision : a + b = %.15lf \n", toFloat(fxAdd_precision(fromFloat(a), fromFloat(b))));
+ fprintf(stdout, "fxSub_precision : a - b = %.15lf \n", toFloat(fxSub_precision(fromFloat(a), fromFloat(b))));
+ fprintf(stdout, "fxMul_precision : a * b = %.15lf \n", toDouble(fxMul_precision(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxDiv_precision : a / b = %.15lf \n", toDouble(fxDiv_precision(fromDouble(a), fromDouble(b))));
+
+ fprintf(stdout, "------------------------------------------- \n");
+ fprintf(stdout, "fxAdd_fair : a + b = %.15lf \n", toDouble(fxAdd_fair(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxSub_fair : a - b = %.15lf \n", toDouble(fxSub_fair(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxMul_fair : a * b = %.15lf \n", toDouble(fxMul_fair(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxDiv_fair : a / b = %.15lf \n", toDouble(fxDiv_fair(fromDouble(a), fromDouble(b))));
+
+ fprintf(stdout, "------------------------------------------- \n");
+ fprintf(stdout, "fxAdd_performance : a + b = %.15lf \n", toDouble(fxAdd_performance(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxSub_performance : a - b = %.15lf \n", toDouble(fxSub_performance(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxMul_performance : a * b = %.15lf \n", toDouble(fxMul_performance(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxDiv_performance : a / b = %.15lf \n", toDouble(fxDiv_performance(fromDouble(a), fromDouble(b))));
+
+ return 0;
+}
diff --git a/fx_s17_14/Makefile b/fx_s17_14/Makefile
new file mode 100644
index 0000000..b763ad4
--- /dev/null
+++ b/fx_s17_14/Makefile
@@ -0,0 +1,17 @@
+CC = gcc
+CFLAGS = -c -o
+OBJS = project_main.o fx_s17_14.o
+HEAD = fx_s17_14.h
+FILE = fx_s17_14.c
+
+fx_s17_14.out: $(OBJS)
+ $(CC) $(OBJS) -o $@
+
+project_main.o: project_main.c $(FILE) $(HEAD)
+ $(CC) project_main.c $(FILE) $(CFLAGS) $@
+
+fx_s17_14.o: project_main.o $(FILE) $(HEAD)
+ $(CC) project_main.o $(FILE) $(CFLAGS) $@
+
+clean:
+ rm $(OBJS) fx_s17_14.out
diff --git a/fx_s17_14/fx_head.h b/fx_s17_14/fx_head.h
new file mode 100644
index 0000000..6d9bd26
--- /dev/null
+++ b/fx_s17_14/fx_head.h
@@ -0,0 +1,79 @@
+#pragma once
+
+// Fixed with signed long long
+#define FX_S28_35 ((1<<16) | (28<<8) | (35))
+#define FX_S29_34 ((1<<16) | (29<<8) | (34))
+#define FX_S30_33 ((1<<16) | (30<<8) | (33))
+#define FX_S31_32 ((1<<16) | (31<<8) | (32))
+#define FX_S32_31 ((1<<16) | (32<<8) | (31))
+#define FX_S33_30 ((1<<16) | (33<<8) | (30))
+#define FX_S34_29 ((1<<16) | (34<<8) | (29))
+#define FX_S35_28 ((1<<16) | (35<<8) | (28))
+// Fixed with unsigned long long
+#define FX_U29_35 ((0<<16) | (29<<8) | (35))
+#define FX_U30_34 ((0<<16) | (30<<8) | (34))
+#define FX_U31_33 ((0<<16) | (31<<8) | (33))
+#define FX_U32_32 ((0<<16) | (32<<8) | (32))
+#define FX_U33_31 ((0<<16) | (33<<8) | (31))
+#define FX_U34_30 ((0<<16) | (34<<8) | (30))
+#define FX_U35_29 ((0<<16) | (35<<8) | (29))
+#define FX_U36_28 ((0<<16) | (36<<8) | (28))
+// Fixed with signed int
+#define FX_S12_19 ((1<<16) | (12<<8) | (19))
+#define FX_S13_18 ((1<<16) | (13<<8) | (18))
+#define FX_S14_17 ((1<<16) | (14<<8) | (17))
+#define FX_S15_16 ((1<<16) | (15<<8) | (16))
+#define FX_S16_15 ((1<<16) | (16<<8) | (15))
+#define FX_S17_14 ((1<<16) | (17<<8) | (14))
+#define FX_S18_13 ((1<<16) | (18<<8) | (13))
+#define FX_S19_12 ((1<<16) | (19<<8) | (12))
+// Fixed with unsigned int
+#define FX_S13_19 ((0<<16) | (13<<8) | (19))
+#define FX_S14_18 ((0<<16) | (14<<8) | (18))
+#define FX_S15_17 ((0<<16) | (15<<8) | (17))
+#define FX_S16_16 ((0<<16) | (16<<8) | (16))
+#define FX_S17_15 ((0<<16) | (17<<8) | (15))
+#define FX_S18_14 ((0<<16) | (18<<8) | (14))
+#define FX_S19_13 ((0<<16) | (19<<8) | (13))
+#define FX_S20_12 ((0<<16) | (20<<8) | (12))
+// Fixed with signed short
+#define FX_S04_11 ((1<<16) | (4<<8) | (11))
+#define FX_S05_10 ((1<<16) | (5<<8) | (10))
+#define FX_S06_09 ((1<<16) | (6<<8) | (9))
+#define FX_S07_08 ((1<<16) | (7<<8) | (8))
+#define FX_S08_07 ((1<<16) | (8<<8) | (7))
+#define FX_S09_06 ((1<<16) | (9<<8) | (6))
+#define FX_S10_05 ((1<<16) | (10<<8) | (5))
+#define FX_S11_04 ((1<<16) | (11<<8) | (4))
+// Fixed with unsigned short
+#define FX_S05_11 ((0<<16) | (5<<8) | (11))
+#define FX_S06_10 ((0<<16) | (6<<8) | (10))
+#define FX_S07_09 ((0<<16) | (7<<8) | (9))
+#define FX_S08_08 ((0<<16) | (8<<8) | (8))
+#define FX_S09_07 ((0<<16) | (9<<8) | (7))
+#define FX_S10_06 ((0<<16) | (10<<8) | (6))
+#define FX_S11_05 ((0<<16) | (11<<8) | (5))
+#define FX_S12_04 ((0<<16) | (12<<8) | (4))
+// Fixed with signed char
+#define FX_S00_07 ((1<<16) | (0<<8) | (7))
+#define FX_S01_06 ((1<<16) | (1<<8) | (6))
+#define FX_S02_05 ((1<<16) | (2<<8) | (5))
+#define FX_S03_04 ((1<<16) | (3<<8) | (4))
+#define FX_S04_03 ((1<<16) | (4<<8) | (3))
+#define FX_S05_02 ((1<<16) | (5<<8) | (2))
+#define FX_S06_01 ((1<<16) | (6<<8) | (1))
+// #define FX_S07_00 ((1<<16) | (7<<8) | (0)) // It is same as unsigned char
+// Fixed with unsigned char
+#define FX_S00_08 ((0<<16) | (0<<8) | (8))
+#define FX_S01_07 ((0<<16) | (1<<8) | (7))
+#define FX_S02_06 ((0<<16) | (2<<8) | (6))
+#define FX_S03_05 ((0<<16) | (3<<8) | (5))
+#define FX_S04_04 ((0<<16) | (4<<8) | (4))
+#define FX_S05_03 ((0<<16) | (5<<8) | (3))
+#define FX_S06_02 ((0<<16) | (6<<8) | (2))
+#define FX_S07_01 ((0<<16) | (7<<8) | (1))
+// Operation Preference
+#define FX_OP_FLOAT 1
+#define FX_OP_PRECISION 2
+#define FX_OP_FAIR 3
+#define FX_OP_PERFORMANCE 4
diff --git a/fx_s17_14/fx_s17_14.c b/fx_s17_14/fx_s17_14.c
new file mode 100644
index 0000000..88bf98c
--- /dev/null
+++ b/fx_s17_14/fx_s17_14.c
@@ -0,0 +1,104 @@
+#include "fx_head.h"
+#include "fx_s17_14.h"
+
+#define fxADD(a,b) ((a)+(b))
+#define fxSUB(a,b) ((a)-(b))
+#define FX_Q_NUM_H (FX_Q_NUM/2)
+#define FX_Q_NUM_HA (FX_Q_NUM_H-FX_Q_NUM_H/2)
+#define FX_Q_NUM_HB (FX_Q_NUM_H/2)
+/*
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+*/
+
+// float function
+fixed fxAdd_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) + toDouble(b));
+}
+
+fixed fxSub_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) - toDouble(b));
+}
+
+fixed fxMul_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) * toDouble(b));
+}
+
+fixed fxDiv_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) / toDouble(b));
+}
+
+// precision function
+fixed fxAdd_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) + toFloat(b));
+}
+
+fixed fxSub_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) - toFloat(b));
+}
+
+fixed fxMul_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la * lb) >> FX_Q_NUM;
+}
+
+fixed fxDiv_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la << FX_Q_NUM) / lb;
+}
+
+// fair function
+fixed fxAdd_fair(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_fair(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la >> FX_Q_NUM_HA) * (lb >> FX_Q_NUM_HB)) >> FX_Q_NUM_H;
+}
+
+fixed fxDiv_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / lb) << FX_Q_NUM_H;
+}
+
+// performance function
+fixed fxAdd_performance(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_performance(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la>>FX_Q_NUM_H)*(lb>>FX_Q_NUM_H);
+}
+
+fixed fxDiv_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / (lb >> FX_Q_NUM_H));
+}
diff --git a/fx_s17_14/fx_s17_14.h b/fx_s17_14/fx_s17_14.h
new file mode 100644
index 0000000..c7900f1
--- /dev/null
+++ b/fx_s17_14/fx_s17_14.h
@@ -0,0 +1,37 @@
+#include "fx_head.h"
+#include <math.h>
+
+#define FX_POINT FX_S17_14
+
+#define FX_Q_NUM (FX_POINT & 0xFF) // 14
+
+// If you want calculate with high precision set 64
+#define FX_SYSTEM_INTEGER 64 // 32 or 64
+#define FX_SYSTEM_FLOAT 64 // 32 or 64
+
+#define FX_DATA_TYPE signed int
+
+
+typedef int fx_s17_14;
+typedef fx_s17_14 fixed;
+
+#define fromDouble(d) ((fixed)((d)*DOUBLE_Q_VALUE))
+#define toDouble(d) ((double)(d)*DOUBLE_1_Q_VALUE)
+#define fromFloat(d) ((fixed)((d)*FLOAT_Q_VALUE))
+#define toFloat(d) ((float)(d)*FLOAT_1_Q_VALUE)
+
+// CONSTANTS
+#define FLOAT_Q_VALUE (float)(1<<FX_Q_NUM)
+#define DOUBLE_Q_VALUE (double)(1<<FX_Q_NUM)
+#define FLOAT_1_Q_VALUE (float)(1.0f/FLOAT_Q_VALUE)
+#define DOUBLE_1_Q_VALUE (double)(1.0f/DOUBLE_Q_VALUE)
+#define FX_PI fromDOUBLE(M_PI)
+
+// One of FX_OP_FLOAT, FX_OP_PRECISION, FX_OP_FAIR, FX_OP_PERFORMANCE
+#define FX_OP_PREFERENCE FX_OP_FLOAT
+
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+
diff --git a/fx_s17_14/project_main.c b/fx_s17_14/project_main.c
new file mode 100644
index 0000000..1593d67
--- /dev/null
+++ b/fx_s17_14/project_main.c
@@ -0,0 +1,77 @@
+#include "fx_s17_14.h"
+#include <stdio.h>
+
+/*
+int main()
+{
+
+ printf("%f : %d\n",1.0, fromDouble(1.0));
+ printf("%f : %f\n",1.3*0.3, toFloat(fxMul_float(fromDouble(1.3),fromDouble(0.3)))) ;
+
+}
+*/
+
+int main()
+{
+ double a,b;
+ int num;
+
+ fprintf(stdout, "FX_OP_FLOAT : 1 \n");
+ fprintf(stdout, "FX_OP_PRECISION : 2 \n");
+ fprintf(stdout, "FX_OP_FAIR : 3 \n");
+ fprintf(stdout, "FX_OP_PERFORMANCE : 4 \n");
+ fprintf(stdout, "QUIT : The others \n\n");
+
+ fprintf(stdout, "Choose calculate way you want : ");
+ fscanf(stdin, "%d", &num);
+
+ if(num!=1 && num!=2 && num!=3 && num!=4)
+ {
+ fprintf(stdout, "Thank you! \n");
+ return 0;
+ }
+
+ fprintf(stdout, "Input the First Number : ");
+ fscanf(stdin, "%lf", &a);
+
+ fprintf(stdout, "Input the Second Number : ");
+ fscanf(stdin, "%lf", &b);
+
+ fprintf(stdout, "\n");
+
+ switch (num)
+ {
+ case 1:
+ fprintf(stdout, "fxAdd_float : a + b = %.15lf \n", toDouble(fxAdd_float(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxSub_float : a - b = %.15lf \n", toDouble(fxSub_float(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxMul_float : a * b = %.15lf \n", toDouble(fxMul_float(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxDiv_float : a / b = %.15lf \n", toDouble(fxDiv_float(fromDouble(a), fromDouble(b))));
+ break;
+
+ case 2:
+ fprintf(stdout, "fxAdd_precision : a + b = %.15lf \n", toFloat(fxAdd_precision(fromFloat(a), fromFloat(b))));
+ fprintf(stdout, "fxSub_precision : a - b = %.15lf \n", toFloat(fxSub_precision(fromFloat(a), fromFloat(b))));
+ fprintf(stdout, "fxMul_precision : a * b = %.15lf \n", toFloat(fxMul_precision(fromFloat(a), fromFloat(b))));
+ fprintf(stdout, "fxDiv_precision : a / b = %.15lf \n", toFloat(fxDiv_precision(fromFloat(a), fromFloat(b))));
+ break;
+
+ case 3:
+ fprintf(stdout, "fxAdd_fair : a + b = %.15lf \n", toFloat(fxAdd_fair(fromFloat(a), fromFloat(b))));
+ fprintf(stdout, "fxSub_fair : a - b = %.15lf \n", toFloat(fxSub_fair(fromFloat(a), fromFloat(b))));
+ fprintf(stdout, "fxMul_fair : a * b = %.15lf \n", toFloat(fxMul_fair(fromFloat(a), fromFloat(b))));
+ fprintf(stdout, "fxDiv_fair : a / b = %.15lf \n", toFloat(fxDiv_fair(fromFloat(a), fromFloat(b))));
+ break;
+
+ case 4:
+ fprintf(stdout, "fxAdd_performance : a + b = %.15lf \n", toDouble(fxAdd_performance(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxSub_performance : a - b = %.15lf \n", toDouble(fxSub_performance(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxMul_performance : a * b = %.15lf \n", toDouble(fxMul_performance(fromDouble(a), fromDouble(b))));
+ fprintf(stdout, "fxDiv_performance : a / b = %.15lf \n", toDouble(fxDiv_performance(fromDouble(a), fromDouble(b))));
+ break;
+
+ default:
+ break;
+ }
+
+ return 0;
+}
diff --git a/overflow/fx_head.h b/overflow/fx_head.h
new file mode 100644
index 0000000..6d9bd26
--- /dev/null
+++ b/overflow/fx_head.h
@@ -0,0 +1,79 @@
+#pragma once
+
+// Fixed with signed long long
+#define FX_S28_35 ((1<<16) | (28<<8) | (35))
+#define FX_S29_34 ((1<<16) | (29<<8) | (34))
+#define FX_S30_33 ((1<<16) | (30<<8) | (33))
+#define FX_S31_32 ((1<<16) | (31<<8) | (32))
+#define FX_S32_31 ((1<<16) | (32<<8) | (31))
+#define FX_S33_30 ((1<<16) | (33<<8) | (30))
+#define FX_S34_29 ((1<<16) | (34<<8) | (29))
+#define FX_S35_28 ((1<<16) | (35<<8) | (28))
+// Fixed with unsigned long long
+#define FX_U29_35 ((0<<16) | (29<<8) | (35))
+#define FX_U30_34 ((0<<16) | (30<<8) | (34))
+#define FX_U31_33 ((0<<16) | (31<<8) | (33))
+#define FX_U32_32 ((0<<16) | (32<<8) | (32))
+#define FX_U33_31 ((0<<16) | (33<<8) | (31))
+#define FX_U34_30 ((0<<16) | (34<<8) | (30))
+#define FX_U35_29 ((0<<16) | (35<<8) | (29))
+#define FX_U36_28 ((0<<16) | (36<<8) | (28))
+// Fixed with signed int
+#define FX_S12_19 ((1<<16) | (12<<8) | (19))
+#define FX_S13_18 ((1<<16) | (13<<8) | (18))
+#define FX_S14_17 ((1<<16) | (14<<8) | (17))
+#define FX_S15_16 ((1<<16) | (15<<8) | (16))
+#define FX_S16_15 ((1<<16) | (16<<8) | (15))
+#define FX_S17_14 ((1<<16) | (17<<8) | (14))
+#define FX_S18_13 ((1<<16) | (18<<8) | (13))
+#define FX_S19_12 ((1<<16) | (19<<8) | (12))
+// Fixed with unsigned int
+#define FX_S13_19 ((0<<16) | (13<<8) | (19))
+#define FX_S14_18 ((0<<16) | (14<<8) | (18))
+#define FX_S15_17 ((0<<16) | (15<<8) | (17))
+#define FX_S16_16 ((0<<16) | (16<<8) | (16))
+#define FX_S17_15 ((0<<16) | (17<<8) | (15))
+#define FX_S18_14 ((0<<16) | (18<<8) | (14))
+#define FX_S19_13 ((0<<16) | (19<<8) | (13))
+#define FX_S20_12 ((0<<16) | (20<<8) | (12))
+// Fixed with signed short
+#define FX_S04_11 ((1<<16) | (4<<8) | (11))
+#define FX_S05_10 ((1<<16) | (5<<8) | (10))
+#define FX_S06_09 ((1<<16) | (6<<8) | (9))
+#define FX_S07_08 ((1<<16) | (7<<8) | (8))
+#define FX_S08_07 ((1<<16) | (8<<8) | (7))
+#define FX_S09_06 ((1<<16) | (9<<8) | (6))
+#define FX_S10_05 ((1<<16) | (10<<8) | (5))
+#define FX_S11_04 ((1<<16) | (11<<8) | (4))
+// Fixed with unsigned short
+#define FX_S05_11 ((0<<16) | (5<<8) | (11))
+#define FX_S06_10 ((0<<16) | (6<<8) | (10))
+#define FX_S07_09 ((0<<16) | (7<<8) | (9))
+#define FX_S08_08 ((0<<16) | (8<<8) | (8))
+#define FX_S09_07 ((0<<16) | (9<<8) | (7))
+#define FX_S10_06 ((0<<16) | (10<<8) | (6))
+#define FX_S11_05 ((0<<16) | (11<<8) | (5))
+#define FX_S12_04 ((0<<16) | (12<<8) | (4))
+// Fixed with signed char
+#define FX_S00_07 ((1<<16) | (0<<8) | (7))
+#define FX_S01_06 ((1<<16) | (1<<8) | (6))
+#define FX_S02_05 ((1<<16) | (2<<8) | (5))
+#define FX_S03_04 ((1<<16) | (3<<8) | (4))
+#define FX_S04_03 ((1<<16) | (4<<8) | (3))
+#define FX_S05_02 ((1<<16) | (5<<8) | (2))
+#define FX_S06_01 ((1<<16) | (6<<8) | (1))
+// #define FX_S07_00 ((1<<16) | (7<<8) | (0)) // It is same as unsigned char
+// Fixed with unsigned char
+#define FX_S00_08 ((0<<16) | (0<<8) | (8))
+#define FX_S01_07 ((0<<16) | (1<<8) | (7))
+#define FX_S02_06 ((0<<16) | (2<<8) | (6))
+#define FX_S03_05 ((0<<16) | (3<<8) | (5))
+#define FX_S04_04 ((0<<16) | (4<<8) | (4))
+#define FX_S05_03 ((0<<16) | (5<<8) | (3))
+#define FX_S06_02 ((0<<16) | (6<<8) | (2))
+#define FX_S07_01 ((0<<16) | (7<<8) | (1))
+// Operation Preference
+#define FX_OP_FLOAT 1
+#define FX_OP_PRECISION 2
+#define FX_OP_FAIR 3
+#define FX_OP_PERFORMANCE 4
diff --git a/overflow/fx_s17_14.c b/overflow/fx_s17_14.c
new file mode 100644
index 0000000..88bf98c
--- /dev/null
+++ b/overflow/fx_s17_14.c
@@ -0,0 +1,104 @@
+#include "fx_head.h"
+#include "fx_s17_14.h"
+
+#define fxADD(a,b) ((a)+(b))
+#define fxSUB(a,b) ((a)-(b))
+#define FX_Q_NUM_H (FX_Q_NUM/2)
+#define FX_Q_NUM_HA (FX_Q_NUM_H-FX_Q_NUM_H/2)
+#define FX_Q_NUM_HB (FX_Q_NUM_H/2)
+/*
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+*/
+
+// float function
+fixed fxAdd_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) + toDouble(b));
+}
+
+fixed fxSub_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) - toDouble(b));
+}
+
+fixed fxMul_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) * toDouble(b));
+}
+
+fixed fxDiv_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) / toDouble(b));
+}
+
+// precision function
+fixed fxAdd_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) + toFloat(b));
+}
+
+fixed fxSub_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) - toFloat(b));
+}
+
+fixed fxMul_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la * lb) >> FX_Q_NUM;
+}
+
+fixed fxDiv_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la << FX_Q_NUM) / lb;
+}
+
+// fair function
+fixed fxAdd_fair(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_fair(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la >> FX_Q_NUM_HA) * (lb >> FX_Q_NUM_HB)) >> FX_Q_NUM_H;
+}
+
+fixed fxDiv_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / lb) << FX_Q_NUM_H;
+}
+
+// performance function
+fixed fxAdd_performance(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_performance(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la>>FX_Q_NUM_H)*(lb>>FX_Q_NUM_H);
+}
+
+fixed fxDiv_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / (lb >> FX_Q_NUM_H));
+}
diff --git a/overflow/fx_s17_14.h b/overflow/fx_s17_14.h
new file mode 100644
index 0000000..c7900f1
--- /dev/null
+++ b/overflow/fx_s17_14.h
@@ -0,0 +1,37 @@
+#include "fx_head.h"
+#include <math.h>
+
+#define FX_POINT FX_S17_14
+
+#define FX_Q_NUM (FX_POINT & 0xFF) // 14
+
+// If you want calculate with high precision set 64
+#define FX_SYSTEM_INTEGER 64 // 32 or 64
+#define FX_SYSTEM_FLOAT 64 // 32 or 64
+
+#define FX_DATA_TYPE signed int
+
+
+typedef int fx_s17_14;
+typedef fx_s17_14 fixed;
+
+#define fromDouble(d) ((fixed)((d)*DOUBLE_Q_VALUE))
+#define toDouble(d) ((double)(d)*DOUBLE_1_Q_VALUE)
+#define fromFloat(d) ((fixed)((d)*FLOAT_Q_VALUE))
+#define toFloat(d) ((float)(d)*FLOAT_1_Q_VALUE)
+
+// CONSTANTS
+#define FLOAT_Q_VALUE (float)(1<<FX_Q_NUM)
+#define DOUBLE_Q_VALUE (double)(1<<FX_Q_NUM)
+#define FLOAT_1_Q_VALUE (float)(1.0f/FLOAT_Q_VALUE)
+#define DOUBLE_1_Q_VALUE (double)(1.0f/DOUBLE_Q_VALUE)
+#define FX_PI fromDOUBLE(M_PI)
+
+// One of FX_OP_FLOAT, FX_OP_PRECISION, FX_OP_FAIR, FX_OP_PERFORMANCE
+#define FX_OP_PREFERENCE FX_OP_FLOAT
+
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+
diff --git a/overflow/testcodemul.c b/overflow/testcodemul.c
new file mode 100644
index 0000000..0bfcfa2
--- /dev/null
+++ b/overflow/testcodemul.c
@@ -0,0 +1,22 @@
+#include "fx_s17_14.h"
+#include <stdio.h>
+
+int main()
+{
+ double i;
+ int mul1, mul2, mul3, mul4;
+ for ( i = 362; i < 363; i+=0.001)
+ {
+ mul1 = fxMul_float(fromDouble(i), fromDouble(i));
+ mul2 = fxMul_precision(fromDouble(i), fromDouble(i));
+ mul3 = fxMul_fair(fromDouble(i), fromDouble(i));
+ mul4 = fxMul_performance(fromDouble(i), fromDouble(i));
+
+ fprintf(stdout, "%f * %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(mul1));
+ fprintf(stdout, "%f * %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(mul2));
+ fprintf(stdout, "%f * %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(mul3));
+ fprintf(stdout, "%f * %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(mul4));
+ fprintf(stdout, "=============================== \n");
+ }
+ return 0;
+}
diff --git a/precisiontest/fx_head.h b/precisiontest/fx_head.h
new file mode 100644
index 0000000..6d9bd26
--- /dev/null
+++ b/precisiontest/fx_head.h
@@ -0,0 +1,79 @@
+#pragma once
+
+// Fixed with signed long long
+#define FX_S28_35 ((1<<16) | (28<<8) | (35))
+#define FX_S29_34 ((1<<16) | (29<<8) | (34))
+#define FX_S30_33 ((1<<16) | (30<<8) | (33))
+#define FX_S31_32 ((1<<16) | (31<<8) | (32))
+#define FX_S32_31 ((1<<16) | (32<<8) | (31))
+#define FX_S33_30 ((1<<16) | (33<<8) | (30))
+#define FX_S34_29 ((1<<16) | (34<<8) | (29))
+#define FX_S35_28 ((1<<16) | (35<<8) | (28))
+// Fixed with unsigned long long
+#define FX_U29_35 ((0<<16) | (29<<8) | (35))
+#define FX_U30_34 ((0<<16) | (30<<8) | (34))
+#define FX_U31_33 ((0<<16) | (31<<8) | (33))
+#define FX_U32_32 ((0<<16) | (32<<8) | (32))
+#define FX_U33_31 ((0<<16) | (33<<8) | (31))
+#define FX_U34_30 ((0<<16) | (34<<8) | (30))
+#define FX_U35_29 ((0<<16) | (35<<8) | (29))
+#define FX_U36_28 ((0<<16) | (36<<8) | (28))
+// Fixed with signed int
+#define FX_S12_19 ((1<<16) | (12<<8) | (19))
+#define FX_S13_18 ((1<<16) | (13<<8) | (18))
+#define FX_S14_17 ((1<<16) | (14<<8) | (17))
+#define FX_S15_16 ((1<<16) | (15<<8) | (16))
+#define FX_S16_15 ((1<<16) | (16<<8) | (15))
+#define FX_S17_14 ((1<<16) | (17<<8) | (14))
+#define FX_S18_13 ((1<<16) | (18<<8) | (13))
+#define FX_S19_12 ((1<<16) | (19<<8) | (12))
+// Fixed with unsigned int
+#define FX_S13_19 ((0<<16) | (13<<8) | (19))
+#define FX_S14_18 ((0<<16) | (14<<8) | (18))
+#define FX_S15_17 ((0<<16) | (15<<8) | (17))
+#define FX_S16_16 ((0<<16) | (16<<8) | (16))
+#define FX_S17_15 ((0<<16) | (17<<8) | (15))
+#define FX_S18_14 ((0<<16) | (18<<8) | (14))
+#define FX_S19_13 ((0<<16) | (19<<8) | (13))
+#define FX_S20_12 ((0<<16) | (20<<8) | (12))
+// Fixed with signed short
+#define FX_S04_11 ((1<<16) | (4<<8) | (11))
+#define FX_S05_10 ((1<<16) | (5<<8) | (10))
+#define FX_S06_09 ((1<<16) | (6<<8) | (9))
+#define FX_S07_08 ((1<<16) | (7<<8) | (8))
+#define FX_S08_07 ((1<<16) | (8<<8) | (7))
+#define FX_S09_06 ((1<<16) | (9<<8) | (6))
+#define FX_S10_05 ((1<<16) | (10<<8) | (5))
+#define FX_S11_04 ((1<<16) | (11<<8) | (4))
+// Fixed with unsigned short
+#define FX_S05_11 ((0<<16) | (5<<8) | (11))
+#define FX_S06_10 ((0<<16) | (6<<8) | (10))
+#define FX_S07_09 ((0<<16) | (7<<8) | (9))
+#define FX_S08_08 ((0<<16) | (8<<8) | (8))
+#define FX_S09_07 ((0<<16) | (9<<8) | (7))
+#define FX_S10_06 ((0<<16) | (10<<8) | (6))
+#define FX_S11_05 ((0<<16) | (11<<8) | (5))
+#define FX_S12_04 ((0<<16) | (12<<8) | (4))
+// Fixed with signed char
+#define FX_S00_07 ((1<<16) | (0<<8) | (7))
+#define FX_S01_06 ((1<<16) | (1<<8) | (6))
+#define FX_S02_05 ((1<<16) | (2<<8) | (5))
+#define FX_S03_04 ((1<<16) | (3<<8) | (4))
+#define FX_S04_03 ((1<<16) | (4<<8) | (3))
+#define FX_S05_02 ((1<<16) | (5<<8) | (2))
+#define FX_S06_01 ((1<<16) | (6<<8) | (1))
+// #define FX_S07_00 ((1<<16) | (7<<8) | (0)) // It is same as unsigned char
+// Fixed with unsigned char
+#define FX_S00_08 ((0<<16) | (0<<8) | (8))
+#define FX_S01_07 ((0<<16) | (1<<8) | (7))
+#define FX_S02_06 ((0<<16) | (2<<8) | (6))
+#define FX_S03_05 ((0<<16) | (3<<8) | (5))
+#define FX_S04_04 ((0<<16) | (4<<8) | (4))
+#define FX_S05_03 ((0<<16) | (5<<8) | (3))
+#define FX_S06_02 ((0<<16) | (6<<8) | (2))
+#define FX_S07_01 ((0<<16) | (7<<8) | (1))
+// Operation Preference
+#define FX_OP_FLOAT 1
+#define FX_OP_PRECISION 2
+#define FX_OP_FAIR 3
+#define FX_OP_PERFORMANCE 4
diff --git a/precisiontest/fx_s17_14.c b/precisiontest/fx_s17_14.c
new file mode 100644
index 0000000..88bf98c
--- /dev/null
+++ b/precisiontest/fx_s17_14.c
@@ -0,0 +1,104 @@
+#include "fx_head.h"
+#include "fx_s17_14.h"
+
+#define fxADD(a,b) ((a)+(b))
+#define fxSUB(a,b) ((a)-(b))
+#define FX_Q_NUM_H (FX_Q_NUM/2)
+#define FX_Q_NUM_HA (FX_Q_NUM_H-FX_Q_NUM_H/2)
+#define FX_Q_NUM_HB (FX_Q_NUM_H/2)
+/*
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+*/
+
+// float function
+fixed fxAdd_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) + toDouble(b));
+}
+
+fixed fxSub_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) - toDouble(b));
+}
+
+fixed fxMul_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) * toDouble(b));
+}
+
+fixed fxDiv_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) / toDouble(b));
+}
+
+// precision function
+fixed fxAdd_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) + toFloat(b));
+}
+
+fixed fxSub_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) - toFloat(b));
+}
+
+fixed fxMul_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la * lb) >> FX_Q_NUM;
+}
+
+fixed fxDiv_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la << FX_Q_NUM) / lb;
+}
+
+// fair function
+fixed fxAdd_fair(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_fair(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la >> FX_Q_NUM_HA) * (lb >> FX_Q_NUM_HB)) >> FX_Q_NUM_H;
+}
+
+fixed fxDiv_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / lb) << FX_Q_NUM_H;
+}
+
+// performance function
+fixed fxAdd_performance(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_performance(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la>>FX_Q_NUM_H)*(lb>>FX_Q_NUM_H);
+}
+
+fixed fxDiv_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / (lb >> FX_Q_NUM_H));
+}
diff --git a/precisiontest/fx_s17_14.h b/precisiontest/fx_s17_14.h
new file mode 100644
index 0000000..c7900f1
--- /dev/null
+++ b/precisiontest/fx_s17_14.h
@@ -0,0 +1,37 @@
+#include "fx_head.h"
+#include <math.h>
+
+#define FX_POINT FX_S17_14
+
+#define FX_Q_NUM (FX_POINT & 0xFF) // 14
+
+// If you want calculate with high precision set 64
+#define FX_SYSTEM_INTEGER 64 // 32 or 64
+#define FX_SYSTEM_FLOAT 64 // 32 or 64
+
+#define FX_DATA_TYPE signed int
+
+
+typedef int fx_s17_14;
+typedef fx_s17_14 fixed;
+
+#define fromDouble(d) ((fixed)((d)*DOUBLE_Q_VALUE))
+#define toDouble(d) ((double)(d)*DOUBLE_1_Q_VALUE)
+#define fromFloat(d) ((fixed)((d)*FLOAT_Q_VALUE))
+#define toFloat(d) ((float)(d)*FLOAT_1_Q_VALUE)
+
+// CONSTANTS
+#define FLOAT_Q_VALUE (float)(1<<FX_Q_NUM)
+#define DOUBLE_Q_VALUE (double)(1<<FX_Q_NUM)
+#define FLOAT_1_Q_VALUE (float)(1.0f/FLOAT_Q_VALUE)
+#define DOUBLE_1_Q_VALUE (double)(1.0f/DOUBLE_Q_VALUE)
+#define FX_PI fromDOUBLE(M_PI)
+
+// One of FX_OP_FLOAT, FX_OP_PRECISION, FX_OP_FAIR, FX_OP_PERFORMANCE
+#define FX_OP_PREFERENCE FX_OP_FLOAT
+
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+
diff --git a/precisiontest/testcodediv.c b/precisiontest/testcodediv.c
new file mode 100644
index 0000000..7b85356
--- /dev/null
+++ b/precisiontest/testcodediv.c
@@ -0,0 +1,21 @@
+#include "fx_s17_14.h"
+#include <stdio.h>
+
+int main()
+{
+ double a = 29.2653, b = 13.4598;
+
+ int div1, div2, div3, div4;
+ div1 = fxDiv_float(fromDouble(a), fromDouble(b));
+ div2 = fxDiv_precision(fromDouble(a), fromDouble(b));
+ div3 = fxDiv_fair(fromDouble(a), fromDouble(b));
+ div4 = fxDiv_performance(fromDouble(a), fromDouble(b));
+
+ fprintf(stdout, "================================================================================================= \n");
+ fprintf(stdout, "value : %.15f fxDiv_float : %.15f diff : %.15f \n", 29.2653 / 13.4598, toDouble(div1), (29.2653 / 13.4598) - toDouble(div1));
+ fprintf(stdout, "value : %.15f fxDiv_precision : %.15f diff : %.15f \n", 29.2653 / 13.4598, toDouble(div2), (29.2653 / 13.4598) - toDouble(div2));
+ fprintf(stdout, "value : %.15f fxDiv_fair : %.15f diff : %.15f \n", 29.2653 / 13.4598, toDouble(div3), (29.2653 / 13.4598) - toDouble(div3));
+ fprintf(stdout, "value : %.15f fxDiv_performance : %.15f diff : %.15f \n", 29.2653 / 13.4598, toDouble(div4), (29.2653 / 13.4598) - toDouble(div4));
+ fprintf(stdout, "================================================================================================= \n");
+ return 0;
+}
diff --git a/precisiontest/testcodemul.c b/precisiontest/testcodemul.c
new file mode 100644
index 0000000..0ad6e5b
--- /dev/null
+++ b/precisiontest/testcodemul.c
@@ -0,0 +1,21 @@
+#include "fx_s17_14.h"
+#include <stdio.h>
+
+int main()
+{
+ double a = 21.468, b = 17.297;
+
+ int mul1, mul2, mul3, mul4;
+ mul1 = fxMul_float(fromDouble(a), fromDouble(b));
+ mul2 = fxMul_precision(fromDouble(a), fromDouble(b));
+ mul3 = fxMul_fair(fromDouble(a), fromDouble(b));
+ mul4 = fxMul_performance(fromDouble(a), fromDouble(b));
+
+ fprintf(stdout, "================================================================================================= \n");
+ fprintf(stdout, "value : %.15f fxMul_float : %.15f diff : %.15f \n", 21.468 * 17.297, toDouble(mul1), (21.468 * 17.297) - toDouble(mul1));
+ fprintf(stdout, "value : %.15f fxMul_precision : %.15f diff : %.15f \n", 21.468 * 17.297, toDouble(mul2), (21.468 * 17.297) - toDouble(mul2));
+ fprintf(stdout, "value : %.15f fxMul_fair : %.15f diff : %.15f \n", 21.468 * 17.297, toDouble(mul3), (21.468 * 17.297) - toDouble(mul3));
+ fprintf(stdout, "value : %.15f fxMul_performance : %.15f diff : %.15f \n", 21.468 * 17.297, toDouble(mul4), (21.468 * 17.297) - toDouble(mul4));
+ fprintf(stdout, "================================================================================================= \n");
+ return 0;
+}
diff --git a/speedtest/fx_head.h b/speedtest/fx_head.h
new file mode 100644
index 0000000..6d9bd26
--- /dev/null
+++ b/speedtest/fx_head.h
@@ -0,0 +1,79 @@
+#pragma once
+
+// Fixed with signed long long
+#define FX_S28_35 ((1<<16) | (28<<8) | (35))
+#define FX_S29_34 ((1<<16) | (29<<8) | (34))
+#define FX_S30_33 ((1<<16) | (30<<8) | (33))
+#define FX_S31_32 ((1<<16) | (31<<8) | (32))
+#define FX_S32_31 ((1<<16) | (32<<8) | (31))
+#define FX_S33_30 ((1<<16) | (33<<8) | (30))
+#define FX_S34_29 ((1<<16) | (34<<8) | (29))
+#define FX_S35_28 ((1<<16) | (35<<8) | (28))
+// Fixed with unsigned long long
+#define FX_U29_35 ((0<<16) | (29<<8) | (35))
+#define FX_U30_34 ((0<<16) | (30<<8) | (34))
+#define FX_U31_33 ((0<<16) | (31<<8) | (33))
+#define FX_U32_32 ((0<<16) | (32<<8) | (32))
+#define FX_U33_31 ((0<<16) | (33<<8) | (31))
+#define FX_U34_30 ((0<<16) | (34<<8) | (30))
+#define FX_U35_29 ((0<<16) | (35<<8) | (29))
+#define FX_U36_28 ((0<<16) | (36<<8) | (28))
+// Fixed with signed int
+#define FX_S12_19 ((1<<16) | (12<<8) | (19))
+#define FX_S13_18 ((1<<16) | (13<<8) | (18))
+#define FX_S14_17 ((1<<16) | (14<<8) | (17))
+#define FX_S15_16 ((1<<16) | (15<<8) | (16))
+#define FX_S16_15 ((1<<16) | (16<<8) | (15))
+#define FX_S17_14 ((1<<16) | (17<<8) | (14))
+#define FX_S18_13 ((1<<16) | (18<<8) | (13))
+#define FX_S19_12 ((1<<16) | (19<<8) | (12))
+// Fixed with unsigned int
+#define FX_S13_19 ((0<<16) | (13<<8) | (19))
+#define FX_S14_18 ((0<<16) | (14<<8) | (18))
+#define FX_S15_17 ((0<<16) | (15<<8) | (17))
+#define FX_S16_16 ((0<<16) | (16<<8) | (16))
+#define FX_S17_15 ((0<<16) | (17<<8) | (15))
+#define FX_S18_14 ((0<<16) | (18<<8) | (14))
+#define FX_S19_13 ((0<<16) | (19<<8) | (13))
+#define FX_S20_12 ((0<<16) | (20<<8) | (12))
+// Fixed with signed short
+#define FX_S04_11 ((1<<16) | (4<<8) | (11))
+#define FX_S05_10 ((1<<16) | (5<<8) | (10))
+#define FX_S06_09 ((1<<16) | (6<<8) | (9))
+#define FX_S07_08 ((1<<16) | (7<<8) | (8))
+#define FX_S08_07 ((1<<16) | (8<<8) | (7))
+#define FX_S09_06 ((1<<16) | (9<<8) | (6))
+#define FX_S10_05 ((1<<16) | (10<<8) | (5))
+#define FX_S11_04 ((1<<16) | (11<<8) | (4))
+// Fixed with unsigned short
+#define FX_S05_11 ((0<<16) | (5<<8) | (11))
+#define FX_S06_10 ((0<<16) | (6<<8) | (10))
+#define FX_S07_09 ((0<<16) | (7<<8) | (9))
+#define FX_S08_08 ((0<<16) | (8<<8) | (8))
+#define FX_S09_07 ((0<<16) | (9<<8) | (7))
+#define FX_S10_06 ((0<<16) | (10<<8) | (6))
+#define FX_S11_05 ((0<<16) | (11<<8) | (5))
+#define FX_S12_04 ((0<<16) | (12<<8) | (4))
+// Fixed with signed char
+#define FX_S00_07 ((1<<16) | (0<<8) | (7))
+#define FX_S01_06 ((1<<16) | (1<<8) | (6))
+#define FX_S02_05 ((1<<16) | (2<<8) | (5))
+#define FX_S03_04 ((1<<16) | (3<<8) | (4))
+#define FX_S04_03 ((1<<16) | (4<<8) | (3))
+#define FX_S05_02 ((1<<16) | (5<<8) | (2))
+#define FX_S06_01 ((1<<16) | (6<<8) | (1))
+// #define FX_S07_00 ((1<<16) | (7<<8) | (0)) // It is same as unsigned char
+// Fixed with unsigned char
+#define FX_S00_08 ((0<<16) | (0<<8) | (8))
+#define FX_S01_07 ((0<<16) | (1<<8) | (7))
+#define FX_S02_06 ((0<<16) | (2<<8) | (6))
+#define FX_S03_05 ((0<<16) | (3<<8) | (5))
+#define FX_S04_04 ((0<<16) | (4<<8) | (4))
+#define FX_S05_03 ((0<<16) | (5<<8) | (3))
+#define FX_S06_02 ((0<<16) | (6<<8) | (2))
+#define FX_S07_01 ((0<<16) | (7<<8) | (1))
+// Operation Preference
+#define FX_OP_FLOAT 1
+#define FX_OP_PRECISION 2
+#define FX_OP_FAIR 3
+#define FX_OP_PERFORMANCE 4
diff --git a/speedtest/fx_s17_14.c b/speedtest/fx_s17_14.c
new file mode 100644
index 0000000..88bf98c
--- /dev/null
+++ b/speedtest/fx_s17_14.c
@@ -0,0 +1,104 @@
+#include "fx_head.h"
+#include "fx_s17_14.h"
+
+#define fxADD(a,b) ((a)+(b))
+#define fxSUB(a,b) ((a)-(b))
+#define FX_Q_NUM_H (FX_Q_NUM/2)
+#define FX_Q_NUM_HA (FX_Q_NUM_H-FX_Q_NUM_H/2)
+#define FX_Q_NUM_HB (FX_Q_NUM_H/2)
+/*
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+*/
+
+// float function
+fixed fxAdd_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) + toDouble(b));
+}
+
+fixed fxSub_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) - toDouble(b));
+}
+
+fixed fxMul_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) * toDouble(b));
+}
+
+fixed fxDiv_float(fixed a, fixed b)
+{
+ return fromDouble(toDouble(a) / toDouble(b));
+}
+
+// precision function
+fixed fxAdd_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) + toFloat(b));
+}
+
+fixed fxSub_precision(fixed a, fixed b)
+{
+ return fromFloat(toFloat(a) - toFloat(b));
+}
+
+fixed fxMul_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la * lb) >> FX_Q_NUM;
+}
+
+fixed fxDiv_precision(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la << FX_Q_NUM) / lb;
+}
+
+// fair function
+fixed fxAdd_fair(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_fair(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la >> FX_Q_NUM_HA) * (lb >> FX_Q_NUM_HB)) >> FX_Q_NUM_H;
+}
+
+fixed fxDiv_fair(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / lb) << FX_Q_NUM_H;
+}
+
+// performance function
+fixed fxAdd_performance(fixed a, fixed b)
+{
+ return fxADD(a,b);
+}
+
+fixed fxSub_performance(fixed a, fixed b)
+{
+ return fxSUB(a,b);
+}
+
+fixed fxMul_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return (la>>FX_Q_NUM_H)*(lb>>FX_Q_NUM_H);
+}
+
+fixed fxDiv_performance(fixed a, fixed b)
+{
+ long long la = a, lb = b;
+ return ((la << FX_Q_NUM_H) / (lb >> FX_Q_NUM_H));
+}
diff --git a/speedtest/fx_s17_14.h b/speedtest/fx_s17_14.h
new file mode 100644
index 0000000..c7900f1
--- /dev/null
+++ b/speedtest/fx_s17_14.h
@@ -0,0 +1,37 @@
+#include "fx_head.h"
+#include <math.h>
+
+#define FX_POINT FX_S17_14
+
+#define FX_Q_NUM (FX_POINT & 0xFF) // 14
+
+// If you want calculate with high precision set 64
+#define FX_SYSTEM_INTEGER 64 // 32 or 64
+#define FX_SYSTEM_FLOAT 64 // 32 or 64
+
+#define FX_DATA_TYPE signed int
+
+
+typedef int fx_s17_14;
+typedef fx_s17_14 fixed;
+
+#define fromDouble(d) ((fixed)((d)*DOUBLE_Q_VALUE))
+#define toDouble(d) ((double)(d)*DOUBLE_1_Q_VALUE)
+#define fromFloat(d) ((fixed)((d)*FLOAT_Q_VALUE))
+#define toFloat(d) ((float)(d)*FLOAT_1_Q_VALUE)
+
+// CONSTANTS
+#define FLOAT_Q_VALUE (float)(1<<FX_Q_NUM)
+#define DOUBLE_Q_VALUE (double)(1<<FX_Q_NUM)
+#define FLOAT_1_Q_VALUE (float)(1.0f/FLOAT_Q_VALUE)
+#define DOUBLE_1_Q_VALUE (double)(1.0f/DOUBLE_Q_VALUE)
+#define FX_PI fromDOUBLE(M_PI)
+
+// One of FX_OP_FLOAT, FX_OP_PRECISION, FX_OP_FAIR, FX_OP_PERFORMANCE
+#define FX_OP_PREFERENCE FX_OP_FLOAT
+
+extern fixed fxAdd_float(), fxAdd_precision(), fxAdd_fair(), fxAdd_performance();
+extern fixed fxSub_float(), fxSub_precision(), fxSub_fair(), fxSub_performance();
+extern fixed fxMul_float(), fxMul_precision(), fxMul_fair(), fxMul_performance();
+extern fixed fxDiv_float(), fxDiv_precision(), fxDiv_fair(), fxDiv_performance();
+
diff --git a/speedtest/testcodediv.c b/speedtest/testcodediv.c
new file mode 100644
index 0000000..f79dac1
--- /dev/null
+++ b/speedtest/testcodediv.c
@@ -0,0 +1,22 @@
+#include "fx_s17_14.h"
+#include <stdio.h>
+
+int main()
+{
+ double i;
+ int div1, div2, div3, div4;
+ for ( i = -362; i < -0.000001; i+=0.0001)
+ {
+ div1 = fxDiv_float(fromDouble(i), fromDouble(i));
+ div2 = fxDiv_precision(fromDouble(i), fromDouble(i));
+ div3 = fxDiv_fair(fromDouble(i), fromDouble(i));
+ div4 = fxDiv_performance(fromDouble(i), fromDouble(i));
+
+ fprintf(stdout, "%f / %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(div1));
+ fprintf(stdout, "%f / %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(div2));
+ fprintf(stdout, "%f / %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(div3));
+ fprintf(stdout, "%f / %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(div4));
+ fprintf(stdout, "=============================== \n");
+ }
+ return 0;
+}
diff --git a/speedtest/testcodediv.txt b/speedtest/testcodediv.txt
new file mode 100644
index 0000000..94ace4b
--- /dev/null
+++ b/speedtest/testcodediv.txt
@@ -0,0 +1,162 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 77.06 0.50 0.50 main
+ 9.25 0.56 0.06 3620000 16.60 16.60 fxDiv_float
+ 6.16 0.60 0.04 3620000 11.07 11.07 fxDiv_fair
+ 4.62 0.63 0.03 3620000 8.30 8.30 fxDiv_performance
+ 3.08 0.65 0.02 3620000 5.53 5.53 fxDiv_precision
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 1.54% of 0.65 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 100.0 0.50 0.15 main [1]
+ 0.06 0.00 3620000/3620000 fxDiv_float [2]
+ 0.04 0.00 3620000/3620000 fxDiv_fair [3]
+ 0.03 0.00 3620000/3620000 fxDiv_performance [4]
+ 0.02 0.00 3620000/3620000 fxDiv_precision [5]
+-----------------------------------------------
+ 0.06 0.00 3620000/3620000 main [1]
+[2] 9.2 0.06 0.00 3620000 fxDiv_float [2]
+-----------------------------------------------
+ 0.04 0.00 3620000/3620000 main [1]
+[3] 6.2 0.04 0.00 3620000 fxDiv_fair [3]
+-----------------------------------------------
+ 0.03 0.00 3620000/3620000 main [1]
+[4] 4.6 0.03 0.00 3620000 fxDiv_performance [4]
+-----------------------------------------------
+ 0.02 0.00 3620000/3620000 main [1]
+[5] 3.1 0.02 0.00 3620000 fxDiv_precision [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [3] fxDiv_fair [4] fxDiv_performance [1] main
+ [2] fxDiv_float [5] fxDiv_precision
diff --git a/speedtest/testcodemul.c b/speedtest/testcodemul.c
new file mode 100644
index 0000000..9e89855
--- /dev/null
+++ b/speedtest/testcodemul.c
@@ -0,0 +1,22 @@
+#include "fx_s17_14.h"
+#include <stdio.h>
+
+int main()
+{
+ double i;
+ int mul1, mul2, mul3, mul4;
+ for ( i = -362; i < 362; i+=0.001)
+ {
+ mul1 = fxMul_float(fromDouble(i), fromDouble(i));
+ mul2 = fxMul_precision(fromDouble(i), fromDouble(i));
+ mul3 = fxMul_fair(fromDouble(i), fromDouble(i));
+ mul4 = fxMul_performance(fromDouble(i), fromDouble(i));
+
+ fprintf(stdout, "%f * %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(mul1));
+ fprintf(stdout, "%f * %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(mul2));
+ fprintf(stdout, "%f * %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(mul3));
+ fprintf(stdout, "%f * %f = %.15f \n", fromDouble(i), fromDouble(i), toDouble(mul4));
+ fprintf(stdout, "=============================== \n");
+ }
+ return 0;
+}
diff --git a/speedtest/testcodemul.txt b/speedtest/testcodemul.txt
new file mode 100644
index 0000000..3317d81
--- /dev/null
+++ b/speedtest/testcodemul.txt
@@ -0,0 +1,162 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 87.66 0.07 0.07 main
+ 12.52 0.08 0.01 724001 13.84 13.84 fxMul_float
+ 0.00 0.08 0.00 724001 0.00 0.00 fxMul_fair
+ 0.00 0.08 0.00 724001 0.00 0.00 fxMul_performance
+ 0.00 0.08 0.00 724001 0.00 0.00 fxMul_precision
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 12.48% of 0.08 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 100.0 0.07 0.01 main [1]
+ 0.01 0.00 724001/724001 fxMul_float [2]
+ 0.00 0.00 724001/724001 fxMul_precision [5]
+ 0.00 0.00 724001/724001 fxMul_fair [3]
+ 0.00 0.00 724001/724001 fxMul_performance [4]
+-----------------------------------------------
+ 0.01 0.00 724001/724001 main [1]
+[2] 12.5 0.01 0.00 724001 fxMul_float [2]
+-----------------------------------------------
+ 0.00 0.00 724001/724001 main [1]
+[3] 0.0 0.00 0.00 724001 fxMul_fair [3]
+-----------------------------------------------
+ 0.00 0.00 724001/724001 main [1]
+[4] 0.0 0.00 0.00 724001 fxMul_performance [4]
+-----------------------------------------------
+ 0.00 0.00 724001/724001 main [1]
+[5] 0.0 0.00 0.00 724001 fxMul_precision [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [3] fxMul_fair [4] fxMul_performance [1] main
+ [2] fxMul_float [5] fxMul_precision
diff --git a/speedtest/testdiv_32.txt b/speedtest/testdiv_32.txt
new file mode 100644
index 0000000..a70ab95
--- /dev/null
+++ b/speedtest/testdiv_32.txt
@@ -0,0 +1,175 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 72.32 0.78 0.78 main
+ 12.98 0.92 0.14 __divdi3
+ 9.73 1.03 0.11 3620000 29.04 29.04 fxDiv_float
+ 1.85 1.05 0.02 3620000 5.53 5.53 fxDiv_precision
+ 1.85 1.07 0.02 __x86.get_pc_thunk.bx
+ 0.93 1.08 0.01 3620000 2.77 2.77 fxDiv_fair
+ 0.46 1.08 0.01 fxMul_float
+ 0.00 1.08 0.00 3620000 0.00 0.00 fxDiv_performance
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 0.92% of 1.08 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 84.7 0.78 0.14 main [1]
+ 0.11 0.00 3620000/3620000 fxDiv_float [3]
+ 0.02 0.00 3620000/3620000 fxDiv_precision [4]
+ 0.01 0.00 3620000/3620000 fxDiv_fair [6]
+ 0.00 0.00 3620000/3620000 fxDiv_performance [8]
+-----------------------------------------------
+ <spontaneous>
+[2] 13.0 0.14 0.00 __divdi3 [2]
+-----------------------------------------------
+ 0.11 0.00 3620000/3620000 main [1]
+[3] 9.7 0.11 0.00 3620000 fxDiv_float [3]
+-----------------------------------------------
+ 0.02 0.00 3620000/3620000 main [1]
+[4] 1.9 0.02 0.00 3620000 fxDiv_precision [4]
+-----------------------------------------------
+ <spontaneous>
+[5] 1.9 0.02 0.00 __x86.get_pc_thunk.bx [5]
+-----------------------------------------------
+ 0.01 0.00 3620000/3620000 main [1]
+[6] 0.9 0.01 0.00 3620000 fxDiv_fair [6]
+-----------------------------------------------
+ <spontaneous>
+[7] 0.5 0.01 0.00 fxMul_float [7]
+-----------------------------------------------
+ 0.00 0.00 3620000/3620000 main [1]
+[8] 0.0 0.00 0.00 3620000 fxDiv_performance [8]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [2] __divdi3 [3] fxDiv_float [7] fxMul_float
+ [5] __x86.get_pc_thunk.bx [8] fxDiv_performance [1] main
+ [6] fxDiv_fair [4] fxDiv_precision
diff --git a/speedtest/testdiv_64.txt b/speedtest/testdiv_64.txt
new file mode 100644
index 0000000..3da672f
--- /dev/null
+++ b/speedtest/testdiv_64.txt
@@ -0,0 +1,162 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 74.05 0.34 0.34 main
+ 10.89 0.39 0.05 3620000 13.84 13.84 fxDiv_float
+ 6.53 0.42 0.03 3620000 8.30 8.30 fxDiv_performance
+ 6.53 0.45 0.03 3620000 8.30 8.30 fxDiv_fair
+ 2.18 0.46 0.01 3620000 2.77 2.77 fxDiv_precision
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 2.17% of 0.46 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 100.0 0.34 0.12 main [1]
+ 0.05 0.00 3620000/3620000 fxDiv_float [2]
+ 0.03 0.00 3620000/3620000 fxDiv_performance [3]
+ 0.03 0.00 3620000/3620000 fxDiv_fair [4]
+ 0.01 0.00 3620000/3620000 fxDiv_precision [5]
+-----------------------------------------------
+ 0.05 0.00 3620000/3620000 main [1]
+[2] 10.9 0.05 0.00 3620000 fxDiv_float [2]
+-----------------------------------------------
+ 0.03 0.00 3620000/3620000 main [1]
+[3] 6.5 0.03 0.00 3620000 fxDiv_performance [3]
+-----------------------------------------------
+ 0.03 0.00 3620000/3620000 main [1]
+[4] 6.5 0.03 0.00 3620000 fxDiv_fair [4]
+-----------------------------------------------
+ 0.01 0.00 3620000/3620000 main [1]
+[5] 2.2 0.01 0.00 3620000 fxDiv_precision [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [4] fxDiv_fair [3] fxDiv_performance [1] main
+ [2] fxDiv_float [5] fxDiv_precision
diff --git a/speedtest/testmul_32.txt b/speedtest/testmul_32.txt
new file mode 100644
index 0000000..55ea5e2
--- /dev/null
+++ b/speedtest/testmul_32.txt
@@ -0,0 +1,162 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 87.61 0.21 0.21 main
+ 8.34 0.23 0.02 724001 27.66 27.66 fxMul_float
+ 4.17 0.24 0.01 724001 13.83 13.83 fxMul_performance
+ 0.00 0.24 0.00 724001 0.00 0.00 fxMul_fair
+ 0.00 0.24 0.00 724001 0.00 0.00 fxMul_precision
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 4.16% of 0.24 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 100.0 0.21 0.03 main [1]
+ 0.02 0.00 724001/724001 fxMul_float [2]
+ 0.01 0.00 724001/724001 fxMul_performance [3]
+ 0.00 0.00 724001/724001 fxMul_precision [5]
+ 0.00 0.00 724001/724001 fxMul_fair [4]
+-----------------------------------------------
+ 0.02 0.00 724001/724001 main [1]
+[2] 8.3 0.02 0.00 724001 fxMul_float [2]
+-----------------------------------------------
+ 0.01 0.00 724001/724001 main [1]
+[3] 4.2 0.01 0.00 724001 fxMul_performance [3]
+-----------------------------------------------
+ 0.00 0.00 724001/724001 main [1]
+[4] 0.0 0.00 0.00 724001 fxMul_fair [4]
+-----------------------------------------------
+ 0.00 0.00 724001/724001 main [1]
+[5] 0.0 0.00 0.00 724001 fxMul_precision [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [4] fxMul_fair [3] fxMul_performance [1] main
+ [2] fxMul_float [5] fxMul_precision
diff --git a/speedtest/testmul_64.txt b/speedtest/testmul_64.txt
new file mode 100644
index 0000000..84e1128
--- /dev/null
+++ b/speedtest/testmul_64.txt
@@ -0,0 +1,162 @@
+Flat profile:
+
+Each sample counts as 0.01 seconds.
+ % cumulative self self total
+ time seconds seconds calls ns/call ns/call name
+ 90.17 0.09 0.09 main
+ 10.02 0.10 0.01 724001 13.84 13.84 fxMul_float
+ 0.00 0.10 0.00 724001 0.00 0.00 fxMul_fair
+ 0.00 0.10 0.00 724001 0.00 0.00 fxMul_performance
+ 0.00 0.10 0.00 724001 0.00 0.00 fxMul_precision
+
+ % the percentage of the total running time of the
+time program used by this function.
+
+cumulative a running sum of the number of seconds accounted
+ seconds for by this function and those listed above it.
+
+ self the number of seconds accounted for by this
+seconds function alone. This is the major sort for this
+ listing.
+
+calls the number of times this function was invoked, if
+ this function is profiled, else blank.
+
+ self the average number of milliseconds spent in this
+ms/call function per call, if this function is profiled,
+ else blank.
+
+ total the average number of milliseconds spent in this
+ms/call function and its descendents per call, if this
+ function is profiled, else blank.
+
+name the name of the function. This is the minor sort
+ for this listing. The index shows the location of
+ the function in the gprof listing. If the index is
+ in parenthesis it shows where it would appear in
+ the gprof listing if it were to be printed.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+ Call graph (explanation follows)
+
+
+granularity: each sample hit covers 2 byte(s) for 9.98% of 0.10 seconds
+
+index % time self children called name
+ <spontaneous>
+[1] 100.0 0.09 0.01 main [1]
+ 0.01 0.00 724001/724001 fxMul_float [2]
+ 0.00 0.00 724001/724001 fxMul_precision [5]
+ 0.00 0.00 724001/724001 fxMul_fair [3]
+ 0.00 0.00 724001/724001 fxMul_performance [4]
+-----------------------------------------------
+ 0.01 0.00 724001/724001 main [1]
+[2] 10.0 0.01 0.00 724001 fxMul_float [2]
+-----------------------------------------------
+ 0.00 0.00 724001/724001 main [1]
+[3] 0.0 0.00 0.00 724001 fxMul_fair [3]
+-----------------------------------------------
+ 0.00 0.00 724001/724001 main [1]
+[4] 0.0 0.00 0.00 724001 fxMul_performance [4]
+-----------------------------------------------
+ 0.00 0.00 724001/724001 main [1]
+[5] 0.0 0.00 0.00 724001 fxMul_precision [5]
+-----------------------------------------------
+
+ This table describes the call tree of the program, and was sorted by
+ the total amount of time spent in each function and its children.
+
+ Each entry in this table consists of several lines. The line with the
+ index number at the left hand margin lists the current function.
+ The lines above it list the functions that called this function,
+ and the lines below it list the functions this one called.
+ This line lists:
+ index A unique number given to each element of the table.
+ Index numbers are sorted numerically.
+ The index number is printed next to every function name so
+ it is easier to look up where the function is in the table.
+
+ % time This is the percentage of the `total' time that was spent
+ in this function and its children. Note that due to
+ different viewpoints, functions excluded by options, etc,
+ these numbers will NOT add up to 100%.
+
+ self This is the total amount of time spent in this function.
+
+ children This is the total amount of time propagated into this
+ function by its children.
+
+ called This is the number of times the function was called.
+ If the function called itself recursively, the number
+ only includes non-recursive calls, and is followed by
+ a `+' and the number of recursive calls.
+
+ name The name of the current function. The index number is
+ printed after it. If the function is a member of a
+ cycle, the cycle number is printed between the
+ function's name and the index number.
+
+
+ For the function's parents, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the function into this parent.
+
+ children This is the amount of time that was propagated from
+ the function's children into this parent.
+
+ called This is the number of times this parent called the
+ function `/' the total number of times the function
+ was called. Recursive calls to the function are not
+ included in the number after the `/'.
+
+ name This is the name of the parent. The parent's index
+ number is printed after it. If the parent is a
+ member of a cycle, the cycle number is printed between
+ the name and the index number.
+
+ If the parents of the function cannot be determined, the word
+ `<spontaneous>' is printed in the `name' field, and all the other
+ fields are blank.
+
+ For the function's children, the fields have the following meanings:
+
+ self This is the amount of time that was propagated directly
+ from the child into the function.
+
+ children This is the amount of time that was propagated from the
+ child's children to the function.
+
+ called This is the number of times the function called
+ this child `/' the total number of times the child
+ was called. Recursive calls by the child are not
+ listed in the number after the `/'.
+
+ name This is the name of the child. The child's index
+ number is printed after it. If the child is a
+ member of a cycle, the cycle number is printed
+ between the name and the index number.
+
+ If there are any cycles (circles) in the call graph, there is an
+ entry for the cycle-as-a-whole. This entry shows who called the
+ cycle (as parents) and the members of the cycle (as children.)
+ The `+' recursive calls entry shows the number of function calls that
+ were internal to the cycle, and the calls entry for each member shows,
+ for that member, how many times it was called from other members of
+ the cycle.
+
+Copyright (C) 2012-2018 Free Software Foundation, Inc.
+
+Copying and distribution of this file, with or without modification,
+are permitted in any medium without royalty provided the copyright
+notice and this notice are preserved.
+
+Index by function name
+
+ [3] fxMul_fair [4] fxMul_performance [1] main
+ [2] fxMul_float [5] fxMul_precision
--
GitLab