Changeset 000494d in mainline for uspace/app/tester/float/softfloat1.c


Ignore:
Timestamp:
2012-10-07T16:12:37Z (13 years ago)
Author:
Jakub Jermar <jakub@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
87e9392
Parents:
e9d0ed4
Message:

Add double tests to softfloat1.
Avoid code duplication.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • uspace/app/tester/float/softfloat1.c

    re9d0ed4 r000494d  
    4343
    4444typedef int32_t cmptype_t;
    45 
    46 static float float_op_a[OPERANDS] =
     45typedef void (* float_op_t)(float, float, float *, float_t *);
     46typedef void (* double_op_t)(double, double, double *, double_t *);
     47typedef void (* template_t)(void *, unsigned, unsigned, cmptype_t *,
     48    cmptype_t *);
     49
     50static float fop_a[OPERANDS] =
    4751        {3.5, -2.1, 100.0, 50.0, -1024.0, 0.0};
    4852
    49 static float float_op_b[OPERANDS] =
     53static float fop_b[OPERANDS] =
     54        {-2.1, 100.0, 50.0, -1024.0, 3.5, 0.0};
     55
     56static double dop_a[OPERANDS] =
     57        {3.5, -2.1, 100.0, 50.0, -1024.0, 0.0};
     58
     59static double dop_b[OPERANDS] =
    5060        {-2.1, 100.0, 50.0, -1024.0, 3.5, 0.0};
    5161
    … …  
    5868}
    5969
    60 static bool test_float_add(void)
     70static void
     71float_template(void *f, unsigned i, unsigned j, cmptype_t *pic,
     72    cmptype_t *pisc)
     73{
     74        float c;
     75        float_t sc;
     76
     77        float_op_t op = (float_op_t) f;
     78       
     79        op(fop_a[i], fop_b[j], &c, &sc);
     80
     81        *pic = (cmptype_t) (c * PRECISION);
     82        *pisc = (cmptype_t) (sc.val * PRECISION);
     83}
     84
     85static void
     86double_template(void *f, unsigned i, unsigned j, cmptype_t *pic,
     87    cmptype_t *pisc)
     88{
     89        double c;
     90        double_t sc;
     91
     92        double_op_t op = (double_op_t) f;
     93       
     94        op(dop_a[i], dop_b[j], &c, &sc);
     95
     96        *pic = (cmptype_t) (c * PRECISION);
     97        *pisc = (cmptype_t) (sc.val * PRECISION);
     98}
     99
     100static bool test_template(template_t template, void *f)
    61101{
    62102        bool correct = true;
    63103       
    64104        for (unsigned int i = 0; i < OPERANDS; i++) {
    65                 for (unsigned int j = 0; j < OPERANDS; j++) {
    66                         float a = float_op_a[i];
    67                         float b = float_op_b[j];
    68                         float c = a + b;
    69                        
    70                         float_t sa;
    71                         float_t sb;
    72                         float_t sc;
    73                        
    74                         sa.val = float_op_a[i];
    75                         sb.val = float_op_b[j];
    76                         if (sa.data.parts.sign == sb.data.parts.sign)
    77                                 sc.data = add_float(sa.data, sb.data);
    78                         else if (sa.data.parts.sign) {
    79                                 sa.data.parts.sign = 0;
    80                                 sc.data = sub_float(sb.data, sa.data);
    81                         } else {
    82                                 sb.data.parts.sign = 0;
    83                                 sc.data = sub_float(sa.data, sb.data);
    84                         }
    85                                
    86                         cmptype_t ic = (cmptype_t) (c * PRECISION);
    87                         cmptype_t isc = (cmptype_t) (sc.val * PRECISION);
     105                for (unsigned int j = 0; j < OPERANDS; j++) {                   
     106                        cmptype_t ic;
     107                        cmptype_t isc;
     108
     109                        template(f, i, j, &ic, &isc);   
    88110                        cmptype_t diff = cmpabs(ic - isc);
    89111                       
    90112                        if (diff != 0) {
    91                                 TPRINTF("i=%u, j=%u diff=%" PRIdCMPTYPE "\n", i, j, diff);
     113                                TPRINTF("i=%u, j=%u diff=%" PRIdCMPTYPE "\n",
     114                                    i, j, diff);
    92115                                correct = false;
    93116                        }
    … …  
    98121}
    99122
    100 static bool test_float_mul(void)
    101 {
    102         bool correct = true;
    103        
    104         for (unsigned int i = 0; i < OPERANDS; i++) {
    105                 for (unsigned int j = 0; j < OPERANDS; j++) {
    106                         float a = float_op_a[i];
    107                         float b = float_op_b[j];
    108                         float c = a * b;
    109                        
    110                         float_t sa;
    111                         float_t sb;
    112                         float_t sc;
    113                        
    114                         sa.val = float_op_a[i];
    115                         sb.val = float_op_b[j];
    116                         sc.data = mul_float(sa.data, sb.data);
    117                                
    118                         cmptype_t ic = (cmptype_t) (c * PRECISION);
    119                         cmptype_t isc = (cmptype_t) (sc.val * PRECISION);
    120                         cmptype_t diff = cmpabs(ic - isc);
    121                        
    122                         if (diff != 0) {
    123                                 TPRINTF("i=%u, j=%u diff=%" PRIdCMPTYPE "\n", i, j, diff);
    124                                 correct = false;
    125                         }
    126                 }
    127         }
    128        
    129         return correct;
    130 }
    131 
    132 static bool test_float_div(void)
    133 {
    134         bool correct = true;
    135        
    136         for (unsigned int i = 0; i < OPERANDS; i++) {
    137                 for (unsigned int j = 0; j < OPERANDS; j++) {
    138                         float a = float_op_a[i];
    139                         float b = float_op_b[j];
    140 
    141                         if (b == 0.0)
    142                                 continue;
    143 
    144                         float c = a / b;
    145                        
    146                         float_t sa;
    147                         float_t sb;
    148                         float_t sc;
    149                        
    150                         sa.val = float_op_a[i];
    151                         sb.val = float_op_b[j];
    152                         sc.data = div_float(sa.data, sb.data);
    153                                
    154                         cmptype_t ic = (cmptype_t) (c * PRECISION);
    155                         cmptype_t isc = (cmptype_t) (sc.val * PRECISION);
    156                         cmptype_t diff = cmpabs(ic - isc);
    157                        
    158                         if (diff != 0) {
    159                                 TPRINTF("i=%u, j=%u diff=%" PRIdCMPTYPE "\n", i, j, diff);
    160                                 correct = false;
    161                         }
    162                 }
    163         }
    164        
    165         return correct;
     123static void float_add_operator(float a, float b, float *pc, float_t *psc)
     124{
     125        *pc = a + b;
     126       
     127        float_t sa;
     128        float_t sb;
     129       
     130        sa.val = a;
     131        sb.val = b;
     132        if (sa.data.parts.sign == sb.data.parts.sign)
     133                psc->data = add_float(sa.data, sb.data);
     134        else if (sa.data.parts.sign) {
     135                sa.data.parts.sign = 0;
     136                psc->data = sub_float(sb.data, sa.data);
     137        } else {
     138                sb.data.parts.sign = 0;
     139                psc->data = sub_float(sa.data, sb.data);
     140        }
     141}
     142
     143static void float_mul_operator(float a, float b, float *pc, float_t *psc)
     144{
     145        *pc = a * b;
     146       
     147        float_t sa;
     148        float_t sb;
     149       
     150        sa.val = a;
     151        sb.val = b;
     152        psc->data = mul_float(sa.data, sb.data);
     153}
     154
     155static void float_div_operator(float a, float b, float *pc, float_t *psc)
     156{
     157        if ((cmptype_t) b == 0) {
     158                *pc = 0.0;
     159                psc->val = 0.0;
     160                return;
     161        }
     162
     163        *pc = a / b;
     164       
     165        float_t sa;
     166        float_t sb;
     167       
     168        sa.val = a;
     169        sb.val = b;
     170        psc->data = div_float(sa.data, sb.data);
     171}
     172
     173static void double_add_operator(double a, double b, double *pc, double_t *psc)
     174{
     175        *pc = a + b;
     176       
     177        double_t sa;
     178        double_t sb;
     179       
     180        sa.val = a;
     181        sb.val = b;
     182        if (sa.data.parts.sign == sb.data.parts.sign)
     183                psc->data = add_double(sa.data, sb.data);
     184        else if (sa.data.parts.sign) {
     185                sa.data.parts.sign = 0;
     186                psc->data = sub_double(sb.data, sa.data);
     187        } else {
     188                sb.data.parts.sign = 0;
     189                psc->data = sub_double(sa.data, sb.data);
     190        }
     191}
     192
     193static void double_mul_operator(double a, double b, double *pc, double_t *psc)
     194{
     195        *pc = a * b;
     196       
     197        double_t sa;
     198        double_t sb;
     199       
     200        sa.val = a;
     201        sb.val = b;
     202        psc->data = mul_double(sa.data, sb.data);
     203}
     204
     205static void double_div_operator(double a, double b, double *pc, double_t *psc)
     206{
     207        if ((cmptype_t) b == 0) {
     208                *pc = 0.0;
     209                psc->val = 0.0;
     210                return;
     211        }
     212
     213        *pc = a / b;
     214       
     215        double_t sa;
     216        double_t sb;
     217       
     218        sa.val = a;
     219        sb.val = b;
     220        psc->data = div_double(sa.data, sb.data);
    166221}
    167222
    168223const char *test_softfloat1(void)
    169224{
    170         if (!test_float_add())
    171                 return "Float addition failed";
    172         if (!test_float_mul())
    173                 return "Float multiplication failed";
    174         if (!test_float_div())
    175                 return "Float division failed";
    176        
    177         return NULL;
    178 }
     225        const char *err = NULL;
     226
     227        if (!test_template(float_template, float_add_operator)) {
     228                err = "Float addition failed";
     229                TPRINTF("%s\n", err);
     230        }
     231        if (!test_template(float_template, float_mul_operator)) {
     232                err = "Float multiplication failed";
     233                TPRINTF("%s\n", err);
     234        }
     235        if (!test_template(float_template, float_div_operator)) {
     236                err = "Float division failed";
     237                TPRINTF("%s\n", err);
     238        }
     239        if (!test_template(double_template, double_add_operator)) {
     240                err = "Double addition failed";
     241                TPRINTF("%s\n", err);
     242        }
     243        if (!test_template(double_template, double_mul_operator)) {
     244                err = "Double multiplication failed";
     245                TPRINTF("%s\n", err);
     246        }
     247        if (!test_template(double_template, double_div_operator)) {
     248                err = "Double division failed";
     249                TPRINTF("%s\n", err);
     250        }
     251       
     252        return err;
     253}
     254
Note: See TracChangeset for help on using the changeset viewer.