Changeset 992ffa6 in mainline for uspace/lib

Timestamp:

2015-09-04T06:40:20Z (10 years ago)

Author:

Jiri Svoboda <jiri@…>

Branches:

lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export

Children:

01cdd5a

Parents:

bae1e1f

Message:

Add exp(f), log(f), pow(f). Improve precision of sin, cos.

Location:

uspace/lib/math

Files:

• Makefile (modified) (1 diff)
• arch/amd64/include/libarch/math.h (modified) (3 diffs)
• generic/ceil.c (modified) (2 diffs)
• generic/exp.c (added)
• generic/floor.c (modified) (2 diffs)
• generic/log.c (added)
• generic/pow.c (added)
• generic/trig.c (modified) (3 diffs)
• generic/trunc.c (modified) (1 diff)
• include/exp.h (added)
• include/log.h (added)
• include/math.h (modified) (1 diff)
• include/pow.h (added)
• include/trunc.h (modified) (1 diff)

uspace/lib/math/Makefile

@@ -42 +42 @@
 GENERIC_SOURCES = \
         generic/ceil.c \
+        generic/exp.c \
         generic/floor.c \
+        generic/log.c \
         generic/trig.c \
+        generic/pow.c \
         generic/mod.c \
         generic/trunc.c

uspace/lib/math/arch/amd64/include/libarch/math.h

@@ -37 +37 @@
 
 #include <ceil.h>
+#include <exp.h>
 #include <floor.h>
+#include <log.h>
 #include <mathtypes.h>
 #include <mod.h>
+#include <pow.h>
 
 static inline float64_t fmod(float64_t dividend, float64_t divisor)
@@ -60 +63 @@
 }
 
+static inline float32_t expf(float32_t val)
+{
+        return float32_exp(val);
+}
+
+static inline float64_t exp(float64_t val)
+{
+        return float64_exp(val);
+}
+
 static inline float64_t floor(float64_t val)
 {
@@ -71 +84 @@
 }
 
+static inline float32_t logf(float32_t val)
+{
+        return float32_log(val);
+}
+
+static inline float64_t log(float64_t val)
+{
+        return float64_log(val);
+}
+
+static inline float32_t powf(float32_t x, float32_t y)
+{
+        return float32_pow(x, y);
+}
+
+static inline float64_t pow(float64_t x, float64_t y)
+{
+        return float64_pow(x, y);
+}
+
 extern float64_t trunc(float64_t);
 

uspace/lib/math/generic/ceil.c

@@ -48 +48 @@
         float64_u v;
         float64_u r;
-
+        
         v.data = val;
         t.data = trunc_float64(val);
-
+        
         if (val.parts.sign == 1 || v.val == t.val) {
                 r = t;
@@ -57 +57 @@
                 r.val = t.val + 1.0;
         }
-
+        
         return r.data;
 }

uspace/lib/math/generic/floor.c

@@ -49 +49 @@
         float64_u v;
         float64_u r;
-
+        
         v.data = val;
         t.data = trunc_float64(val);
-
+        
         if (val.parts.sign == 0 || v.val == t.val) {
                 r = t;
@@ -58 +58 @@
                 r.val = t.val - 1.0;
         }
-
+        
         return r.data;
 }

uspace/lib/math/generic/trig.c

@@ -36 +36 @@
 #include <trig.h>
 
-#define TAYLOR_DEGREE  13
+#define TAYLOR_DEGREE_32 13
+#define TAYLOR_DEGREE_64 21
 
 /** Precomputed values for factorial (starting from 1!) */
-static float64_t factorials[TAYLOR_DEGREE] = {
+static float64_t factorials[TAYLOR_DEGREE_64] = {
         1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800, 39916800,
-        479001600, 6227020800
+        479001600, 6227020800.0L, 87178291200.0L, 1307674368000.0L,
+        20922789888000.0L, 355687428096000.0L, 6402373705728000.0L,
+        121645100408832000.0L, 2432902008176640000.0L, 51090942171709440000.0L
 };
 
@@ -61 +64 @@
         float64_t nom = 1;
         
-        for (unsigned int i = 0; i < TAYLOR_DEGREE; i++) {
+        for (unsigned int i = 0; i < TAYLOR_DEGREE_64; i++) {
                 nom *= arg;
                 
@@ -90 +93 @@
         float64_t nom = 1;
         
-        for (unsigned int i = 0; i < TAYLOR_DEGREE; i++) {
+        for (unsigned int i = 0; i < TAYLOR_DEGREE_64; i++) {
                 nom *= arg;
                 

uspace/lib/math/generic/trunc.c

@@ -35 +35 @@
 #include <mathtypes.h>
 #include <trunc.h>
+
+/** Truncate fractional part (round towards zero)
+ *
+ * Truncate the fractional part of IEEE 754 single
+ * precision floating point number by zeroing fraction
+ * bits, effectively rounding the number towards zero
+ * to the nearest whole number.
+ *
+ * If the argument is infinity or NaN, an exception
+ * should be indicated. This is not implemented yet.
+ *
+ * @param val Floating point number.
+ *
+ * @return Number rounded towards zero.
+ *
+ */
+float32 trunc_float32(float32 val)
+{
+        int32_t exp = val.parts.exp - FLOAT32_BIAS;
+        
+        if (exp < 0) {
+                /* -1 < val < 1 => result is +0 or -0 */
+                val.parts.exp = 0;
+                val.parts.fraction = 0;
+        } else if (exp >= FLOAT32_FRACTION_SIZE) {
+                if (exp == 1024) {
+                        /* val is +inf, -inf or NaN => trigger an exception */
+                        // FIXME TODO
+                }
+                
+                /* All bits in val are relevant for the result */
+        } else {
+                /* Truncate irrelevant fraction bits */
+                val.parts.fraction &= ~(UINT32_C(0x007fffff) >> exp);
+        }
+        
+        return val;
+}
 
 /** Truncate fractional part (round towards zero)

uspace/lib/math/include/math.h

@@ -38 +38 @@
 #include <libarch/math.h>
 
-#define M_PI  3.14159265358979323846
+#define M_LN2 0.69314718055994530942
+#define M_LOG2E 1.4426950408889634074
+#define M_PI 3.14159265358979323846
 
 #endif

uspace/lib/math/include/trunc.h

@@ -38 +38 @@
 #include <mathtypes.h>
 
+extern float32 trunc_float32(float32);
 extern float64 trunc_float64(float64);