Changeset e6f5766 in mainline for uspace/lib/math/generic


Ignore:
Timestamp:
2015-09-05T10:11:40Z (10 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/generic
Files:
4 edited

Legend:

Unmodified
Added
Removed
  • 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
Note: See TracChangeset for help on using the changeset viewer.