Ignore:
File:
1 edited

Legend:

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

    r000494d rb6636dc  
    3131#include <sftypes.h>
    3232#include <add.h>
    33 #include <sub.h>
    34 #include <mul.h>
    35 #include <div.h>
    3633#include <bool.h>
    3734#include "../tester.h"
    3835
    39 #define OPERANDS  6
     36#define OPERANDS   5
    4037#define PRECISION  10000
    4138
     
    4340
    4441typedef int32_t cmptype_t;
    45 typedef void (* float_op_t)(float, float, float *, float_t *);
    46 typedef void (* double_op_t)(double, double, double *, double_t *);
    47 typedef void (* template_t)(void *, unsigned, unsigned, cmptype_t *,
    48     cmptype_t *);
    4942
    50 static float fop_a[OPERANDS] =
    51         {3.5, -2.1, 100.0, 50.0, -1024.0, 0.0};
     43static float float_op_a[OPERANDS] =
     44        {3.5, -2.1, 100.0, 50.0, -1024.0};
    5245
    53 static float fop_b[OPERANDS] =
    54         {-2.1, 100.0, 50.0, -1024.0, 3.5, 0.0};
    55 
    56 static double dop_a[OPERANDS] =
    57         {3.5, -2.1, 100.0, 50.0, -1024.0, 0.0};
    58 
    59 static double dop_b[OPERANDS] =
    60         {-2.1, 100.0, 50.0, -1024.0, 3.5, 0.0};
     46static float float_op_b[OPERANDS] =
     47        {-2.1, 100.0, 50.0, -1024.0, 3.5};
    6148
    6249static cmptype_t cmpabs(cmptype_t a)
     
    6855}
    6956
    70 static void
    71 float_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 
    85 static void
    86 double_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 
    100 static bool test_template(template_t template, void *f)
     57static bool test_float_add(void)
    10158{
    10259        bool correct = true;
    10360       
    10461        for (unsigned int i = 0; i < OPERANDS; i++) {
    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);   
     62                for (unsigned int j = 0; j < OPERANDS; j++) {
     63                        float a = float_op_a[i];
     64                        float b = float_op_b[j];
     65                        float c = a + b;
     66                       
     67                        float_t sa;
     68                        float_t sb;
     69                        float_t sc;
     70                       
     71                        sa.val = float_op_a[i];
     72                        sb.val = float_op_b[i];
     73                        sc.data = add_float(sa.data, sb.data);
     74                       
     75                        cmptype_t ic = (cmptype_t) (c * PRECISION);
     76                        cmptype_t isc = (cmptype_t) (sc.val * PRECISION);
    11077                        cmptype_t diff = cmpabs(ic - isc);
    11178                       
    11279                        if (diff != 0) {
    113                                 TPRINTF("i=%u, j=%u diff=%" PRIdCMPTYPE "\n",
    114                                     i, j, diff);
     80                                TPRINTF("i=%u, j=%u diff=%" PRIdCMPTYPE "\n", i, j, diff);
    11581                                correct = false;
    11682                        }
     
    12187}
    12288
    123 static 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 
    143 static 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 
    155 static 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 
    173 static 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 
    193 static 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 
    205 static 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);
    221 }
    222 
    22389const char *test_softfloat1(void)
    22490{
    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         }
     91        if (!test_float_add())
     92                return "Float addition failed";
    25193       
    252         return err;
     94        return NULL;
    25395}
    254 
Note: See TracChangeset for help on using the changeset viewer.