Ignore:
File:
1 edited

Legend:

Unmodified
Added
Removed
  • uspace/app/tester/float/softfloat1.c

    r3e6a98c5 r7218fe6  
    3939#include "../tester.h"
    4040
    41 #define OPERANDS  10
     41#define OPERANDS   10
    4242#define PRECISION  10000
    4343
     
    5656    cmptype_t *);
    5757
    58 #define NUMBERS \
     58#define NUMBERS \
    5959        3.5, -2.1, 100.0, 50.0, -1024.0, 0.0, 768.3156, 1080.499999, -600.0, 1.0
    6060
     
    6363};
    6464
    65 static double dop_a[OPERANDS] = {
     65static double dop_a[OPERANDS] = {
    6666        NUMBERS
    6767};
     
    8383        if (a < b)
    8484                return -1;
    85         else if (a > b)
     85       
     86        if (a > b)
    8687                return 1;
    87 
     88       
    8889        return 0;
    8990}
    9091
    91 static void
    92 uint_to_double_template(void *f, unsigned i, cmptype_t *pic, cmptype_t *pisc)
    93 {
     92static void uint_to_double_template(void *f, unsigned i, cmptype_t *pic,
     93    cmptype_t *pisc)
     94{
     95        uint_to_double_op_t op = (uint_to_double_op_t) f;
     96       
    9497        double c;
    9598        double_t sc;
    96 
    97         uint_to_double_op_t op = (uint_to_double_op_t) f;
    98        
    9999        op(uop_a[i], &c, &sc);
    100 
     100       
    101101        *pic = (cmptype_t) (c * PRECISION);
    102102        *pisc = (cmptype_t) (sc.val * PRECISION);
    103103}
    104104
    105 static void
    106 double_to_uint_template(void *f, unsigned i, cmptype_t *pic, cmptype_t *pisc)
    107 {
     105static void double_to_uint_template(void *f, unsigned i, cmptype_t *pic,
     106    cmptype_t *pisc)
     107{
     108        double_to_uint_op_t op = (double_to_uint_op_t) f;
     109       
    108110        unsigned int c;
    109111        unsigned int sc;
    110 
    111         double_to_uint_op_t op = (double_to_uint_op_t) f;
    112        
    113112        op(dop_a[i], &c, &sc);
    114 
     113       
    115114        *pic = (cmptype_t) c;
    116115        *pisc = (cmptype_t) sc;
     
    118117
    119118
    120 static void
    121 float_template_binary(void *f, unsigned i, unsigned j, cmptype_t *pic,
    122     cmptype_t *pisc)
    123 {
     119static void float_template_binary(void *f, unsigned i, unsigned j,
     120    cmptype_t *pic, cmptype_t *pisc)
     121{
     122        float_binary_op_t op = (float_binary_op_t) f;
     123       
    124124        float c;
    125125        float_t sc;
    126 
    127         float_binary_op_t op = (float_binary_op_t) f;
    128        
    129126        op(fop_a[i], fop_a[j], &c, &sc);
    130 
     127       
    131128        *pic = (cmptype_t) (c * PRECISION);
    132129        *pisc = (cmptype_t) (sc.val * PRECISION);
    133130}
    134131
    135 static void
    136 double_template_binary(void *f, unsigned i, unsigned j, cmptype_t *pic,
    137     cmptype_t *pisc)
    138 {
     132static void double_template_binary(void *f, unsigned i, unsigned j,
     133    cmptype_t *pic, cmptype_t *pisc)
     134{
     135        double_binary_op_t op = (double_binary_op_t) f;
     136       
    139137        double c;
    140138        double_t sc;
    141 
    142         double_binary_op_t op = (double_binary_op_t) f;
    143        
    144139        op(dop_a[i], dop_a[j], &c, &sc);
    145 
     140       
    146141        *pic = (cmptype_t) (c * PRECISION);
    147142        *pisc = (cmptype_t) (sc.val * PRECISION);
    148143}
    149144
    150 static void
    151 double_compare_template(void *f, unsigned i, unsigned j, cmptype_t *pis,
    152     cmptype_t *piss)
     145static void double_compare_template(void *f, unsigned i, unsigned j,
     146    cmptype_t *pis, cmptype_t *piss)
    153147{
    154148        double_cmp_op_t op = (double_cmp_op_t) f;
     
    164158                cmptype_t ic;
    165159                cmptype_t isc;
    166 
    167                 template(f, i, &ic, &isc);     
     160               
     161                template(f, i, &ic, &isc);
    168162                cmptype_t diff = cmpabs(ic - isc);
    169                        
     163               
    170164                if (diff != 0) {
    171165                        TPRINTF("i=%u diff=%" PRIdCMPTYPE "\n", i, diff);
     
    182176       
    183177        for (unsigned int i = 0; i < OPERANDS; i++) {
    184                 for (unsigned int j = 0; j < OPERANDS; j++) {                   
     178                for (unsigned int j = 0; j < OPERANDS; j++) {
    185179                        cmptype_t ic;
    186180                        cmptype_t isc;
    187 
    188                         template(f, i, j, &ic, &isc);   
     181                       
     182                        template(f, i, j, &ic, &isc);
    189183                        cmptype_t diff = cmpabs(ic - isc);
    190184                       
     
    206200}
    207201
    208 static void
    209 double_to_uint_operator(double a, unsigned int *pc, unsigned int *psc)
    210 {
    211         double_t sa;
    212 
    213         sa.val = a;
    214 
     202static void double_to_uint_operator(double a, unsigned int *pc,
     203    unsigned int *psc)
     204{
     205        double_t sa;
     206       
     207        sa.val = a;
     208       
    215209        *pc = (unsigned int) a;
    216210        *psc = double_to_uint(sa.data);
    217211}
    218212
    219 static void
    220 double_to_int_operator(double a, unsigned int *pc, unsigned int *psc)
    221 {
    222         double_t sa;
    223 
    224         sa.val = a;
    225 
     213static void double_to_int_operator(double a, unsigned int *pc,
     214    unsigned int *psc)
     215{
     216        double_t sa;
     217       
     218        sa.val = a;
     219       
    226220        *pc = (int) a;
    227221        *psc = double_to_int(sa.data);
     
    237231        sa.val = a;
    238232        sb.val = b;
    239         if (sa.data.parts.sign == sb.data.parts.sign)
     233       
     234        if (sa.data.parts.sign == sb.data.parts.sign) {
    240235                psc->data = add_float(sa.data, sb.data);
    241         else if (sa.data.parts.sign) {
     236        } else if (sa.data.parts.sign) {
    242237                sa.data.parts.sign = 0;
    243238                psc->data = sub_float(sb.data, sa.data);
     
    267262                return;
    268263        }
    269 
     264       
    270265        *pc = a / b;
    271266       
     
    287282        sa.val = a;
    288283        sb.val = b;
    289         if (sa.data.parts.sign == sb.data.parts.sign)
     284       
     285        if (sa.data.parts.sign == sb.data.parts.sign) {
    290286                psc->data = add_double(sa.data, sb.data);
    291         else if (sa.data.parts.sign) {
     287        } else if (sa.data.parts.sign) {
    292288                sa.data.parts.sign = 0;
    293289                psc->data = sub_double(sb.data, sa.data);
     
    317313                return;
    318314        }
    319 
     315       
    320316        *pc = a / b;
    321317       
     
    328324}
    329325
    330 static void
    331 double_cmp_operator(double a, double b, cmptype_t *pis, cmptype_t *piss)
     326static void double_cmp_operator(double a, double b, cmptype_t *pis,
     327    cmptype_t *piss)
    332328{
    333329        *pis = dcmp(a, b);
    334 
     330       
    335331        double_t sa;
    336332        double_t sb;
    337 
    338         sa.val = a;
    339         sb.val = b;
    340 
     333       
     334        sa.val = a;
     335        sb.val = b;
     336       
    341337        if (is_double_lt(sa.data, sb.data))
    342338                *piss = -1;
     
    352348{
    353349        const char *err = NULL;
    354 
     350       
    355351        if (!test_template_binary(float_template_binary, float_add_operator)) {
    356352                err = "Float addition failed";
    357353                TPRINTF("%s\n", err);
    358354        }
     355       
    359356        if (!test_template_binary(float_template_binary, float_mul_operator)) {
    360357                err = "Float multiplication failed";
    361358                TPRINTF("%s\n", err);
    362359        }
     360       
    363361        if (!test_template_binary(float_template_binary, float_div_operator)) {
    364362                err = "Float division failed";
    365363                TPRINTF("%s\n", err);
    366364        }
     365       
    367366        if (!test_template_binary(double_template_binary, double_add_operator)) {
    368367                err = "Double addition failed";
    369368                TPRINTF("%s\n", err);
    370369        }
     370       
    371371        if (!test_template_binary(double_template_binary, double_mul_operator)) {
    372372                err = "Double multiplication failed";
    373373                TPRINTF("%s\n", err);
    374374        }
     375       
    375376        if (!test_template_binary(double_template_binary, double_div_operator)) {
    376377                err = "Double division failed";
    377378                TPRINTF("%s\n", err);
    378379        }
     380       
    379381        if (!test_template_binary(double_compare_template, double_cmp_operator)) {
    380382                err = "Double comparison failed";
    381383                TPRINTF("%s\n", err);
    382384        }
     385       
    383386        if (!test_template_unary(uint_to_double_template,
    384387            uint_to_double_operator)) {
     
    386389                TPRINTF("%s\n", err);
    387390        }
     391       
    388392        if (!test_template_unary(double_to_uint_template,
    389393            double_to_uint_operator)) {
     
    391395                TPRINTF("%s\n", err);
    392396        }
     397       
    393398        if (!test_template_unary(double_to_uint_template,
    394399            double_to_int_operator)) {
     
    399404        return err;
    400405}
    401 
Note: See TracChangeset for help on using the changeset viewer.