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


Ignore:
Timestamp:
2018-03-02T20:10:49Z (7 years ago)
Author:
Jiří Zárevúcky <zarevucky.jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
f1380b7
Parents:
3061bc1
git-author:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-02-28 17:38:31)
git-committer:
Jiří Zárevúcky <zarevucky.jiri@…> (2018-03-02 20:10:49)
Message:

style: Remove trailing whitespace on _all_ lines, including empty ones, for particular file types.

Command used: tools/srepl '\s\+$' '' -- *.c *.h *.py *.sh *.s *.S *.ag

Currently, whitespace on empty lines is very inconsistent.
There are two basic choices: Either remove the whitespace, or keep empty lines
indented to the level of surrounding code. The former is AFAICT more common,
and also much easier to do automatically.

Alternatively, we could write script for automatic indentation, and use that
instead. However, if such a script exists, it's possible to use the indented
style locally, by having the editor apply relevant conversions on load/save,
without affecting remote repository. IMO, it makes more sense to adopt
the simpler rule.

Location:
uspace/lib/math/generic
Files:
9 edited

Legend:

Unmodified
Added
Removed

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

    r3061bc1 ra35b458  
    4949{
    5050        float32_t aval;
    51        
     51
    5252        if (arg < -1.0 || arg > 1.0) {
    5353                errno = EDOM;
    5454                return FLOAT32_NAN;
    5555        }
    56        
     56
    5757        aval = 2.0 * atan_f32(arg / (1.0 + sqrt_f32(1.0 - arg*arg)));
    5858        if (arg > 0.0)
    … …  
    7474{
    7575        float64_t aval;
    76        
     76
    7777        if (arg < -1.0 || arg > 1.0) {
    7878                errno = EDOM;
    7979                return FLOAT64_NAN;
    8080        }
    81        
     81
    8282        aval = 2.0 * atan_f64(arg / (1.0 + sqrt_f64(1.0 - arg*arg)));
    8383        if (arg > 0.0)

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

    r3061bc1 ra35b458  
    5454        float32_t sum = 0;
    5555        float32_t a = arg / (1.0 + arg * arg);
    56        
     56
    5757        /*
    5858         * atan(z) = sum(n=0, +inf) [ (2^2n) * (n!)^2 / (2n + 1)! *
    5959         *    z^(2n+1) / (1 + z^2)^(n+1) ]
    6060         */
    61        
     61
    6262        for (unsigned int n = 0; n < SERIES_DEGREE_32; n++) {
    6363                if (n > 0) {
    … …  
    6868                a = a * 4.0 * arg * arg / (1.0 + arg * arg);
    6969        }
    70        
     70
    7171        return sum;
    7272}
    … …  
    8686        float64_t sum = 0;
    8787        float64_t a = arg / (1.0 + arg * arg);
    88        
     88
    8989        /*
    9090         * atan(z) = sum(n=0, +inf) [ (2^2n) * (n!)^2 / (2n + 1)! *
    9191         *    z^(2n+1) / (1 + z^2)^(n+1) ]
    9292         */
    93        
     93
    9494        for (unsigned int n = 0; n < SERIES_DEGREE_64; n++) {
    9595                if (n > 0) {
    … …  
    100100                a = a * 4.0 * arg * arg / (1.0 + arg * arg);
    101101        }
    102        
     102
    103103        return sum;
    104104}

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

    r3061bc1 ra35b458  
    4848        float32_u v;
    4949        float32_u r;
    50        
     50
    5151        v.val = val;
    5252        t.val = trunc_f32(val);
    53        
     53
    5454        if (v.data.parts.sign == 1 || val == t.val) {
    5555                r = t;
    … …  
    5757                r.val = t.val + 1.0;
    5858        }
    59        
     59
    6060        return r.val;
    6161}
    … …  
    7272        float64_u v;
    7373        float64_u r;
    74        
     74
    7575        v.val = val;
    7676        t.val = trunc_f64(val);
    77        
     77
    7878        if (v.data.parts.sign == 1 || val == t.val) {
    7979                r = t;
    … …  
    8181                r.val = t.val + 1.0;
    8282        }
    83        
     83
    8484        return r.val;
    8585}

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

    r3061bc1 ra35b458  
    6464        float32_t ret = 1;
    6565        float32_t nom = 1;
    66        
     66
    6767        for (unsigned int i = 0; i < TAYLOR_DEGREE_32; i++) {
    6868                nom *= arg;
    6969                ret += nom / factorials[i];
    7070        }
    71        
     71
    7272        return ret;
    7373}
    … …  
    8989        float64_t ret = 1;
    9090        float64_t nom = 1;
    91        
     91
    9292        for (unsigned int i = 0; i < TAYLOR_DEGREE_64; i++) {
    9393                nom *= arg;
    9494                ret += nom / factorials[i];
    9595        }
    96        
     96
    9797        return ret;
    9898}

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

    r3061bc1 ra35b458  
    4848        float32_t t;
    4949        float32_u v;
    50        
     50
    5151        v.val = val;
    5252        t = trunc_f32(val);
    53        
     53
    5454        if (v.data.parts.sign == 0 || val == t)
    5555                return t;
    … …  
    6969        float64_t t;
    7070        float64_u v;
    71        
     71
    7272        v.val = val;
    7373        t = trunc_f64(val);
    74        
     74
    7575        if (v.data.parts.sign == 0 || val == t)
    7676                return t;

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

    r3061bc1 ra35b458  
    5555{
    5656        // FIXME: replace with exact arithmetics
    57        
     57
    5858        float32_t quotient = trunc_f32(dividend / divisor);
    59        
     59
    6060        return (dividend - quotient * divisor);
    6161}
    … …  
    8080{
    8181        // FIXME: replace with exact arithmetics
    82        
     82
    8383        float64_t quotient = trunc_f64(dividend / divisor);
    84        
     84
    8585        return (dividend - quotient * divisor);
    8686}

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

    r3061bc1 ra35b458  
    5555        float32_t ret = 0;
    5656        float32_t num = 1;
    57        
     57
    5858        for (unsigned int i = 1; i <= TAYLOR_DEGREE_32; i++) {
    5959                num *= arg;
    60                
     60
    6161                if ((i % 2) == 0)
    6262                        ret += num / i;
    … …  
    6464                        ret -= num / i;
    6565        }
    66        
     66
    6767        return ret;
    6868}
    … …  
    8383        float64_t ret = 0;
    8484        float64_t num = 1;
    85        
     85
    8686        for (unsigned int i = 1; i <= TAYLOR_DEGREE_64; i++) {
    8787                num *= arg;
    88                
     88
    8989                if ((i % 2) == 0)
    9090                        ret += num / i;
    … …  
    9292                        ret -= num / i;
    9393        }
    94        
     94
    9595        return ret;
    9696}
    … …  
    107107        float32_u m;
    108108        int e;
    109        
     109
    110110        m.val = arg;
    111111        /*
    … …  
    118118        e = m.data.parts.exp - (FLOAT32_BIAS - 1);
    119119        m.data.parts.exp = FLOAT32_BIAS - 1;
    120        
     120
    121121        /*
    122122         * arg = m * 2^e ; log(arg) = log(m) + log(2^e) =
    … …  
    137137        float64_u m;
    138138        int e;
    139        
     139
    140140        m.val = arg;
    141        
     141
    142142        /*
    143143         * Factor arg into m * 2^e where m has exponent -1,
    … …  
    149149        e = m.data.parts.exp - (FLOAT64_BIAS - 1);
    150150        m.data.parts.exp = FLOAT64_BIAS - 1;
    151        
     151
    152152        /*
    153153         * arg = m * 2^e ; log(arg) = log(m) + log(2^e) =

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

    r3061bc1 ra35b458  
    6464        float32_t ret = 0;
    6565        float32_t nom = 1;
    66        
     66
    6767        for (unsigned int i = 0; i < TAYLOR_DEGREE_32; i++) {
    6868                nom *= arg;
    69                
     69
    7070                if ((i % 4) == 0)
    7171                        ret += nom / factorials[i];
    … …  
    7373                        ret -= nom / factorials[i];
    7474        }
    75        
     75
    7676        return ret;
    7777}
    … …  
    9393        float64_t ret = 0;
    9494        float64_t nom = 1;
    95        
     95
    9696        for (unsigned int i = 0; i < TAYLOR_DEGREE_64; i++) {
    9797                nom *= arg;
    98                
     98
    9999                if ((i % 4) == 0)
    100100                        ret += nom / factorials[i];
    … …  
    102102                        ret -= nom / factorials[i];
    103103        }
    104        
     104
    105105        return ret;
    106106}
    … …  
    122122        float32_t ret = 1;
    123123        float32_t nom = 1;
    124        
     124
    125125        for (unsigned int i = 0; i < TAYLOR_DEGREE_32; i++) {
    126126                nom *= arg;
    127                
     127
    128128                if ((i % 4) == 1)
    129129                        ret -= nom / factorials[i];
    … …  
    131131                        ret += nom / factorials[i];
    132132        }
    133        
     133
    134134        return ret;
    135135}
    … …  
    151151        float64_t ret = 1;
    152152        float64_t nom = 1;
    153        
     153
    154154        for (unsigned int i = 0; i < TAYLOR_DEGREE_64; i++) {
    155155                nom *= arg;
    156                
     156
    157157                if ((i % 4) == 1)
    158158                        ret -= nom / factorials[i];
    … …  
    160160                        ret += nom / factorials[i];
    161161        }
    162        
     162
    163163        return ret;
    164164}
    … …  
    179179{
    180180        unsigned int period = arg / (M_PI / 4);
    181        
     181
    182182        switch (period) {
    183183        case 0:
    … …  
    212212{
    213213        unsigned int period = arg / (M_PI / 4);
    214        
     214
    215215        switch (period) {
    216216        case 0:
    … …  
    245245{
    246246        unsigned int period = arg / (M_PI / 4);
    247        
     247
    248248        switch (period) {
    249249        case 0:
    … …  
    278278{
    279279        unsigned int period = arg / (M_PI / 4);
    280        
     280
    281281        switch (period) {
    282282        case 0:
    … …  
    308308{
    309309        float32_t base_arg = fmod_f32(arg, 2 * M_PI);
    310        
     310
    311311        if (base_arg < 0)
    312312                return -base_sin_32(-base_arg);
    313        
     313
    314314        return base_sin_32(base_arg);
    315315}
    … …  
    327327{
    328328        float64_t base_arg = fmod_f64(arg, 2 * M_PI);
    329        
     329
    330330        if (base_arg < 0)
    331331                return -base_sin_64(-base_arg);
    332        
     332
    333333        return base_sin_64(base_arg);
    334334}
    … …  
    346346{
    347347        float32_t base_arg = fmod_f32(arg, 2 * M_PI);
    348        
     348
    349349        if (base_arg < 0)
    350350                return base_cos_32(-base_arg);
    351        
     351
    352352        return base_cos_32(base_arg);
    353353}
    … …  
    365365{
    366366        float64_t base_arg = fmod_f64(arg, 2 * M_PI);
    367        
     367
    368368        if (base_arg < 0)
    369369                return base_cos_64(-base_arg);
    370        
     370
    371371        return base_cos_64(base_arg);
    372372}

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

    r3061bc1 ra35b458  
    5656        float32_u v;
    5757        int32_t exp;
    58        
     58
    5959        v.val = val;
    6060        exp = v.data.parts.exp - FLOAT32_BIAS;
    61        
     61
    6262        if (exp < 0) {
    6363                /* -1 < val < 1 => result is +0 or -0 */
    … …  
    6969                        // FIXME TODO
    7070                }
    71                
     71
    7272                /* All bits in val are relevant for the result */
    7373        } else {
    … …  
    7575                v.data.parts.fraction &= ~(UINT32_C(0x007fffff) >> exp);
    7676        }
    77        
     77
    7878        return v.val;
    7979}
    … …  
    9898        float64_u v;
    9999        int32_t exp;
    100        
     100
    101101        v.val = val;
    102102        exp = v.data.parts.exp - FLOAT64_BIAS;
    103        
     103
    104104        if (exp < 0) {
    105105                /* -1 < val < 1 => result is +0 or -0 */
    … …  
    111111                        // FIXME TODO
    112112                }
    113                
     113
    114114                /* All bits in val are relevant for the result */
    115115        } else {
    … …  
    117117                v.data.parts.fraction &= ~(UINT64_C(0x000fffffffffffff) >> exp);
    118118        }
    119        
     119
    120120        return v.val;
    121121}
Note: See TracChangeset for help on using the changeset viewer.