Changeset e6f5766 in mainline


Ignore:
Timestamp:
2015-09-05T10:11:40Z (9 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
9adb61d
Parents:
01cdd5a
Message:

Use floatN_t types in generic function interfaces.

Location:
uspace/lib/math
Files:
18 edited

Legend:

Unmodified
Added
Removed

  • uspace/lib/math/arch/abs32le/include/libarch/math.h

    r01cdd5a re6f5766  
    5353static inline float64_t trunc(float64_t val)
    5454{
    55         float64_u arg;
    56         arg.val = val;
    57        
    58         float64_u ret;
    59         ret.data = trunc_float64(arg.data);
    60        
    61         return ret.val;
     55        return float64_trunc(val);
    6256}
    6357
    6458static inline float64_t ceil(float64_t val)
    6559{
    66         float64_u arg;
    67         arg.val = val;
    68        
    69         float64_u ret;
    70         ret.data = ceil_float64(arg.data);
    71        
    72         return ret.val;
     60        return float64_ceil(val);
    7361}
    7462
    … …  
    8573static inline float64_t floor(float64_t val)
    8674{
    87         float64_u arg;
    88         arg.val = val;
    89        
    90         float64_u ret;
    91         ret.data = floor_float64(arg.data);
    92        
    93         return ret.val;
     75        return float64_floor(val);
    9476}
    9577

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

    r01cdd5a re6f5766  
    5454static inline float64_t ceil(float64_t val)
    5555{
    56         float64_u arg;
    57         arg.val = val;
    58        
    59         float64_u ret;
    60         ret.data = ceil_float64(arg.data);
    61        
    62         return ret.val;
     56        return float64_ceil(val);
    6357}
    6458
    … …  
    7569static inline float64_t floor(float64_t val)
    7670{
    77         float64_u arg;
    78         arg.val = val;
    79        
    80         float64_u ret;
    81         ret.data = floor_float64(arg.data);
    82        
    83         return ret.val;
     71        return float64_floor(val);
    8472}
    8573

  • uspace/lib/math/arch/arm32/include/libarch/math.h

    r01cdd5a re6f5766  
    5353static inline float64_t trunc(float64_t val)
    5454{
    55         float64_u arg;
    56         arg.val = val;
    57        
    58         float64_u ret;
    59         ret.data = trunc_float64(arg.data);
    60        
    61         return ret.val;
     55        return float64_trunc(val);
    6256}
    6357
    6458static inline float64_t ceil(float64_t val)
    6559{
    66         float64_u arg;
    67         arg.val = val;
    68        
    69         float64_u ret;
    70         ret.data = ceil_float64(arg.data);
    71        
    72         return ret.val;
     60        return float64_ceil(val);
    7361}
    7462
    … …  
    8573static inline float64_t floor(float64_t val)
    8674{
    87         float64_u arg;
    88         arg.val = val;
    89        
    90         float64_u ret;
    91         ret.data = floor_float64(arg.data);
    92        
    93         return ret.val;
     75        return float64_floor(val);
    9476}
    9577

  • uspace/lib/math/arch/ia32/include/libarch/math.h

    r01cdd5a re6f5766  
    5454static inline float64_t ceil(float64_t val)
    5555{
    56         float64_u arg;
    57         arg.val = val;
    58        
    59         float64_u ret;
    60         ret.data = ceil_float64(arg.data);
    61        
    62         return ret.val;
     56        return float64_ceil(val);
    6357}
    6458
    6559static inline float64_t floor(float64_t val)
    6660{
    67         float64_u arg;
    68         arg.val = val;
    69        
    70         float64_u ret;
    71         ret.data = floor_float64(arg.data);
    72        
    73         return ret.val;
     61        return float64_floor(val);
    7462}
    7563

  • uspace/lib/math/arch/ia64/include/libarch/math.h

    r01cdd5a re6f5766  
    5353static inline float64_t trunc(float64_t val)
    5454{
    55         float64_u arg;
    56         arg.val = val;
    57        
    58         float64_u ret;
    59         ret.data = trunc_float64(arg.data);
    60        
    61         return ret.val;
     55        return float64_trunc(val);
    6256}
    6357
    6458static inline float64_t ceil(float64_t val)
    6559{
    66         float64_u arg;
    67         arg.val = val;
    68        
    69         float64_u ret;
    70         ret.data = ceil_float64(arg.data);
    71        
    72         return ret.val;
     60        return float64_ceil(val);
    7361}
    7462
    … …  
    8573static inline float64_t floor(float64_t val)
    8674{
    87         float64_u arg;
    88         arg.val = val;
    89        
    90         float64_u ret;
    91         ret.data = floor_float64(arg.data);
    92        
    93         return ret.val;
     75        return float64_floor(val);
    9476}
    9577

  • uspace/lib/math/arch/mips32/include/libarch/math.h

    r01cdd5a re6f5766  
    5353static inline float64_t trunc(float64_t val)
    5454{
    55         float64_u arg;
    56         arg.val = val;
    57        
    58         float64_u ret;
    59         ret.data = trunc_float64(arg.data);
    60        
    61         return ret.val;
     55        return float64_trunc(val);
    6256}
    6357
    6458static inline float64_t ceil(float64_t val)
    6559{
    66         float64_u arg;
    67         arg.val = val;
    68        
    69         float64_u ret;
    70         ret.data = ceil_float64(arg.data);
    71        
    72         return ret.val;
     60        return float64_ceil(val);
    7361}
    7462
    … …  
    8573static inline float64_t floor(float64_t val)
    8674{
    87         float64_u arg;
    88         arg.val = val;
    89        
    90         float64_u ret;
    91         ret.data = floor_float64(arg.data);
    92        
    93         return ret.val;
     75        return float64_floor(val);
    9476}
    9577

  • uspace/lib/math/arch/mips32eb/include/libarch/math.h

    r01cdd5a re6f5766  
    5353static inline float64_t trunc(float64_t val)
    5454{
    55         float64_u arg;
    56         arg.val = val;
    57        
    58         float64_u ret;
    59         ret.data = trunc_float64(arg.data);
    60        
    61         return ret.val;
     55        return float64_trunc(val);
    6256}
    6357
    6458static inline float64_t ceil(float64_t val)
    6559{
    66         float64_u arg;
    67         arg.val = val;
    68        
    69         float64_u ret;
    70         ret.data = ceil_float64(arg.data);
    71        
    72         return ret.val;
     60        return float64_ceil(val);
    7361}
    7462
    … …  
    8573static inline float64_t floor(float64_t val)
    8674{
    87         float64_u arg;
    88         arg.val = val;
    89        
    90         float64_u ret;
    91         ret.data = floor_float64(arg.data);
    92        
    93         return ret.val;
     75        return float64_floor(val);
    9476}
    9577

  • uspace/lib/math/arch/ppc32/include/libarch/math.h

    r01cdd5a re6f5766  
    5353static inline double trunc(double val)
    5454{
    55         float64_u arg;
    56         arg.val = val;
    57        
    58         float64_u ret;
    59         ret.data = trunc_float64(arg.data);
    60        
    61         return ret.val;
     55        return float64_trunc(val);
    6256}
    6357
    6458static inline float64_t ceil(float64_t val)
    6559{
    66         float64_u arg;
    67         arg.val = val;
    68        
    69         float64_u ret;
    70         ret.data = ceil_float64(arg.data);
    71        
    72         return ret.val;
     60        return float64_ceil(val);
    7361}
    7462
    … …  
    8573static inline float64_t floor(float64_t val)
    8674{
    87         float64_u arg;
    88         arg.val = val;
    89        
    90         float64_u ret;
    91         ret.data = floor_float64(arg.data);
    92        
    93         return ret.val;
     75        return float64_floor(val);
    9476}
    9577

  • uspace/lib/math/arch/sparc32/include/libarch/math.h

    r01cdd5a re6f5766  
    5353static inline float64_t trunc(float64_t val)
    5454{
    55         float64_u arg;
    56         arg.val = val;
    57        
    58         float64_u ret;
    59         ret.data = trunc_float64(arg.data);
    60        
    61         return ret.val;
     55        return float64_trunc(val);
    6256}
    6357
    6458static inline float64_t ceil(float64_t val)
    6559{
    66         float64_u arg;
    67         arg.val = val;
    68        
    69         float64_u ret;
    70         ret.data = ceil_float64(arg.data);
    71        
    72         return ret.val;
     60        return float64_ceil(val);
    7361}
    7462
    … …  
    8573static inline float64_t floor(float64_t val)
    8674{
    87         float64_u arg;
    88         arg.val = val;
    89        
    90         float64_u ret;
    91         ret.data = floor_float64(arg.data);
    92        
    93         return ret.val;
     75        return float64_floor(val);
    9476}
    9577

  • uspace/lib/math/arch/sparc64/include/libarch/math.h

    r01cdd5a re6f5766  
    5353static inline float64_t trunc(float64_t val)
    5454{
    55         float64_u arg;
    56         arg.val = val;
    57        
    58         float64_u ret;
    59         ret.data = trunc_float64(arg.data);
    60        
    61         return ret.val;
     55        return float64_trunc(val);
    6256}
    6357
    6458static inline float64_t ceil(float64_t val)
    6559{
    66         float64_u arg;
    67         arg.val = val;
    68        
    69         float64_u ret;
    70         ret.data = ceil_float64(arg.data);
    71        
    72         return ret.val;
     60        return float64_ceil(val);
    7361}
    7462
    … …  
    8573static inline float64_t floor(float64_t val)
    8674{
    87         float64_u arg;
    88         arg.val = val;
    89        
    90         float64_u ret;
    91         ret.data = floor_float64(arg.data);
    92        
    93         return ret.val;
     75        return float64_floor(val);
    9476}
    9577

  • uspace/lib/math/generic/ceil.c

    r01cdd5a re6f5766  
    4343 * @return Number rounded towards positive infinity.
    4444 */
    45 float64 ceil_float64(float64 val)
     45float64_t float64_ceil(float64_t val)
    4646{
    4747        float64_u t;
    … …  
    4949        float64_u r;
    5050       
    51         v.data = val;
    52         t.data = trunc_float64(val);
     51        v.val = val;
     52        t.val = float64_trunc(val);
    5353       
    54         if (val.parts.sign == 1 || v.val == t.val) {
     54        if (v.data.parts.sign == 1 || val == t.val) {
    5555                r = t;
    5656        } else {
    … …  
    5858        }
    5959       
    60         return r.data;
     60        return r.val;
    6161}
    6262

  • uspace/lib/math/generic/exp.c

    r01cdd5a re6f5766  
    111111{
    112112        float32_t f;
    113         float32_u i;
    114         float32_u m;
     113        float32_t i;
    115114        float32_u r;
    116115
    … …  
    122121         */
    123122
    124         m.val = arg * M_LOG2E;
    125         i.data = trunc_float32(m.data);
    126         f = arg * M_LOG2E - i.val;
     123        i = float32_trunc(arg * M_LOG2E);
     124        f = arg * M_LOG2E - i;
    127125
    128126        r.val = taylor_exp_32(M_LN2 * f);
    129         r.data.parts.exp += i.val;
     127        r.data.parts.exp += i;
    130128        return r.val;
    131129}
    … …  
    143141{
    144142        float64_t f;
    145         float64_u i;
    146         float64_u m;
     143        float64_t i;
    147144        float64_u r;
    148145
    … …  
    154151         */
    155152
    156         m.val = arg * M_LOG2E;
    157         i.data = trunc_float64(m.data);
    158         f = arg * M_LOG2E - i.val;
     153        i = float64_trunc(arg * M_LOG2E);
     154        f = arg * M_LOG2E - i;
    159155
    160156        r.val = taylor_exp_64(M_LN2 * f);
    161         r.data.parts.exp += i.val;
     157        r.data.parts.exp += i;
    162158        return r.val;
    163159}

  • uspace/lib/math/generic/floor.c

    r01cdd5a re6f5766  
    4444 */
    4545
    46 float64 floor_float64(float64 val)
     46float64_t float64_floor(float64_t val)
    4747{
    48         float64_u t;
     48        float64_t t;
    4949        float64_u v;
    50         float64_u r;
    5150       
    52         v.data = val;
    53         t.data = trunc_float64(val);
     51        v.val = val;
     52        t = float64_trunc(val);
    5453       
    55         if (val.parts.sign == 0 || v.val == t.val) {
    56                 r = t;
    57         } else {
    58                 r.val = t.val - 1.0;
    59         }
    60        
    61         return r.data;
     54        if (v.data.parts.sign == 0 || val == t)
     55                return t;
     56        else
     57                return t - 1.0;
    6258}
    6359

  • uspace/lib/math/generic/trunc.c

    r01cdd5a re6f5766  
    5151 *
    5252 */
    53 float32 trunc_float32(float32 val)
     53float32_t float32_trunc(float32_t val)
    5454{
    55         int32_t exp = val.parts.exp - FLOAT32_BIAS;
     55        float32_u v;
     56        int32_t exp;
     57       
     58        v.val = val;
     59        exp = v.data.parts.exp - FLOAT32_BIAS;
    5660       
    5761        if (exp < 0) {
    5862                /* -1 < val < 1 => result is +0 or -0 */
    59                 val.parts.exp = 0;
    60                 val.parts.fraction = 0;
     63                v.data.parts.exp = 0;
     64                v.data.parts.fraction = 0;
    6165        } else if (exp >= FLOAT32_FRACTION_SIZE) {
    6266                if (exp == 1024) {
    … …  
    6872        } else {
    6973                /* Truncate irrelevant fraction bits */
    70                 val.parts.fraction &= ~(UINT32_C(0x007fffff) >> exp);
     74                v.data.parts.fraction &= ~(UINT32_C(0x007fffff) >> exp);
    7175        }
    7276       
    73         return val;
     77        return v.val;
    7478}
    7579
    … …  
    8993 *
    9094 */
    91 float64 trunc_float64(float64 val)
     95float64_t float64_trunc(float64_t val)
    9296{
    93         int32_t exp = val.parts.exp - FLOAT64_BIAS;
     97        float64_u v;
     98        int32_t exp;
     99       
     100        v.val = val;
     101        exp = v.data.parts.exp - FLOAT64_BIAS;
    94102       
    95103        if (exp < 0) {
    96104                /* -1 < val < 1 => result is +0 or -0 */
    97                 val.parts.exp = 0;
    98                 val.parts.fraction = 0;
     105                v.data.parts.exp = 0;
     106                v.data.parts.fraction = 0;
    99107        } else if (exp >= FLOAT64_FRACTION_SIZE) {
    100108                if (exp == 1024) {
    … …  
    106114        } else {
    107115                /* Truncate irrelevant fraction bits */
    108                 val.parts.fraction &= ~(UINT64_C(0x000fffffffffffff) >> exp);
     116                v.data.parts.fraction &= ~(UINT64_C(0x000fffffffffffff) >> exp);
    109117        }
    110118       
    111         return val;
     119        return v.val;
    112120}
    113121

  • uspace/lib/math/include/ceil.h

    r01cdd5a re6f5766  
    3838#include <mathtypes.h>
    3939
    40 extern float64 ceil_float64(float64);
     40extern float64_t float64_ceil(float64_t);
    4141
    4242#endif

  • uspace/lib/math/include/floor.h

    r01cdd5a re6f5766  
    3838#include <mathtypes.h>
    3939
    40 extern float64 floor_float64(float64);
     40extern float64_t float64_floor(float64_t);
    4141
    4242#endif

  • uspace/lib/math/include/trig.h

    r01cdd5a re6f5766  
    3636#define LIBMATH_TRIG_H_
    3737
     38#include <mathtypes.h>
     39
    3840extern float64_t float64_sin(float64_t);
    3941extern float64_t float64_cos(float64_t);

  • uspace/lib/math/include/trunc.h

    r01cdd5a re6f5766  
    3838#include <mathtypes.h>
    3939
    40 extern float32 trunc_float32(float32);
    41 extern float64 trunc_float64(float64);
     40extern float32_t float32_trunc(float32_t);
     41extern float64_t float64_trunc(float64_t);
    4242
    4343#endif
Note: See TracChangeset for help on using the changeset viewer.