Changeset 3b23d05 in mainline for uspace/app/tester/float/float2.c


Ignore:
Timestamp:
2015-09-17T16:21:28Z (9 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
c7b9c5d6
Parents:
996dc042 (diff), b69786e (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge math library improvements.

File:
1 edited

Legend:

Unmodified
Added
Removed

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

    r996dc042 r3b23d05  
    4242};
    4343
     44static double arguments_acos[OPERANDS] = {
     45        -0.936456687291, -0.504846104600, 0.862318872288, 0.964966028492,
     46        0.987353618220, 1.0, -0.194939922623, 0.978471923925, -0.999023478833,
     47        0.540302305868
     48};
     49
     50static double arguments_asin[OPERANDS] = {
     51        -0.350783227690, -0.863209366649, -0.506365641110, -0.262374853704,
     52        0.158533380044, 0.0, 0.980815184715, -0.206379975025, -0.044182448332,
     53        0.841470984808
     54};
     55
     56static double arguments_atan[OPERANDS] = {
     57        3.5, 100.0, 50.0, 768.3156, 1080.499999, 1.0, 66.0,
     58        2.718281828459045, 9.9, 0.001
     59};
     60
    4461static double arguments_exp[OPERANDS] = {
    4562        3.5, -2.1, 50.0, 0.0, 1.0, 13.2, -1.1, -5.5, 0.1, -66.0
    … …  
    5168};
    5269
     70static double arguments_sqrt[OPERANDS] = {
     71        3.5, 100.0, 50.0, 768.3156, 1080.499999, 1.0, 66.0,
     72        2.718281828459045, 9.9, 0.001
     73};
     74
     75static double arguments_tanh[OPERANDS] = {
     76        3.5, -2.1, 50.0, 0.0, 1.0, 13.2, -1.1, -5.5, 0.000001, -66000000.0
     77};
     78
     79static double results_acos[OPERANDS] = {
     80        2.783185307180, 2.100000000000, 0.530964914873, 0.265482457437,
     81        0.159205070272, 0.000000000000, 1.766992524091, 0.207873834887,
     82        3.097395817941, 1.000000000000
     83};
     84
     85static double results_asin[OPERANDS] = {
     86        -0.358407346411, -1.041592653590, -0.530964914874, -0.265482457437,
     87        0.159205070273, 0.000000000000, 1.374600129498, -0.207873834889,
     88        -0.044196835651, 1.000000000000
     89};
     90
     91static double results_atan[OPERANDS] = {
     92        1.292496667790, 1.560796660108, 1.550798992822, 1.569494779052,
     93        1.569870829603, 0.785398163397, 1.555645970920, 1.218282905017,
     94        1.470127674637, 0.000999999667
     95};
    5396
    5497static double results_ceil[OPERANDS] = {
    … …  
    5699};
    57100
     101static double results_cos[OPERANDS] = {
     102        -0.936456687291, -0.504846104600, 0.862318872288, 0.964966028492,
     103        0.987353618220, 1.0, -0.194939922623, 0.978471923925, -0.999023478833,
     104        0.540302305868
     105};
     106
     107static double results_cosh[OPERANDS] = {
     108        16.572824671057, 4.144313170410, 2592352764293536022528.000000000000,
     109        1.000000000000, 1.543080634815, 270182.468624271103, 1.668518553822,
     110        122.348009517829, 1.005004168056, 23035933171656458903220125696.0
     111};
     112
     113static double results_fabs[OPERANDS] = {
     114        3.5, 2.1, 100.0, 50.0, 1024.0, 0.0, 768.3156, 1080.499999, 600.0, 1.0
     115};
     116
    58117static double results_floor[OPERANDS] = {
    59118        3.0, -3.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
    60119};
    61120
    62 static double results_trunc[OPERANDS] = {
    63         3.0, -2.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
     121static double results_exp[OPERANDS] = {
     122        33.115451958692, 0.122456428253, 5184705528587072045056.0,
     123        1.000000000000, 2.718281828459, 540364.937246691552, 0.332871083698,
     124        0.004086771438, 1.105170918076, 0.000000000000
     125};
     126
     127static double results_log[OPERANDS] = {
     128        1.252762968495, 4.605170185988, 3.912023005428, 6.644200586236,
     129        6.985179175021, 0.000000000000, 4.189654742026, 1.000000000000,
     130        2.292534757141, -6.907755278982
     131};
     132
     133static double results_log10[OPERANDS] = {
     134        0.544068044350, 2.000000000000, 1.698970004336, 2.885539651261,
     135        3.033624770817, 0.000000000000, 1.819543935542, 0.434294481903,
     136        0.995635194598, -3.000000000000
    64137};
    65138
    … …  
    70143};
    71144
    72 static double results_cos[OPERANDS] = {
    73         -0.936456687291, -0.504846104600, 0.862318872288, 0.964966028492,
    74         0.987353618220, 1.0, -0.194939922623, 0.978471923925, -0.999023478833,
    75         0.540302305868
    76 };
    77 
    78 static double results_log[OPERANDS] = {
    79         1.252762968495, 4.605170185988, 3.912023005428, 6.644200586236,
    80         6.985179175021, 0.000000000000, 4.189654742026, 1.000000000000,
    81         2.292534757141, -6.907755278982
    82 };
    83 
    84 static double results_exp[OPERANDS] = {
    85         33.115451958692, 0.122456428253, 5184705528587072045056.0,
    86         1.000000000000, 2.718281828459, 540364.937246691552, 0.332871083698,
    87         0.004086771438, 1.105170918076, 0.000000000000
     145static double results_sinh[OPERANDS] = {
     146        16.542627287635, -4.021856742157, 2592352764293536022528.000000000000,
     147        0.000000000000, 1.175201193644, 270182.468622420449, -1.335647470124,
     148        -122.343922746391, 0.100166750020, -23035933171656458903220125696.0
     149};
     150
     151static double results_sqrt[OPERANDS] = {
     152        1.870828693387, 10.000000000000, 7.071067811865, 27.718506453271,
     153        32.870959812576, 1.000000000000, 8.124038404636, 1.648721270700,
     154        3.146426544510, 0.031622776602
     155};
     156
     157static double results_tan[OPERANDS] = {
     158        0.374585640159, 1.709846542905, -0.587213915157, -0.271900611998,
     159        0.160563932839, 0.000000000000, -5.031371570891, -0.210920691722,
     160        0.044225635601, 1.557407724655
     161};
     162
     163static double results_tanh[OPERANDS] = {
     164        0.998177897611, -0.970451936613, 1.000000000000, 0.000000000000,
     165        0.761594155956, 0.999999999993, -0.800499021761, -0.999966597156,
     166        0.000001000000, -1.000000000000
     167};
     168
     169static double results_trunc[OPERANDS] = {
     170        3.0, -2.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
    88171};
    89172
    … …  
    125208{
    126209        bool fail = false;
     210if (0) {
     211        for (unsigned int i = 0; i < OPERANDS; i++) {
     212                double res = acos(arguments_acos[i]);
     213
     214                if (!cmp_double(res, results_acos[i])) {
     215                        TPRINTF("Double precision acos failed "
     216                            "(%lf != %lf, arg %u)\n", res, results_acos[i], i);
     217                        fail = true;
     218                }
     219        }
     220
     221        for (unsigned int i = 0; i < OPERANDS; i++) {
     222                float res = acosf(arguments_acos[i]);
     223
     224                if (!cmp_float(res, results_acos[i])) {
     225                        TPRINTF("Single precision acos failed "
     226                            "(%f != %lf, arg %u)\n", res, results_acos[i], i);
     227                        fail = true;
     228                }
     229        }
     230
     231        for (unsigned int i = 0; i < OPERANDS; i++) {
     232                double res = asin(arguments_asin[i]);
     233
     234                if (!cmp_double(res, results_asin[i])) {
     235                        TPRINTF("Double precision asin failed "
     236                            "(%lf != %lf, arg %u)\n", res, results_asin[i], i);
     237                        fail = true;
     238                }
     239        }
     240
     241        for (unsigned int i = 0; i < OPERANDS; i++) {
     242                float res = asinf(arguments_asin[i]);
     243
     244                if (!cmp_float(res, results_asin[i])) {
     245                        TPRINTF("Single precision asin failed "
     246                            "(%f != %lf, arg %u)\n", res, results_asin[i], i);
     247                        fail = true;
     248                }
     249        }
     250}
     251        for (unsigned int i = 0; i < OPERANDS; i++) {
     252                double res = atan(arguments_atan[i]);
     253
     254                if (!cmp_double(res, results_atan[i])) {
     255                        TPRINTF("Double precision atan failed "
     256                            "(%.12lf != %.12lf, arg %u)\n", res, results_atan[i], i);
     257                        fail = true;
     258                }
     259        }
     260
     261        for (unsigned int i = 0; i < OPERANDS; i++) {
     262                float res = atanf(arguments_atan[i]);
     263
     264                if (!cmp_float(res, results_atan[i])) {
     265                        TPRINTF("Single precision atan failed "
     266                            "(%f != %lf, arg %u)\n", res, results_atan[i], i);
     267                        fail = true;
     268                }
     269        }
     270
     271        for (unsigned int i = 0; i < OPERANDS; i++) {
     272                double res = ceil(arguments[i]);
     273
     274                if (!cmp_double(res, results_ceil[i])) {
     275                        TPRINTF("Double precision ceil failed "
     276                            "(%lf != %lf, arg %u)\n", res, results_ceil[i], i);
     277                        fail = true;
     278                }
     279        }
     280
     281        for (unsigned int i = 0; i < OPERANDS; i++) {
     282                float res = ceilf(arguments[i]);
     283
     284                if (!cmp_float(res, results_ceil[i])) {
     285                        TPRINTF("Single precision ceil failed "
     286                            "(%f != %lf, arg %u)\n", res, results_ceil[i], i);
     287                        fail = true;
     288                }
     289        }
     290
     291        for (unsigned int i = 0; i < OPERANDS; i++) {
     292                double res = cos(arguments[i]);
     293
     294                if (!cmp_double(res, results_cos[i])) {
     295                        TPRINTF("Double precision cos failed "
     296                            "(%lf != %lf, arg %u)\n", res, results_cos[i], i);
     297                        fail = true;
     298                }
     299        }
     300
     301        for (unsigned int i = 0; i < OPERANDS; i++) {
     302                float res = cosf(arguments[i]);
     303
     304                if (!cmp_float(res, results_cos[i])) {
     305                        TPRINTF("Single precision cos failed "
     306                            "(%f != %lf, arg %u)\n", res, results_cos[i], i);
     307                        fail = true;
     308                }
     309        }
     310
     311        for (unsigned int i = 0; i < OPERANDS; i++) {
     312                double res = cosh(arguments_exp[i]);
     313
     314                if (!cmp_double(res, results_cosh[i])) {
     315                        TPRINTF("Double precision cosh failed "
     316                            "(%lf != %lf, arg %u)\n", res, results_cosh[i], i);
     317                        fail = true;
     318                }
     319        }
     320
     321        for (unsigned int i = 0; i < OPERANDS; i++) {
     322                float res = coshf(arguments_exp[i]);
     323
     324                if (!cmp_float(res, results_cosh[i])) {
     325                        TPRINTF("Single precision cosh failed "
     326                            "(%f != %lf, arg %u)\n", res, results_cosh[i], i);
     327                        fail = true;
     328                }
     329        }
     330
     331        for (unsigned int i = 0; i < OPERANDS; i++) {
     332                double res = exp(arguments_exp[i]);
     333
     334                if (!cmp_double(res, results_exp[i])) {
     335                        TPRINTF("Double precision exp failed "
     336                            "(%lf != %lf, arg %u)\n", res, results_exp[i], i);
     337                        fail = true;
     338                }
     339        }
     340
     341        for (unsigned int i = 0; i < OPERANDS; i++) {
     342                float res = expf(arguments_exp[i]);
     343
     344                if (!cmp_float(res, results_exp[i])) {
     345                        TPRINTF("Single precision exp failed "
     346                            "(%f != %lf, arg %u)\n", res, results_exp[i], i);
     347                        fail = true;
     348                }
     349        }
     350
     351        for (unsigned int i = 0; i < OPERANDS; i++) {
     352                double res = fabs(arguments[i]);
     353
     354                if (!cmp_double(res, results_fabs[i])) {
     355                        TPRINTF("Double precision fabs failed "
     356                            "(%lf != %lf, arg %u)\n", res, results_fabs[i], i);
     357                        fail = true;
     358                }
     359        }
     360
     361        for (unsigned int i = 0; i < OPERANDS; i++) {
     362                float res = fabsf(arguments[i]);
     363
     364                if (!cmp_float(res, results_fabs[i])) {
     365                        TPRINTF("Single precision fabs failed "
     366                            "(%f != %lf, arg %u)\n", res, results_fabs[i], i);
     367                        fail = true;
     368                }
     369        }
    127370
    128371        for (unsigned int i = 0; i < OPERANDS; i++) {
    129372                double res = floor(arguments[i]);
    130                 int64_t res_int = (int64_t) (res * PRECISION);
    131                 int64_t corr_int = (int64_t) (results_floor[i] * PRECISION);
    132                
    133                 if (res_int != corr_int) {
    134                         TPRINTF("Double precision floor failed (%" PRId64
    135                             " != %" PRId64 ", arg %u)\n", res_int, corr_int, i);
    136                         fail = true;
    137                 }
    138         }
    139 
    140         for (unsigned int i = 0; i < OPERANDS; i++) {
    141                 double res = ceil(arguments[i]);
    142                 int64_t res_int = (int64_t) (res * PRECISION);
    143                 int64_t corr_int = (int64_t) (results_ceil[i] * PRECISION);
    144                
    145                 if (res_int != corr_int) {
    146                         TPRINTF("Double precision ceil failed (%" PRId64
    147                             " != %" PRId64 ", arg %u)\n", res_int, corr_int, i);
     373
     374                if (!cmp_double(res, results_floor[i])) {
     375                        TPRINTF("Double precision floor failed "
     376                            "(%lf != %lf, arg %u)\n", res, results_floor[i], i);
     377                        fail = true;
     378                }
     379        }
     380
     381        for (unsigned int i = 0; i < OPERANDS; i++) {
     382                float res = floorf(arguments[i]);
     383
     384                if (!cmp_float(res, results_floor[i])) {
     385                        TPRINTF("Single precision floor failed "
     386                            "(%f != %lf, arg %u)\n", res, results_floor[i], i);
     387                        fail = true;
     388                }
     389        }
     390
     391        for (unsigned int i = 0; i < OPERANDS; i++) {
     392                double res = log(arguments_log[i]);
     393
     394                if (!cmp_double(res, results_log[i])) {
     395                        TPRINTF("Double precision log failed "
     396                            "(%lf != %lf, arg %u)\n", res, results_log[i], i);
     397                        fail = true;
     398                }
     399        }
     400
     401        for (unsigned int i = 0; i < OPERANDS; i++) {
     402                float res = logf(arguments_log[i]);
     403
     404                if (!cmp_float(res, results_log[i])) {
     405                        TPRINTF("Single precision log failed "
     406                            "(%f != %lf, arg %u)\n", res, results_log[i], i);
     407                        fail = true;
     408                }
     409        }
     410
     411        for (unsigned int i = 0; i < OPERANDS; i++) {
     412                double res = log10(arguments_log[i]);
     413
     414                if (!cmp_double(res, results_log10[i])) {
     415                        TPRINTF("Double precision log10 failed "
     416                            "(%lf != %lf, arg %u)\n", res, results_log10[i], i);
     417                        fail = true;
     418                }
     419        }
     420
     421        for (unsigned int i = 0; i < OPERANDS; i++) {
     422                float res = log10f(arguments_log[i]);
     423
     424                if (!cmp_float(res, results_log10[i])) {
     425                        TPRINTF("Single precision log10 failed "
     426                            "(%f != %lf, arg %u)\n", res, results_log10[i], i);
     427                        fail = true;
     428                }
     429        }
     430
     431        for (unsigned int i = 0; i < OPERANDS; i++) {
     432                double res = sin(arguments[i]);
     433
     434                if (!cmp_double(res, results_sin[i])) {
     435                        TPRINTF("Double precision sin failed "
     436                            "(%lf != %lf, arg %u)\n", res, results_sin[i], i);
     437                        fail = true;
     438                }
     439        }
     440
     441        for (unsigned int i = 0; i < OPERANDS; i++) {
     442                float res = sinf(arguments[i]);
     443
     444                if (!cmp_float(res, results_sin[i])) {
     445                        TPRINTF("Single precision sin failed "
     446                            "(%f != %lf, arg %u)\n", res, results_sin[i], i);
     447                        fail = true;
     448                }
     449        }
     450;
     451        for (unsigned int i = 0; i < OPERANDS; i++) {
     452                double res = sinh(arguments_exp[i]);
     453
     454                if (!cmp_double(res, results_sinh[i])) {
     455                        TPRINTF("Double precision sinh failed "
     456                            "(%lf != %lf, arg %u)\n", res, results_sinh[i], i);
     457                        fail = true;
     458                }
     459        }
     460
     461        for (unsigned int i = 0; i < OPERANDS; i++) {
     462                float res = sinhf(arguments_exp[i]);
     463
     464                if (!cmp_float(res, results_sinh[i])) {
     465                        TPRINTF("Single precision sinh failed "
     466                            "(%f != %lf, arg %u)\n", res, results_sinh[i], i);
     467                        fail = true;
     468                }
     469        }
     470
     471        for (unsigned int i = 0; i < OPERANDS; i++) {
     472                double res = sqrt(arguments_sqrt[i]);
     473
     474                if (!cmp_double(res, results_sqrt[i])) {
     475                        TPRINTF("Double precision sqrt failed "
     476                            "(%lf != %lf, arg %u)\n", res, results_sqrt[i], i);
     477                        fail = true;
     478                }
     479        }
     480
     481        for (unsigned int i = 0; i < OPERANDS; i++) {
     482                float res = sqrtf(arguments_sqrt[i]);
     483
     484                if (!cmp_float(res, results_sqrt[i])) {
     485                        TPRINTF("Single precision sqrt failed "
     486                            "(%f != %lf, arg %u)\n", res, results_sqrt[i], i);
     487                        fail = true;
     488                }
     489        }
     490
     491        for (unsigned int i = 0; i < OPERANDS; i++) {
     492                double res = tan(arguments[i]);
     493
     494                if (!cmp_double(res, results_tan[i])) {
     495                        TPRINTF("Double precision tan failed "
     496                            "(%lf != %lf, arg %u)\n", res, results_tan[i], i);
     497                        fail = true;
     498                }
     499        }
     500
     501        for (unsigned int i = 0; i < OPERANDS; i++) {
     502                float res = tanf(arguments[i]);
     503
     504                if (!cmp_float(res, results_tan[i])) {
     505                        TPRINTF("Single precision tan failed "
     506                            "(%f != %lf, arg %u)\n", res, results_tan[i], i);
     507                        fail = true;
     508                }
     509        }
     510
     511        for (unsigned int i = 0; i < OPERANDS; i++) {
     512                double res = tanh(arguments_tanh[i]);
     513
     514                if (!cmp_double(res, results_tanh[i])) {
     515                        TPRINTF("Double precision tanh failed "
     516                            "(%lf != %lf, arg %u)\n", res, results_tanh[i], i);
     517                        fail = true;
     518                }
     519        }
     520
     521        for (unsigned int i = 0; i < OPERANDS; i++) {
     522                float res = tanhf(arguments_tanh[i]);
     523
     524                if (!cmp_float(res, results_tanh[i])) {
     525                        TPRINTF("Single precision tanh failed "
     526                            "(%f != %lf, arg %u)\n", res, results_tanh[i], i);
    148527                        fail = true;
    149528                }
    … …  
    152531        for (unsigned int i = 0; i < OPERANDS; i++) {
    153532                double res = trunc(arguments[i]);
    154                 int64_t res_int = (int64_t) (res * PRECISION);
    155                 int64_t corr_int = (int64_t) (results_trunc[i] * PRECISION);
    156                
    157                 if (res_int != corr_int) {
    158                         TPRINTF("Double precisiontruncation failed (%" PRId64
    159                             " != %" PRId64 ", arg %u)\n", res_int, corr_int, i);
    160                         fail = true;
    161                 }
    162         }
    163        
    164         for (unsigned int i = 0; i < OPERANDS; i++) {
    165                 double res = sin(arguments[i]);
    166                 int64_t res_int = (int64_t) (res * PRECISION);
    167                 int64_t corr_int = (int64_t) (results_sin[i] * PRECISION);
    168                
    169                 if (res_int != corr_int) {
    170                         TPRINTF("Double precision sine failed (%" PRId64
    171                             " != %" PRId64 ", arg %u)\n", res_int, corr_int, i);
    172                         fail = true;
    173                 }
    174         }
    175        
    176         for (unsigned int i = 0; i < OPERANDS; i++) {
    177                 double res = cos(arguments[i]);
    178                 int64_t res_int = (int64_t) (res * PRECISION);
    179                 int64_t corr_int = (int64_t) (results_cos[i] * PRECISION);
    180                
    181                 if (res_int != corr_int) {
    182                         TPRINTF("Double precision cosine failed (%" PRId64
    183                             " != %" PRId64 ", arg %u)\n", res_int, corr_int, i);
    184                         fail = true;
    185                 }
    186         }
    187        
    188         for (unsigned int i = 0; i < OPERANDS; i++) {
    189                 float res = logf(arguments_log[i]);
    190                
    191                 if (!cmp_float(res, results_log[i])) {
    192                         TPRINTF("Single precision logarithm failed "
    193                             "(%lf != %lf, arg %u)\n", res, results_log[i], i);
    194                         fail = true;
    195                 }
    196         }
    197        
    198         for (unsigned int i = 0; i < OPERANDS; i++) {
    199                 double res = log(arguments_log[i]);
    200                
    201                 if (!cmp_double(res, results_log[i])) {
    202                         TPRINTF("Double precision logarithm failed "
    203                             "(%lf != %lf, arg %u)\n", res, results_log[i], i);
    204                         fail = true;
    205                 }
    206         }
    207        
    208         for (unsigned int i = 0; i < OPERANDS; i++) {
    209                 float res = exp(arguments_exp[i]);
    210                
    211                 if (!cmp_float(res, results_exp[i])) {
    212                         TPRINTF("Single precision exponential failed "
    213                             "(%lf != %lf, arg %u)\n", res, results_exp[i], i);
    214                         fail = true;
    215                 }
    216         }
    217        
    218         for (unsigned int i = 0; i < OPERANDS; i++) {
    219                 double res = exp(arguments_exp[i]);
    220                
    221                 if (!cmp_double(res, results_exp[i])) {
    222                         TPRINTF("Double precision exponential failed "
    223                             "(%lf != %lf, arg %u)\n", res, results_exp[i], i);
    224                         fail = true;
    225                 }
    226         }
    227        
     533
     534                if (!cmp_double(res, results_trunc[i])) {
     535                        TPRINTF("Double precision trunc failed "
     536                            "(%lf != %lf, arg %u)\n", res, results_trunc[i], i);
     537                        fail = true;
     538                }
     539        }
     540
     541        for (unsigned int i = 0; i < OPERANDS; i++) {
     542                float res = truncf(arguments[i]);
     543
     544                if (!cmp_float(res, results_trunc[i])) {
     545                        TPRINTF("Single precision trunc failed "
     546                            "(%f != %lf, arg %u)\n", res, results_trunc[i], i);
     547                        fail = true;
     548                }
     549        }
     550
    228551        if (fail)
    229552                return "Floating point imprecision";
    230        
     553
    231554        return NULL;
    232555}
Note: See TracChangeset for help on using the changeset viewer.