Changeset 3b23d05 in mainline


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.

Location:
uspace
Files:
28 added
17 edited
2 moved

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}

  • uspace/app/tester/tester.h

    r996dc042 r3b23d05  
    6060        do { \
    6161                if (!test_quiet) { \
    62                         fprintf(stderr, (format), ##__VA_ARGS__); \
     62                        fprintf(stdout, (format), ##__VA_ARGS__); \
    6363                } \
    6464        } while (0)

  • uspace/lib/c/include/errno.h

    r996dc042 r3b23d05  
    5050#define ENOTEMPTY     (-261)
    5151#define EBADF         (-262)
    52 #define ERANGE        (-263)
    53 #define EXDEV         (-264)
    54 #define EIO           (-265)
    55 #define EMLINK        (-266)
    56 #define ENXIO         (-267)
     52#define EDOM          (-263)
     53#define ERANGE        (-264)
     54#define EXDEV         (-265)
     55#define EIO           (-266)
     56#define EMLINK        (-267)
     57#define ENXIO         (-268)
    5758
    5859/** Bad checksum. */

  • uspace/lib/math/Makefile

    r996dc042 r3b23d05  
    4141
    4242GENERIC_SOURCES = \
     43        generic/acos.c \
     44        generic/asin.c \
     45        generic/atan.c \
     46        generic/atan2.c \
    4347        generic/ceil.c \
     48        generic/cosh.c \
    4449        generic/exp.c \
     50        generic/fabs.c \
    4551        generic/floor.c \
     52        generic/fmod.c \
     53        generic/frexp.c \
     54        generic/ldexp.c \
    4655        generic/log.c \
     56        generic/log10.c \
     57        generic/modf.c \
     58        generic/pow.c \
     59        generic/sinh.c \
     60        generic/sqrt.c \
     61        generic/tan.c \
     62        generic/tanh.c \
    4763        generic/trig.c \
    48         generic/pow.c \
    49         generic/mod.c \
    5064        generic/trunc.c
    5165

  • uspace/lib/math/arch/abs32le/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_abs32le_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    67123}
    68124
     125static inline float64_t cosh_f64(float64_t val)
     126{
     127        return float64_cosh(val);
     128}
     129
     130static inline float32_t cosh_f32(float32_t val)
     131{
     132        return float32_cosh(val);
     133}
     134
    69135static inline float64_t exp_f64(float64_t val)
    70136{
    … …  
    77143}
    78144
     145static inline float64_t fabs_f64(float64_t val)
     146{
     147        return float64_fabs(val);
     148}
     149
     150static inline float32_t fabs_f32(float32_t val)
     151{
     152        return float32_fabs(val);
     153}
     154
    79155static inline float64_t floor_f64(float64_t val)
    80156{
    … …  
    86162        return float32_floor(val);
    87163}
    88 
    89164static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    90165{
    91         return float64_mod(dividend, divisor);
     166        return float64_fmod(dividend, divisor);
    92167}
    93168
    94169static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    95170{
    96         return float32_mod(dividend, divisor);
     171        return float32_fmod(dividend, divisor);
     172}
     173
     174static inline float64_t frexp_f64(float64_t x, int *exp)
     175{
     176        return float64_frexp(x, exp);
     177}
     178
     179static inline float64_t frexp_f32(float32_t x, int *exp)
     180{
     181        return float32_frexp(x, exp);
     182}
     183
     184static inline float64_t ldexp_f64(float64_t x, int exp)
     185{
     186        return float64_ldexp(x, exp);
     187}
     188
     189static inline float64_t ldexp_f32(float32_t x, int exp)
     190{
     191        return float32_ldexp(x, exp);
    97192}
    98193
    … …  
    107202}
    108203
     204static inline float64_t log10_f64(float64_t val)
     205{
     206        return float64_log10(val);
     207}
     208
     209static inline float32_t log10_f32(float32_t val)
     210{
     211        return float32_log10(val);
     212}
     213
     214static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     215{
     216        return float64_modf(value, iptr);
     217}
     218
     219static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     220{
     221        return float32_modf(value, iptr);
     222}
     223
    109224static inline float64_t pow_f64(float64_t x, float64_t y)
    110225{
    … …  
    127242}
    128243
     244static inline float64_t sinh_f64(float64_t val)
     245{
     246        return float64_sinh(val);
     247}
     248
     249static inline float32_t sinh_f32(float32_t val)
     250{
     251        return float32_sinh(val);
     252}
     253
     254static inline float64_t sqrt_f64(float64_t val)
     255{
     256        return float64_sqrt(val);
     257}
     258
     259static inline float32_t sqrt_f32(float32_t val)
     260{
     261        return float32_sqrt(val);
     262}
     263
     264static inline float64_t tan_f64(float64_t val)
     265{
     266        return float64_tan(val);
     267}
     268
     269static inline float32_t tan_f32(float32_t val)
     270{
     271        return float32_tan(val);
     272}
     273
     274static inline float64_t tanh_f64(float64_t val)
     275{
     276        return float64_tanh(val);
     277}
     278
     279static inline float32_t tanh_f32(float32_t val)
     280{
     281        return float32_tanh(val);
     282}
     283
    129284static inline float64_t trunc_f64(float64_t val)
    130285{
    … …  
    137292}
    138293
     294static inline float64_t acos(float64_t val)
     295{
     296        return acos_f64(val);
     297}
     298
     299static inline float32_t acosf(float32_t val)
     300{
     301        return acos_f32(val);
     302}
     303
     304static inline float64_t asin(float64_t val)
     305{
     306        return asin_f64(val);
     307}
     308
     309static inline float32_t asinf(float32_t val)
     310{
     311        return asin_f32(val);
     312}
     313
     314static inline float64_t atan(float64_t val)
     315{
     316        return atan_f64(val);
     317}
     318
     319static inline float32_t atanf(float32_t val)
     320{
     321        return atan_f32(val);
     322}
     323
     324static inline float64_t atan2(float64_t y, float64_t x)
     325{
     326        return atan2_f64(y, x);
     327}
     328
     329static inline float32_t atan2f(float32_t y, float32_t x)
     330{
     331        return atan2_f32(y, x);
     332}
     333
    139334static inline float64_t ceil(float64_t val)
    140335{
    … …  
    157352}
    158353
     354static inline float64_t cosh(float64_t val)
     355{
     356        return cosh_f64(val);
     357}
     358
     359static inline float32_t coshf(float32_t val)
     360{
     361        return cosh_f32(val);
     362}
     363
    159364static inline float64_t exp(float64_t val)
    160365{
    … …  
    167372}
    168373
     374static inline float64_t fabs(float64_t val)
     375{
     376        return fabs_f64(val);
     377}
     378
     379static inline float32_t fabsf(float32_t val)
     380{
     381        return fabs_f32(val);
     382}
     383
    169384static inline float64_t floor(float64_t val)
    170385{
    … …  
    187402}
    188403
     404static inline float64_t frexp(float64_t x, int *exp)
     405{
     406        return frexp_f64(x, exp);
     407}
     408
     409static inline float32_t frexpf(float32_t x, int *exp)
     410{
     411        return frexp_f32(x, exp);
     412}
     413
     414static inline float64_t ldexp(float64_t x, int exp)
     415{
     416        return ldexp_f64(x, exp);
     417}
     418
     419static inline float32_t ldexpf(float32_t x, int exp)
     420{
     421        return ldexp_f32(x, exp);
     422}
     423
    189424static inline float64_t log(float64_t val)
    190425{
    … …  
    197432}
    198433
     434static inline float64_t log10(float64_t val)
     435{
     436        return log10_f64(val);
     437}
     438
     439static inline float32_t log10f(float32_t val)
     440{
     441        return log10_f32(val);
     442}
     443
     444static inline float64_t modf(float64_t value, float64_t *iptr)
     445{
     446        return modf_f64(value, iptr);
     447}
     448
     449static inline float32_t modff(float32_t value, float32_t *iptr)
     450{
     451        return modf_f32(value, iptr);
     452}
     453
    199454static inline float64_t pow(float64_t x, float64_t y)
    200455{
    … …  
    215470{
    216471        return sin_f32(val);
     472}
     473
     474static inline float64_t sinh(float64_t val)
     475{
     476        return sinh_f64(val);
     477}
     478
     479static inline float32_t sinhf(float32_t val)
     480{
     481        return sinh_f32(val);
     482}
     483
     484static inline float64_t sqrt(float64_t val)
     485{
     486        return sqrt_f64(val);
     487}
     488
     489static inline float32_t sqrtf(float32_t val)
     490{
     491        return sqrt_f32(val);
     492}
     493
     494static inline float64_t tan(float64_t val)
     495{
     496        return tan_f64(val);
     497}
     498
     499static inline float32_t tanf(float32_t val)
     500{
     501        return tan_f32(val);
     502}
     503
     504static inline float64_t tanh(float64_t val)
     505{
     506        return tanh_f64(val);
     507}
     508
     509static inline float32_t tanhf(float32_t val)
     510{
     511        return tanh_f32(val);
    217512}
    218513

  • uspace/lib/math/arch/amd64/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_amd64_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    64120}
    65121
     122static inline float64_t cosh_f64(float64_t val)
     123{
     124        return float64_cosh(val);
     125}
     126
     127static inline float32_t cosh_f32(float32_t val)
     128{
     129        return float32_cosh(val);
     130}
     131
    66132static inline float64_t exp_f64(float64_t val)
    67133{
    … …  
    74140}
    75141
     142static inline float64_t fabs_f64(float64_t val)
     143{
     144        return float64_fabs(val);
     145}
     146
     147static inline float32_t fabs_f32(float32_t val)
     148{
     149        return float32_fabs(val);
     150}
     151
    76152static inline float64_t floor_f64(float64_t val)
    77153{
    … …  
    83159        return float32_floor(val);
    84160}
    85 
    86161static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    87162{
    88         return float64_mod(dividend, divisor);
     163        return float64_fmod(dividend, divisor);
    89164}
    90165
    91166static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    92167{
    93         return float32_mod(dividend, divisor);
     168        return float32_fmod(dividend, divisor);
     169}
     170
     171static inline float64_t frexp_f64(float64_t x, int *exp)
     172{
     173        return float64_frexp(x, exp);
     174}
     175
     176static inline float64_t frexp_f32(float32_t x, int *exp)
     177{
     178        return float32_frexp(x, exp);
     179}
     180
     181static inline float64_t ldexp_f64(float64_t x, int exp)
     182{
     183        return float64_ldexp(x, exp);
     184}
     185
     186static inline float64_t ldexp_f32(float32_t x, int exp)
     187{
     188        return float32_ldexp(x, exp);
    94189}
    95190
    … …  
    104199}
    105200
     201static inline float64_t log10_f64(float64_t val)
     202{
     203        return float64_log10(val);
     204}
     205
     206static inline float32_t log10_f32(float32_t val)
     207{
     208        return float32_log10(val);
     209}
     210
     211static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     212{
     213        return float64_modf(value, iptr);
     214}
     215
     216static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     217{
     218        return float32_modf(value, iptr);
     219}
     220
    106221static inline float64_t pow_f64(float64_t x, float64_t y)
    107222{
    … …  
    121236}
    122237
     238static inline float64_t sinh_f64(float64_t val)
     239{
     240        return float64_sinh(val);
     241}
     242
     243static inline float32_t sinh_f32(float32_t val)
     244{
     245        return float32_sinh(val);
     246}
     247
     248static inline float64_t sqrt_f64(float64_t val)
     249{
     250        return float64_sqrt(val);
     251}
     252
     253static inline float32_t sqrt_f32(float32_t val)
     254{
     255        return float32_sqrt(val);
     256}
     257
     258static inline float64_t tan_f64(float64_t val)
     259{
     260        return float64_tan(val);
     261}
     262
     263static inline float32_t tan_f32(float32_t val)
     264{
     265        return float32_tan(val);
     266}
     267
     268static inline float64_t tanh_f64(float64_t val)
     269{
     270        return float64_tanh(val);
     271}
     272
     273static inline float32_t tanh_f32(float32_t val)
     274{
     275        return float32_tanh(val);
     276}
     277
    123278extern float64_t trunc_f64(float64_t);
    124279
    … …  
    128283}
    129284
     285static inline float64_t acos(float64_t val)
     286{
     287        return acos_f64(val);
     288}
     289
     290static inline float32_t acosf(float32_t val)
     291{
     292        return acos_f32(val);
     293}
     294
     295static inline float64_t asin(float64_t val)
     296{
     297        return asin_f64(val);
     298}
     299
     300static inline float32_t asinf(float32_t val)
     301{
     302        return asin_f32(val);
     303}
     304
     305static inline float64_t atan(float64_t val)
     306{
     307        return atan_f64(val);
     308}
     309
     310static inline float32_t atanf(float32_t val)
     311{
     312        return atan_f32(val);
     313}
     314
     315static inline float64_t atan2(float64_t y, float64_t x)
     316{
     317        return atan2_f64(y, x);
     318}
     319
     320static inline float32_t atan2f(float32_t y, float32_t x)
     321{
     322        return atan2_f32(y, x);
     323}
     324
    130325static inline float64_t ceil(float64_t val)
    131326{
    … …  
    148343}
    149344
     345static inline float64_t cosh(float64_t val)
     346{
     347        return cosh_f64(val);
     348}
     349
     350static inline float32_t coshf(float32_t val)
     351{
     352        return cosh_f32(val);
     353}
     354
    150355static inline float64_t exp(float64_t val)
    151356{
    … …  
    158363}
    159364
     365static inline float64_t fabs(float64_t val)
     366{
     367        return fabs_f64(val);
     368}
     369
     370static inline float32_t fabsf(float32_t val)
     371{
     372        return fabs_f32(val);
     373}
     374
    160375static inline float64_t floor(float64_t val)
    161376{
    … …  
    178393}
    179394
     395static inline float64_t frexp(float64_t x, int *exp)
     396{
     397        return frexp_f64(x, exp);
     398}
     399
     400static inline float32_t frexpf(float32_t x, int *exp)
     401{
     402        return frexp_f32(x, exp);
     403}
     404
     405static inline float64_t ldexp(float64_t x, int exp)
     406{
     407        return ldexp_f64(x, exp);
     408}
     409
     410static inline float32_t ldexpf(float32_t x, int exp)
     411{
     412        return ldexp_f32(x, exp);
     413}
     414
    180415static inline float64_t log(float64_t val)
    181416{
    … …  
    188423}
    189424
     425static inline float64_t log10(float64_t val)
     426{
     427        return log10_f64(val);
     428}
     429
     430static inline float32_t log10f(float32_t val)
     431{
     432        return log10_f32(val);
     433}
     434
     435static inline float64_t modf(float64_t value, float64_t *iptr)
     436{
     437        return modf_f64(value, iptr);
     438}
     439
     440static inline float32_t modff(float32_t value, float32_t *iptr)
     441{
     442        return modf_f32(value, iptr);
     443}
     444
    190445static inline float64_t pow(float64_t x, float64_t y)
    191446{
    … …  
    206461{
    207462        return sin_f32(val);
     463}
     464
     465static inline float64_t sinh(float64_t val)
     466{
     467        return sinh_f64(val);
     468}
     469
     470static inline float32_t sinhf(float32_t val)
     471{
     472        return sinh_f32(val);
     473}
     474
     475static inline float64_t sqrt(float64_t val)
     476{
     477        return sqrt_f64(val);
     478}
     479
     480static inline float32_t sqrtf(float32_t val)
     481{
     482        return sqrt_f32(val);
     483}
     484
     485static inline float64_t tan(float64_t val)
     486{
     487        return tan_f64(val);
     488}
     489
     490static inline float32_t tanf(float32_t val)
     491{
     492        return tan_f32(val);
     493}
     494
     495static inline float64_t tanh(float64_t val)
     496{
     497        return tanh_f64(val);
     498}
     499
     500static inline float32_t tanhf(float32_t val)
     501{
     502        return tanh_f32(val);
    208503}
    209504

  • uspace/lib/math/arch/arm32/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_arm32_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    67123}
    68124
     125static inline float64_t cosh_f64(float64_t val)
     126{
     127        return float64_cosh(val);
     128}
     129
     130static inline float32_t cosh_f32(float32_t val)
     131{
     132        return float32_cosh(val);
     133}
     134
    69135static inline float64_t exp_f64(float64_t val)
    70136{
    … …  
    77143}
    78144
     145static inline float64_t fabs_f64(float64_t val)
     146{
     147        return float64_fabs(val);
     148}
     149
     150static inline float32_t fabs_f32(float32_t val)
     151{
     152        return float32_fabs(val);
     153}
     154
    79155static inline float64_t floor_f64(float64_t val)
    80156{
    … …  
    86162        return float32_floor(val);
    87163}
    88 
    89164static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    90165{
    91         return float64_mod(dividend, divisor);
     166        return float64_fmod(dividend, divisor);
    92167}
    93168
    94169static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    95170{
    96         return float32_mod(dividend, divisor);
     171        return float32_fmod(dividend, divisor);
     172}
     173
     174static inline float64_t frexp_f64(float64_t x, int *exp)
     175{
     176        return float64_frexp(x, exp);
     177}
     178
     179static inline float64_t frexp_f32(float32_t x, int *exp)
     180{
     181        return float32_frexp(x, exp);
     182}
     183
     184static inline float64_t ldexp_f64(float64_t x, int exp)
     185{
     186        return float64_ldexp(x, exp);
     187}
     188
     189static inline float64_t ldexp_f32(float32_t x, int exp)
     190{
     191        return float32_ldexp(x, exp);
    97192}
    98193
    … …  
    107202}
    108203
     204static inline float64_t log10_f64(float64_t val)
     205{
     206        return float64_log10(val);
     207}
     208
     209static inline float32_t log10_f32(float32_t val)
     210{
     211        return float32_log10(val);
     212}
     213
     214static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     215{
     216        return float64_modf(value, iptr);
     217}
     218
     219static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     220{
     221        return float32_modf(value, iptr);
     222}
     223
    109224static inline float64_t pow_f64(float64_t x, float64_t y)
    110225{
    … …  
    127242}
    128243
     244static inline float64_t sinh_f64(float64_t val)
     245{
     246        return float64_sinh(val);
     247}
     248
     249static inline float32_t sinh_f32(float32_t val)
     250{
     251        return float32_sinh(val);
     252}
     253
     254static inline float64_t sqrt_f64(float64_t val)
     255{
     256        return float64_sqrt(val);
     257}
     258
     259static inline float32_t sqrt_f32(float32_t val)
     260{
     261        return float32_sqrt(val);
     262}
     263
     264static inline float64_t tan_f64(float64_t val)
     265{
     266        return float64_tan(val);
     267}
     268
     269static inline float32_t tan_f32(float32_t val)
     270{
     271        return float32_tan(val);
     272}
     273
     274static inline float64_t tanh_f64(float64_t val)
     275{
     276        return float64_tanh(val);
     277}
     278
     279static inline float32_t tanh_f32(float32_t val)
     280{
     281        return float32_tanh(val);
     282}
     283
    129284static inline float64_t trunc_f64(float64_t val)
    130285{
    … …  
    137292}
    138293
     294static inline float64_t acos(float64_t val)
     295{
     296        return acos_f64(val);
     297}
     298
     299static inline float32_t acosf(float32_t val)
     300{
     301        return acos_f32(val);
     302}
     303
     304static inline float64_t asin(float64_t val)
     305{
     306        return asin_f64(val);
     307}
     308
     309static inline float32_t asinf(float32_t val)
     310{
     311        return asin_f32(val);
     312}
     313
     314static inline float64_t atan(float64_t val)
     315{
     316        return atan_f64(val);
     317}
     318
     319static inline float32_t atanf(float32_t val)
     320{
     321        return atan_f32(val);
     322}
     323
     324static inline float64_t atan2(float64_t y, float64_t x)
     325{
     326        return atan2_f64(y, x);
     327}
     328
     329static inline float32_t atan2f(float32_t y, float32_t x)
     330{
     331        return atan2_f32(y, x);
     332}
     333
    139334static inline float64_t ceil(float64_t val)
    140335{
    … …  
    157352}
    158353
     354static inline float64_t cosh(float64_t val)
     355{
     356        return cosh_f64(val);
     357}
     358
     359static inline float32_t coshf(float32_t val)
     360{
     361        return cosh_f32(val);
     362}
     363
    159364static inline float64_t exp(float64_t val)
    160365{
    … …  
    167372}
    168373
     374static inline float64_t fabs(float64_t val)
     375{
     376        return fabs_f64(val);
     377}
     378
     379static inline float32_t fabsf(float32_t val)
     380{
     381        return fabs_f32(val);
     382}
     383
    169384static inline float64_t floor(float64_t val)
    170385{
    … …  
    187402}
    188403
     404static inline float64_t frexp(float64_t x, int *exp)
     405{
     406        return frexp_f64(x, exp);
     407}
     408
     409static inline float32_t frexpf(float32_t x, int *exp)
     410{
     411        return frexp_f32(x, exp);
     412}
     413
     414static inline float64_t ldexp(float64_t x, int exp)
     415{
     416        return ldexp_f64(x, exp);
     417}
     418
     419static inline float32_t ldexpf(float32_t x, int exp)
     420{
     421        return ldexp_f32(x, exp);
     422}
     423
    189424static inline float64_t log(float64_t val)
    190425{
    … …  
    197432}
    198433
     434static inline float64_t log10(float64_t val)
     435{
     436        return log10_f64(val);
     437}
     438
     439static inline float32_t log10f(float32_t val)
     440{
     441        return log10_f32(val);
     442}
     443
     444static inline float64_t modf(float64_t value, float64_t *iptr)
     445{
     446        return modf_f64(value, iptr);
     447}
     448
     449static inline float32_t modff(float32_t value, float32_t *iptr)
     450{
     451        return modf_f32(value, iptr);
     452}
     453
    199454static inline float64_t pow(float64_t x, float64_t y)
    200455{
    … …  
    215470{
    216471        return sin_f32(val);
     472}
     473
     474static inline float64_t sinh(float64_t val)
     475{
     476        return sinh_f64(val);
     477}
     478
     479static inline float32_t sinhf(float32_t val)
     480{
     481        return sinh_f32(val);
     482}
     483
     484static inline float64_t sqrt(float64_t val)
     485{
     486        return sqrt_f64(val);
     487}
     488
     489static inline float32_t sqrtf(float32_t val)
     490{
     491        return sqrt_f32(val);
     492}
     493
     494static inline float64_t tan(float64_t val)
     495{
     496        return tan_f64(val);
     497}
     498
     499static inline float32_t tanf(float32_t val)
     500{
     501        return tan_f32(val);
     502}
     503
     504static inline float64_t tanh(float64_t val)
     505{
     506        return tanh_f64(val);
     507}
     508
     509static inline float32_t tanhf(float32_t val)
     510{
     511        return tanh_f32(val);
    217512}
    218513

  • uspace/lib/math/arch/ia32/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_ia32_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    64120}
    65121
     122static inline float64_t cosh_f64(float64_t val)
     123{
     124        return float64_cosh(val);
     125}
     126
     127static inline float32_t cosh_f32(float32_t val)
     128{
     129        return float32_cosh(val);
     130}
     131
    66132static inline float64_t exp_f64(float64_t val)
    67133{
    … …  
    74140}
    75141
     142static inline float64_t fabs_f64(float64_t val)
     143{
     144        return float64_fabs(val);
     145}
     146
     147static inline float32_t fabs_f32(float32_t val)
     148{
     149        return float32_fabs(val);
     150}
     151
    76152static inline float64_t floor_f64(float64_t val)
    77153{
    … …  
    83159        return float32_floor(val);
    84160}
    85 
    86161static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    87162{
    88         return float64_mod(dividend, divisor);
     163        return float64_fmod(dividend, divisor);
    89164}
    90165
    91166static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    92167{
    93         return float32_mod(dividend, divisor);
     168        return float32_fmod(dividend, divisor);
     169}
     170
     171static inline float64_t frexp_f64(float64_t x, int *exp)
     172{
     173        return float64_frexp(x, exp);
     174}
     175
     176static inline float64_t frexp_f32(float32_t x, int *exp)
     177{
     178        return float32_frexp(x, exp);
     179}
     180
     181static inline float64_t ldexp_f64(float64_t x, int exp)
     182{
     183        return float64_ldexp(x, exp);
     184}
     185
     186static inline float64_t ldexp_f32(float32_t x, int exp)
     187{
     188        return float32_ldexp(x, exp);
    94189}
    95190
    … …  
    104199}
    105200
     201static inline float64_t log10_f64(float64_t val)
     202{
     203        return float64_log10(val);
     204}
     205
     206static inline float32_t log10_f32(float32_t val)
     207{
     208        return float32_log10(val);
     209}
     210
     211static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     212{
     213        return float64_modf(value, iptr);
     214}
     215
     216static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     217{
     218        return float32_modf(value, iptr);
     219}
     220
    106221static inline float64_t pow_f64(float64_t x, float64_t y)
    107222{
    … …  
    121236}
    122237
     238static inline float64_t sinh_f64(float64_t val)
     239{
     240        return float64_sinh(val);
     241}
     242
     243static inline float32_t sinh_f32(float32_t val)
     244{
     245        return float32_sinh(val);
     246}
     247
     248static inline float64_t sqrt_f64(float64_t val)
     249{
     250        return float64_sqrt(val);
     251}
     252
     253static inline float32_t sqrt_f32(float32_t val)
     254{
     255        return float32_sqrt(val);
     256}
     257
     258static inline float64_t tan_f64(float64_t val)
     259{
     260        return float64_tan(val);
     261}
     262
     263static inline float32_t tan_f32(float32_t val)
     264{
     265        return float32_tan(val);
     266}
     267
     268static inline float64_t tanh_f64(float64_t val)
     269{
     270        return float64_tanh(val);
     271}
     272
     273static inline float32_t tanh_f32(float32_t val)
     274{
     275        return float32_tanh(val);
     276}
     277
    123278extern float64_t trunc_f64(float64_t);
    124279
    … …  
    128283}
    129284
     285static inline float64_t acos(float64_t val)
     286{
     287        return acos_f64(val);
     288}
     289
     290static inline float32_t acosf(float32_t val)
     291{
     292        return acos_f32(val);
     293}
     294
     295static inline float64_t asin(float64_t val)
     296{
     297        return asin_f64(val);
     298}
     299
     300static inline float32_t asinf(float32_t val)
     301{
     302        return asin_f32(val);
     303}
     304
     305static inline float64_t atan(float64_t val)
     306{
     307        return atan_f64(val);
     308}
     309
     310static inline float32_t atanf(float32_t val)
     311{
     312        return atan_f32(val);
     313}
     314
     315static inline float64_t atan2(float64_t y, float64_t x)
     316{
     317        return atan2_f64(y, x);
     318}
     319
     320static inline float32_t atan2f(float32_t y, float32_t x)
     321{
     322        return atan2_f32(y, x);
     323}
     324
    130325static inline float64_t ceil(float64_t val)
    131326{
    … …  
    148343}
    149344
     345static inline float64_t cosh(float64_t val)
     346{
     347        return cosh_f64(val);
     348}
     349
     350static inline float32_t coshf(float32_t val)
     351{
     352        return cosh_f32(val);
     353}
     354
    150355static inline float64_t exp(float64_t val)
    151356{
    … …  
    158363}
    159364
     365static inline float64_t fabs(float64_t val)
     366{
     367        return fabs_f64(val);
     368}
     369
     370static inline float32_t fabsf(float32_t val)
     371{
     372        return fabs_f32(val);
     373}
     374
    160375static inline float64_t floor(float64_t val)
    161376{
    … …  
    178393}
    179394
     395static inline float64_t frexp(float64_t x, int *exp)
     396{
     397        return frexp_f64(x, exp);
     398}
     399
     400static inline float32_t frexpf(float32_t x, int *exp)
     401{
     402        return frexp_f32(x, exp);
     403}
     404
     405static inline float64_t ldexp(float64_t x, int exp)
     406{
     407        return ldexp_f64(x, exp);
     408}
     409
     410static inline float32_t ldexpf(float32_t x, int exp)
     411{
     412        return ldexp_f32(x, exp);
     413}
     414
    180415static inline float64_t log(float64_t val)
    181416{
    … …  
    188423}
    189424
     425static inline float64_t log10(float64_t val)
     426{
     427        return log10_f64(val);
     428}
     429
     430static inline float32_t log10f(float32_t val)
     431{
     432        return log10_f32(val);
     433}
     434
     435static inline float64_t modf(float64_t value, float64_t *iptr)
     436{
     437        return modf_f64(value, iptr);
     438}
     439
     440static inline float32_t modff(float32_t value, float32_t *iptr)
     441{
     442        return modf_f32(value, iptr);
     443}
     444
    190445static inline float64_t pow(float64_t x, float64_t y)
    191446{
    … …  
    206461{
    207462        return sin_f32(val);
     463}
     464
     465static inline float64_t sinh(float64_t val)
     466{
     467        return sinh_f64(val);
     468}
     469
     470static inline float32_t sinhf(float32_t val)
     471{
     472        return sinh_f32(val);
     473}
     474
     475static inline float64_t sqrt(float64_t val)
     476{
     477        return sqrt_f64(val);
     478}
     479
     480static inline float32_t sqrtf(float32_t val)
     481{
     482        return sqrt_f32(val);
     483}
     484
     485static inline float64_t tan(float64_t val)
     486{
     487        return tan_f64(val);
     488}
     489
     490static inline float32_t tanf(float32_t val)
     491{
     492        return tan_f32(val);
     493}
     494
     495static inline float64_t tanh(float64_t val)
     496{
     497        return tanh_f64(val);
     498}
     499
     500static inline float32_t tanhf(float32_t val)
     501{
     502        return tanh_f32(val);
    208503}
    209504

  • uspace/lib/math/arch/ia64/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_ia64_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    67123}
    68124
     125static inline float64_t cosh_f64(float64_t val)
     126{
     127        return float64_cosh(val);
     128}
     129
     130static inline float32_t cosh_f32(float32_t val)
     131{
     132        return float32_cosh(val);
     133}
     134
    69135static inline float64_t exp_f64(float64_t val)
    70136{
    … …  
    77143}
    78144
     145static inline float64_t fabs_f64(float64_t val)
     146{
     147        return float64_fabs(val);
     148}
     149
     150static inline float32_t fabs_f32(float32_t val)
     151{
     152        return float32_fabs(val);
     153}
     154
    79155static inline float64_t floor_f64(float64_t val)
    80156{
    … …  
    86162        return float32_floor(val);
    87163}
    88 
    89164static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    90165{
    91         return float64_mod(dividend, divisor);
     166        return float64_fmod(dividend, divisor);
    92167}
    93168
    94169static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    95170{
    96         return float32_mod(dividend, divisor);
     171        return float32_fmod(dividend, divisor);
     172}
     173
     174static inline float64_t frexp_f64(float64_t x, int *exp)
     175{
     176        return float64_frexp(x, exp);
     177}
     178
     179static inline float64_t frexp_f32(float32_t x, int *exp)
     180{
     181        return float32_frexp(x, exp);
     182}
     183
     184static inline float64_t ldexp_f64(float64_t x, int exp)
     185{
     186        return float64_ldexp(x, exp);
     187}
     188
     189static inline float64_t ldexp_f32(float32_t x, int exp)
     190{
     191        return float32_ldexp(x, exp);
    97192}
    98193
    … …  
    107202}
    108203
     204static inline float64_t log10_f64(float64_t val)
     205{
     206        return float64_log10(val);
     207}
     208
     209static inline float32_t log10_f32(float32_t val)
     210{
     211        return float32_log10(val);
     212}
     213
     214static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     215{
     216        return float64_modf(value, iptr);
     217}
     218
     219static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     220{
     221        return float32_modf(value, iptr);
     222}
     223
    109224static inline float64_t pow_f64(float64_t x, float64_t y)
    110225{
    … …  
    127242}
    128243
     244static inline float64_t sinh_f64(float64_t val)
     245{
     246        return float64_sinh(val);
     247}
     248
     249static inline float32_t sinh_f32(float32_t val)
     250{
     251        return float32_sinh(val);
     252}
     253
     254static inline float64_t sqrt_f64(float64_t val)
     255{
     256        return float64_sqrt(val);
     257}
     258
     259static inline float32_t sqrt_f32(float32_t val)
     260{
     261        return float32_sqrt(val);
     262}
     263
     264static inline float64_t tan_f64(float64_t val)
     265{
     266        return float64_tan(val);
     267}
     268
     269static inline float32_t tan_f32(float32_t val)
     270{
     271        return float32_tan(val);
     272}
     273
     274static inline float64_t tanh_f64(float64_t val)
     275{
     276        return float64_tanh(val);
     277}
     278
     279static inline float32_t tanh_f32(float32_t val)
     280{
     281        return float32_tanh(val);
     282}
     283
    129284static inline float64_t trunc_f64(float64_t val)
    130285{
    … …  
    137292}
    138293
     294static inline float64_t acos(float64_t val)
     295{
     296        return acos_f64(val);
     297}
     298
     299static inline float32_t acosf(float32_t val)
     300{
     301        return acos_f32(val);
     302}
     303
     304static inline float64_t asin(float64_t val)
     305{
     306        return asin_f64(val);
     307}
     308
     309static inline float32_t asinf(float32_t val)
     310{
     311        return asin_f32(val);
     312}
     313
     314static inline float64_t atan(float64_t val)
     315{
     316        return atan_f64(val);
     317}
     318
     319static inline float32_t atanf(float32_t val)
     320{
     321        return atan_f32(val);
     322}
     323
     324static inline float64_t atan2(float64_t y, float64_t x)
     325{
     326        return atan2_f64(y, x);
     327}
     328
     329static inline float32_t atan2f(float32_t y, float32_t x)
     330{
     331        return atan2_f32(y, x);
     332}
     333
    139334static inline float64_t ceil(float64_t val)
    140335{
    … …  
    157352}
    158353
     354static inline float64_t cosh(float64_t val)
     355{
     356        return cosh_f64(val);
     357}
     358
     359static inline float32_t coshf(float32_t val)
     360{
     361        return cosh_f32(val);
     362}
     363
    159364static inline float64_t exp(float64_t val)
    160365{
    … …  
    167372}
    168373
     374static inline float64_t fabs(float64_t val)
     375{
     376        return fabs_f64(val);
     377}
     378
     379static inline float32_t fabsf(float32_t val)
     380{
     381        return fabs_f32(val);
     382}
     383
    169384static inline float64_t floor(float64_t val)
    170385{
    … …  
    187402}
    188403
     404static inline float64_t frexp(float64_t x, int *exp)
     405{
     406        return frexp_f64(x, exp);
     407}
     408
     409static inline float32_t frexpf(float32_t x, int *exp)
     410{
     411        return frexp_f32(x, exp);
     412}
     413
     414static inline float64_t ldexp(float64_t x, int exp)
     415{
     416        return ldexp_f64(x, exp);
     417}
     418
     419static inline float32_t ldexpf(float32_t x, int exp)
     420{
     421        return ldexp_f32(x, exp);
     422}
     423
    189424static inline float64_t log(float64_t val)
    190425{
    … …  
    197432}
    198433
     434static inline float64_t log10(float64_t val)
     435{
     436        return log10_f64(val);
     437}
     438
     439static inline float32_t log10f(float32_t val)
     440{
     441        return log10_f32(val);
     442}
     443
     444static inline float64_t modf(float64_t value, float64_t *iptr)
     445{
     446        return modf_f64(value, iptr);
     447}
     448
     449static inline float32_t modff(float32_t value, float32_t *iptr)
     450{
     451        return modf_f32(value, iptr);
     452}
     453
    199454static inline float64_t pow(float64_t x, float64_t y)
    200455{
    … …  
    215470{
    216471        return sin_f32(val);
     472}
     473
     474static inline float64_t sinh(float64_t val)
     475{
     476        return sinh_f64(val);
     477}
     478
     479static inline float32_t sinhf(float32_t val)
     480{
     481        return sinh_f32(val);
     482}
     483
     484static inline float64_t sqrt(float64_t val)
     485{
     486        return sqrt_f64(val);
     487}
     488
     489static inline float32_t sqrtf(float32_t val)
     490{
     491        return sqrt_f32(val);
     492}
     493
     494static inline float64_t tan(float64_t val)
     495{
     496        return tan_f64(val);
     497}
     498
     499static inline float32_t tanf(float32_t val)
     500{
     501        return tan_f32(val);
     502}
     503
     504static inline float64_t tanh(float64_t val)
     505{
     506        return tanh_f64(val);
     507}
     508
     509static inline float32_t tanhf(float32_t val)
     510{
     511        return tanh_f32(val);
    217512}
    218513

  • uspace/lib/math/arch/mips32/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_mips32_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    67123}
    68124
     125static inline float64_t cosh_f64(float64_t val)
     126{
     127        return float64_cosh(val);
     128}
     129
     130static inline float32_t cosh_f32(float32_t val)
     131{
     132        return float32_cosh(val);
     133}
     134
    69135static inline float64_t exp_f64(float64_t val)
    70136{
    … …  
    77143}
    78144
     145static inline float64_t fabs_f64(float64_t val)
     146{
     147        return float64_fabs(val);
     148}
     149
     150static inline float32_t fabs_f32(float32_t val)
     151{
     152        return float32_fabs(val);
     153}
     154
    79155static inline float64_t floor_f64(float64_t val)
    80156{
    … …  
    86162        return float32_floor(val);
    87163}
    88 
    89164static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    90165{
    91         return float64_mod(dividend, divisor);
     166        return float64_fmod(dividend, divisor);
    92167}
    93168
    94169static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    95170{
    96         return float32_mod(dividend, divisor);
     171        return float32_fmod(dividend, divisor);
     172}
     173
     174static inline float64_t frexp_f64(float64_t x, int *exp)
     175{
     176        return float64_frexp(x, exp);
     177}
     178
     179static inline float64_t frexp_f32(float32_t x, int *exp)
     180{
     181        return float32_frexp(x, exp);
     182}
     183
     184static inline float64_t ldexp_f64(float64_t x, int exp)
     185{
     186        return float64_ldexp(x, exp);
     187}
     188
     189static inline float64_t ldexp_f32(float32_t x, int exp)
     190{
     191        return float32_ldexp(x, exp);
    97192}
    98193
    … …  
    107202}
    108203
     204static inline float64_t log10_f64(float64_t val)
     205{
     206        return float64_log10(val);
     207}
     208
     209static inline float32_t log10_f32(float32_t val)
     210{
     211        return float32_log10(val);
     212}
     213
     214static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     215{
     216        return float64_modf(value, iptr);
     217}
     218
     219static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     220{
     221        return float32_modf(value, iptr);
     222}
     223
    109224static inline float64_t pow_f64(float64_t x, float64_t y)
    110225{
    … …  
    127242}
    128243
     244static inline float64_t sinh_f64(float64_t val)
     245{
     246        return float64_sinh(val);
     247}
     248
     249static inline float32_t sinh_f32(float32_t val)
     250{
     251        return float32_sinh(val);
     252}
     253
     254static inline float64_t sqrt_f64(float64_t val)
     255{
     256        return float64_sqrt(val);
     257}
     258
     259static inline float32_t sqrt_f32(float32_t val)
     260{
     261        return float32_sqrt(val);
     262}
     263
     264static inline float64_t tan_f64(float64_t val)
     265{
     266        return float64_tan(val);
     267}
     268
     269static inline float32_t tan_f32(float32_t val)
     270{
     271        return float32_tan(val);
     272}
     273
     274static inline float64_t tanh_f64(float64_t val)
     275{
     276        return float64_tanh(val);
     277}
     278
     279static inline float32_t tanh_f32(float32_t val)
     280{
     281        return float32_tanh(val);
     282}
     283
    129284static inline float64_t trunc_f64(float64_t val)
    130285{
    … …  
    137292}
    138293
     294static inline float64_t acos(float64_t val)
     295{
     296        return acos_f64(val);
     297}
     298
     299static inline float32_t acosf(float32_t val)
     300{
     301        return acos_f32(val);
     302}
     303
     304static inline float64_t asin(float64_t val)
     305{
     306        return asin_f64(val);
     307}
     308
     309static inline float32_t asinf(float32_t val)
     310{
     311        return asin_f32(val);
     312}
     313
     314static inline float64_t atan(float64_t val)
     315{
     316        return atan_f64(val);
     317}
     318
     319static inline float32_t atanf(float32_t val)
     320{
     321        return atan_f32(val);
     322}
     323
     324static inline float64_t atan2(float64_t y, float64_t x)
     325{
     326        return atan2_f64(y, x);
     327}
     328
     329static inline float32_t atan2f(float32_t y, float32_t x)
     330{
     331        return atan2_f32(y, x);
     332}
     333
    139334static inline float64_t ceil(float64_t val)
    140335{
    … …  
    157352}
    158353
     354static inline float64_t cosh(float64_t val)
     355{
     356        return cosh_f64(val);
     357}
     358
     359static inline float32_t coshf(float32_t val)
     360{
     361        return cosh_f32(val);
     362}
     363
    159364static inline float64_t exp(float64_t val)
    160365{
    … …  
    167372}
    168373
     374static inline float64_t fabs(float64_t val)
     375{
     376        return fabs_f64(val);
     377}
     378
     379static inline float32_t fabsf(float32_t val)
     380{
     381        return fabs_f32(val);
     382}
     383
    169384static inline float64_t floor(float64_t val)
    170385{
    … …  
    187402}
    188403
     404static inline float64_t frexp(float64_t x, int *exp)
     405{
     406        return frexp_f64(x, exp);
     407}
     408
     409static inline float32_t frexpf(float32_t x, int *exp)
     410{
     411        return frexp_f32(x, exp);
     412}
     413
     414static inline float64_t ldexp(float64_t x, int exp)
     415{
     416        return ldexp_f64(x, exp);
     417}
     418
     419static inline float32_t ldexpf(float32_t x, int exp)
     420{
     421        return ldexp_f32(x, exp);
     422}
     423
    189424static inline float64_t log(float64_t val)
    190425{
    … …  
    197432}
    198433
     434static inline float64_t log10(float64_t val)
     435{
     436        return log10_f64(val);
     437}
     438
     439static inline float32_t log10f(float32_t val)
     440{
     441        return log10_f32(val);
     442}
     443
     444static inline float64_t modf(float64_t value, float64_t *iptr)
     445{
     446        return modf_f64(value, iptr);
     447}
     448
     449static inline float32_t modff(float32_t value, float32_t *iptr)
     450{
     451        return modf_f32(value, iptr);
     452}
     453
    199454static inline float64_t pow(float64_t x, float64_t y)
    200455{
    … …  
    215470{
    216471        return sin_f32(val);
     472}
     473
     474static inline float64_t sinh(float64_t val)
     475{
     476        return sinh_f64(val);
     477}
     478
     479static inline float32_t sinhf(float32_t val)
     480{
     481        return sinh_f32(val);
     482}
     483
     484static inline float64_t sqrt(float64_t val)
     485{
     486        return sqrt_f64(val);
     487}
     488
     489static inline float32_t sqrtf(float32_t val)
     490{
     491        return sqrt_f32(val);
     492}
     493
     494static inline float64_t tan(float64_t val)
     495{
     496        return tan_f64(val);
     497}
     498
     499static inline float32_t tanf(float32_t val)
     500{
     501        return tan_f32(val);
     502}
     503
     504static inline float64_t tanh(float64_t val)
     505{
     506        return tanh_f64(val);
     507}
     508
     509static inline float32_t tanhf(float32_t val)
     510{
     511        return tanh_f32(val);
    217512}
    218513

  • uspace/lib/math/arch/mips32eb/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_mips32eb_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    67123}
    68124
     125static inline float64_t cosh_f64(float64_t val)
     126{
     127        return float64_cosh(val);
     128}
     129
     130static inline float32_t cosh_f32(float32_t val)
     131{
     132        return float32_cosh(val);
     133}
     134
    69135static inline float64_t exp_f64(float64_t val)
    70136{
    … …  
    77143}
    78144
     145static inline float64_t fabs_f64(float64_t val)
     146{
     147        return float64_fabs(val);
     148}
     149
     150static inline float32_t fabs_f32(float32_t val)
     151{
     152        return float32_fabs(val);
     153}
     154
    79155static inline float64_t floor_f64(float64_t val)
    80156{
    … …  
    86162        return float32_floor(val);
    87163}
    88 
    89164static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    90165{
    91         return float64_mod(dividend, divisor);
     166        return float64_fmod(dividend, divisor);
    92167}
    93168
    94169static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    95170{
    96         return float32_mod(dividend, divisor);
     171        return float32_fmod(dividend, divisor);
     172}
     173
     174static inline float64_t frexp_f64(float64_t x, int *exp)
     175{
     176        return float64_frexp(x, exp);
     177}
     178
     179static inline float64_t frexp_f32(float32_t x, int *exp)
     180{
     181        return float32_frexp(x, exp);
     182}
     183
     184static inline float64_t ldexp_f64(float64_t x, int exp)
     185{
     186        return float64_ldexp(x, exp);
     187}
     188
     189static inline float64_t ldexp_f32(float32_t x, int exp)
     190{
     191        return float32_ldexp(x, exp);
    97192}
    98193
    … …  
    107202}
    108203
     204static inline float64_t log10_f64(float64_t val)
     205{
     206        return float64_log10(val);
     207}
     208
     209static inline float32_t log10_f32(float32_t val)
     210{
     211        return float32_log10(val);
     212}
     213
     214static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     215{
     216        return float64_modf(value, iptr);
     217}
     218
     219static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     220{
     221        return float32_modf(value, iptr);
     222}
     223
    109224static inline float64_t pow_f64(float64_t x, float64_t y)
    110225{
    … …  
    127242}
    128243
     244static inline float64_t sinh_f64(float64_t val)
     245{
     246        return float64_sinh(val);
     247}
     248
     249static inline float32_t sinh_f32(float32_t val)
     250{
     251        return float32_sinh(val);
     252}
     253
     254static inline float64_t sqrt_f64(float64_t val)
     255{
     256        return float64_sqrt(val);
     257}
     258
     259static inline float32_t sqrt_f32(float32_t val)
     260{
     261        return float32_sqrt(val);
     262}
     263
     264static inline float64_t tan_f64(float64_t val)
     265{
     266        return float64_tan(val);
     267}
     268
     269static inline float32_t tan_f32(float32_t val)
     270{
     271        return float32_tan(val);
     272}
     273
     274static inline float64_t tanh_f64(float64_t val)
     275{
     276        return float64_tanh(val);
     277}
     278
     279static inline float32_t tanh_f32(float32_t val)
     280{
     281        return float32_tanh(val);
     282}
     283
    129284static inline float64_t trunc_f64(float64_t val)
    130285{
    … …  
    137292}
    138293
     294static inline float64_t acos(float64_t val)
     295{
     296        return acos_f64(val);
     297}
     298
     299static inline float32_t acosf(float32_t val)
     300{
     301        return acos_f32(val);
     302}
     303
     304static inline float64_t asin(float64_t val)
     305{
     306        return asin_f64(val);
     307}
     308
     309static inline float32_t asinf(float32_t val)
     310{
     311        return asin_f32(val);
     312}
     313
     314static inline float64_t atan(float64_t val)
     315{
     316        return atan_f64(val);
     317}
     318
     319static inline float32_t atanf(float32_t val)
     320{
     321        return atan_f32(val);
     322}
     323
     324static inline float64_t atan2(float64_t y, float64_t x)
     325{
     326        return atan2_f64(y, x);
     327}
     328
     329static inline float32_t atan2f(float32_t y, float32_t x)
     330{
     331        return atan2_f32(y, x);
     332}
     333
    139334static inline float64_t ceil(float64_t val)
    140335{
    … …  
    157352}
    158353
     354static inline float64_t cosh(float64_t val)
     355{
     356        return cosh_f64(val);
     357}
     358
     359static inline float32_t coshf(float32_t val)
     360{
     361        return cosh_f32(val);
     362}
     363
    159364static inline float64_t exp(float64_t val)
    160365{
    … …  
    167372}
    168373
     374static inline float64_t fabs(float64_t val)
     375{
     376        return fabs_f64(val);
     377}
     378
     379static inline float32_t fabsf(float32_t val)
     380{
     381        return fabs_f32(val);
     382}
     383
    169384static inline float64_t floor(float64_t val)
    170385{
    … …  
    187402}
    188403
     404static inline float64_t frexp(float64_t x, int *exp)
     405{
     406        return frexp_f64(x, exp);
     407}
     408
     409static inline float32_t frexpf(float32_t x, int *exp)
     410{
     411        return frexp_f32(x, exp);
     412}
     413
     414static inline float64_t ldexp(float64_t x, int exp)
     415{
     416        return ldexp_f64(x, exp);
     417}
     418
     419static inline float32_t ldexpf(float32_t x, int exp)
     420{
     421        return ldexp_f32(x, exp);
     422}
     423
    189424static inline float64_t log(float64_t val)
    190425{
    … …  
    197432}
    198433
     434static inline float64_t log10(float64_t val)
     435{
     436        return log10_f64(val);
     437}
     438
     439static inline float32_t log10f(float32_t val)
     440{
     441        return log10_f32(val);
     442}
     443
     444static inline float64_t modf(float64_t value, float64_t *iptr)
     445{
     446        return modf_f64(value, iptr);
     447}
     448
     449static inline float32_t modff(float32_t value, float32_t *iptr)
     450{
     451        return modf_f32(value, iptr);
     452}
     453
    199454static inline float64_t pow(float64_t x, float64_t y)
    200455{
    … …  
    215470{
    216471        return sin_f32(val);
     472}
     473
     474static inline float64_t sinh(float64_t val)
     475{
     476        return sinh_f64(val);
     477}
     478
     479static inline float32_t sinhf(float32_t val)
     480{
     481        return sinh_f32(val);
     482}
     483
     484static inline float64_t sqrt(float64_t val)
     485{
     486        return sqrt_f64(val);
     487}
     488
     489static inline float32_t sqrtf(float32_t val)
     490{
     491        return sqrt_f32(val);
     492}
     493
     494static inline float64_t tan(float64_t val)
     495{
     496        return tan_f64(val);
     497}
     498
     499static inline float32_t tanf(float32_t val)
     500{
     501        return tan_f32(val);
     502}
     503
     504static inline float64_t tanh(float64_t val)
     505{
     506        return tanh_f64(val);
     507}
     508
     509static inline float32_t tanhf(float32_t val)
     510{
     511        return tanh_f32(val);
    217512}
    218513

  • uspace/lib/math/arch/ppc32/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_ppc32_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    67123}
    68124
     125static inline float64_t cosh_f64(float64_t val)
     126{
     127        return float64_cosh(val);
     128}
     129
     130static inline float32_t cosh_f32(float32_t val)
     131{
     132        return float32_cosh(val);
     133}
     134
    69135static inline float64_t exp_f64(float64_t val)
    70136{
    … …  
    77143}
    78144
     145static inline float64_t fabs_f64(float64_t val)
     146{
     147        return float64_fabs(val);
     148}
     149
     150static inline float32_t fabs_f32(float32_t val)
     151{
     152        return float32_fabs(val);
     153}
     154
    79155static inline float64_t floor_f64(float64_t val)
    80156{
    … …  
    86162        return float32_floor(val);
    87163}
    88 
    89164static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    90165{
    91         return float64_mod(dividend, divisor);
     166        return float64_fmod(dividend, divisor);
    92167}
    93168
    94169static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    95170{
    96         return float32_mod(dividend, divisor);
     171        return float32_fmod(dividend, divisor);
     172}
     173
     174static inline float64_t frexp_f64(float64_t x, int *exp)
     175{
     176        return float64_frexp(x, exp);
     177}
     178
     179static inline float64_t frexp_f32(float32_t x, int *exp)
     180{
     181        return float32_frexp(x, exp);
     182}
     183
     184static inline float64_t ldexp_f64(float64_t x, int exp)
     185{
     186        return float64_ldexp(x, exp);
     187}
     188
     189static inline float64_t ldexp_f32(float32_t x, int exp)
     190{
     191        return float32_ldexp(x, exp);
    97192}
    98193
    … …  
    107202}
    108203
     204static inline float64_t log10_f64(float64_t val)
     205{
     206        return float64_log10(val);
     207}
     208
     209static inline float32_t log10_f32(float32_t val)
     210{
     211        return float32_log10(val);
     212}
     213
     214static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     215{
     216        return float64_modf(value, iptr);
     217}
     218
     219static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     220{
     221        return float32_modf(value, iptr);
     222}
     223
    109224static inline float64_t pow_f64(float64_t x, float64_t y)
    110225{
    … …  
    127242}
    128243
     244static inline float64_t sinh_f64(float64_t val)
     245{
     246        return float64_sinh(val);
     247}
     248
     249static inline float32_t sinh_f32(float32_t val)
     250{
     251        return float32_sinh(val);
     252}
     253
     254static inline float64_t sqrt_f64(float64_t val)
     255{
     256        return float64_sqrt(val);
     257}
     258
     259static inline float32_t sqrt_f32(float32_t val)
     260{
     261        return float32_sqrt(val);
     262}
     263
     264static inline float64_t tan_f64(float64_t val)
     265{
     266        return float64_tan(val);
     267}
     268
     269static inline float32_t tan_f32(float32_t val)
     270{
     271        return float32_tan(val);
     272}
     273
     274static inline float64_t tanh_f64(float64_t val)
     275{
     276        return float64_tanh(val);
     277}
     278
     279static inline float32_t tanh_f32(float32_t val)
     280{
     281        return float32_tanh(val);
     282}
     283
    129284static inline float64_t trunc_f64(float64_t val)
    130285{
    … …  
    137292}
    138293
     294static inline float64_t acos(float64_t val)
     295{
     296        return acos_f64(val);
     297}
     298
     299static inline float32_t acosf(float32_t val)
     300{
     301        return acos_f32(val);
     302}
     303
     304static inline float64_t asin(float64_t val)
     305{
     306        return asin_f64(val);
     307}
     308
     309static inline float32_t asinf(float32_t val)
     310{
     311        return asin_f32(val);
     312}
     313
     314static inline float64_t atan(float64_t val)
     315{
     316        return atan_f64(val);
     317}
     318
     319static inline float32_t atanf(float32_t val)
     320{
     321        return atan_f32(val);
     322}
     323
     324static inline float64_t atan2(float64_t y, float64_t x)
     325{
     326        return atan2_f64(y, x);
     327}
     328
     329static inline float32_t atan2f(float32_t y, float32_t x)
     330{
     331        return atan2_f32(y, x);
     332}
     333
    139334static inline float64_t ceil(float64_t val)
    140335{
    … …  
    157352}
    158353
     354static inline float64_t cosh(float64_t val)
     355{
     356        return cosh_f64(val);
     357}
     358
     359static inline float32_t coshf(float32_t val)
     360{
     361        return cosh_f32(val);
     362}
     363
    159364static inline float64_t exp(float64_t val)
    160365{
    … …  
    167372}
    168373
     374static inline float64_t fabs(float64_t val)
     375{
     376        return fabs_f64(val);
     377}
     378
     379static inline float32_t fabsf(float32_t val)
     380{
     381        return fabs_f32(val);
     382}
     383
    169384static inline float64_t floor(float64_t val)
    170385{
    … …  
    187402}
    188403
     404static inline float64_t frexp(float64_t x, int *exp)
     405{
     406        return frexp_f64(x, exp);
     407}
     408
     409static inline float32_t frexpf(float32_t x, int *exp)
     410{
     411        return frexp_f32(x, exp);
     412}
     413
     414static inline float64_t ldexp(float64_t x, int exp)
     415{
     416        return ldexp_f64(x, exp);
     417}
     418
     419static inline float32_t ldexpf(float32_t x, int exp)
     420{
     421        return ldexp_f32(x, exp);
     422}
     423
    189424static inline float64_t log(float64_t val)
    190425{
    … …  
    197432}
    198433
     434static inline float64_t log10(float64_t val)
     435{
     436        return log10_f64(val);
     437}
     438
     439static inline float32_t log10f(float32_t val)
     440{
     441        return log10_f32(val);
     442}
     443
     444static inline float64_t modf(float64_t value, float64_t *iptr)
     445{
     446        return modf_f64(value, iptr);
     447}
     448
     449static inline float32_t modff(float32_t value, float32_t *iptr)
     450{
     451        return modf_f32(value, iptr);
     452}
     453
    199454static inline float64_t pow(float64_t x, float64_t y)
    200455{
    … …  
    215470{
    216471        return sin_f32(val);
     472}
     473
     474static inline float64_t sinh(float64_t val)
     475{
     476        return sinh_f64(val);
     477}
     478
     479static inline float32_t sinhf(float32_t val)
     480{
     481        return sinh_f32(val);
     482}
     483
     484static inline float64_t sqrt(float64_t val)
     485{
     486        return sqrt_f64(val);
     487}
     488
     489static inline float32_t sqrtf(float32_t val)
     490{
     491        return sqrt_f32(val);
     492}
     493
     494static inline float64_t tan(float64_t val)
     495{
     496        return tan_f64(val);
     497}
     498
     499static inline float32_t tanf(float32_t val)
     500{
     501        return tan_f32(val);
     502}
     503
     504static inline float64_t tanh(float64_t val)
     505{
     506        return tanh_f64(val);
     507}
     508
     509static inline float32_t tanhf(float32_t val)
     510{
     511        return tanh_f32(val);
    217512}
    218513

  • uspace/lib/math/arch/sparc32/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_sparc32_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    67123}
    68124
     125static inline float64_t cosh_f64(float64_t val)
     126{
     127        return float64_cosh(val);
     128}
     129
     130static inline float32_t cosh_f32(float32_t val)
     131{
     132        return float32_cosh(val);
     133}
     134
    69135static inline float64_t exp_f64(float64_t val)
    70136{
    … …  
    77143}
    78144
     145static inline float64_t fabs_f64(float64_t val)
     146{
     147        return float64_fabs(val);
     148}
     149
     150static inline float32_t fabs_f32(float32_t val)
     151{
     152        return float32_fabs(val);
     153}
     154
    79155static inline float64_t floor_f64(float64_t val)
    80156{
    … …  
    86162        return float32_floor(val);
    87163}
    88 
    89164static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    90165{
    91         return float64_mod(dividend, divisor);
     166        return float64_fmod(dividend, divisor);
    92167}
    93168
    94169static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    95170{
    96         return float32_mod(dividend, divisor);
     171        return float32_fmod(dividend, divisor);
     172}
     173
     174static inline float64_t frexp_f64(float64_t x, int *exp)
     175{
     176        return float64_frexp(x, exp);
     177}
     178
     179static inline float64_t frexp_f32(float32_t x, int *exp)
     180{
     181        return float32_frexp(x, exp);
     182}
     183
     184static inline float64_t ldexp_f64(float64_t x, int exp)
     185{
     186        return float64_ldexp(x, exp);
     187}
     188
     189static inline float64_t ldexp_f32(float32_t x, int exp)
     190{
     191        return float32_ldexp(x, exp);
    97192}
    98193
    … …  
    107202}
    108203
     204static inline float64_t log10_f64(float64_t val)
     205{
     206        return float64_log10(val);
     207}
     208
     209static inline float32_t log10_f32(float32_t val)
     210{
     211        return float32_log10(val);
     212}
     213
     214static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     215{
     216        return float64_modf(value, iptr);
     217}
     218
     219static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     220{
     221        return float32_modf(value, iptr);
     222}
     223
    109224static inline float64_t pow_f64(float64_t x, float64_t y)
    110225{
    … …  
    127242}
    128243
     244static inline float64_t sinh_f64(float64_t val)
     245{
     246        return float64_sinh(val);
     247}
     248
     249static inline float32_t sinh_f32(float32_t val)
     250{
     251        return float32_sinh(val);
     252}
     253
     254static inline float64_t sqrt_f64(float64_t val)
     255{
     256        return float64_sqrt(val);
     257}
     258
     259static inline float32_t sqrt_f32(float32_t val)
     260{
     261        return float32_sqrt(val);
     262}
     263
     264static inline float64_t tan_f64(float64_t val)
     265{
     266        return float64_tan(val);
     267}
     268
     269static inline float32_t tan_f32(float32_t val)
     270{
     271        return float32_tan(val);
     272}
     273
     274static inline float64_t tanh_f64(float64_t val)
     275{
     276        return float64_tanh(val);
     277}
     278
     279static inline float32_t tanh_f32(float32_t val)
     280{
     281        return float32_tanh(val);
     282}
     283
    129284static inline float64_t trunc_f64(float64_t val)
    130285{
    … …  
    137292}
    138293
     294static inline float64_t acos(float64_t val)
     295{
     296        return acos_f64(val);
     297}
     298
     299static inline float32_t acosf(float32_t val)
     300{
     301        return acos_f32(val);
     302}
     303
     304static inline float64_t asin(float64_t val)
     305{
     306        return asin_f64(val);
     307}
     308
     309static inline float32_t asinf(float32_t val)
     310{
     311        return asin_f32(val);
     312}
     313
     314static inline float64_t atan(float64_t val)
     315{
     316        return atan_f64(val);
     317}
     318
     319static inline float32_t atanf(float32_t val)
     320{
     321        return atan_f32(val);
     322}
     323
     324static inline float64_t atan2(float64_t y, float64_t x)
     325{
     326        return atan2_f64(y, x);
     327}
     328
     329static inline float32_t atan2f(float32_t y, float32_t x)
     330{
     331        return atan2_f32(y, x);
     332}
     333
    139334static inline float64_t ceil(float64_t val)
    140335{
    … …  
    157352}
    158353
     354static inline float64_t cosh(float64_t val)
     355{
     356        return cosh_f64(val);
     357}
     358
     359static inline float32_t coshf(float32_t val)
     360{
     361        return cosh_f32(val);
     362}
     363
    159364static inline float64_t exp(float64_t val)
    160365{
    … …  
    167372}
    168373
     374static inline float64_t fabs(float64_t val)
     375{
     376        return fabs_f64(val);
     377}
     378
     379static inline float32_t fabsf(float32_t val)
     380{
     381        return fabs_f32(val);
     382}
     383
    169384static inline float64_t floor(float64_t val)
    170385{
    … …  
    187402}
    188403
     404static inline float64_t frexp(float64_t x, int *exp)
     405{
     406        return frexp_f64(x, exp);
     407}
     408
     409static inline float32_t frexpf(float32_t x, int *exp)
     410{
     411        return frexp_f32(x, exp);
     412}
     413
     414static inline float64_t ldexp(float64_t x, int exp)
     415{
     416        return ldexp_f64(x, exp);
     417}
     418
     419static inline float32_t ldexpf(float32_t x, int exp)
     420{
     421        return ldexp_f32(x, exp);
     422}
     423
    189424static inline float64_t log(float64_t val)
    190425{
    … …  
    197432}
    198433
     434static inline float64_t log10(float64_t val)
     435{
     436        return log10_f64(val);
     437}
     438
     439static inline float32_t log10f(float32_t val)
     440{
     441        return log10_f32(val);
     442}
     443
     444static inline float64_t modf(float64_t value, float64_t *iptr)
     445{
     446        return modf_f64(value, iptr);
     447}
     448
     449static inline float32_t modff(float32_t value, float32_t *iptr)
     450{
     451        return modf_f32(value, iptr);
     452}
     453
    199454static inline float64_t pow(float64_t x, float64_t y)
    200455{
    … …  
    215470{
    216471        return sin_f32(val);
     472}
     473
     474static inline float64_t sinh(float64_t val)
     475{
     476        return sinh_f64(val);
     477}
     478
     479static inline float32_t sinhf(float32_t val)
     480{
     481        return sinh_f32(val);
     482}
     483
     484static inline float64_t sqrt(float64_t val)
     485{
     486        return sqrt_f64(val);
     487}
     488
     489static inline float32_t sqrtf(float32_t val)
     490{
     491        return sqrt_f32(val);
     492}
     493
     494static inline float64_t tan(float64_t val)
     495{
     496        return tan_f64(val);
     497}
     498
     499static inline float32_t tanf(float32_t val)
     500{
     501        return tan_f32(val);
     502}
     503
     504static inline float64_t tanh(float64_t val)
     505{
     506        return tanh_f64(val);
     507}
     508
     509static inline float32_t tanhf(float32_t val)
     510{
     511        return tanh_f32(val);
    217512}
    218513

  • uspace/lib/math/arch/sparc64/include/libarch/math.h

    r996dc042 r3b23d05  
    3737#define LIBMATH_sparc64_MATH_H_
    3838
     39#include <acos.h>
     40#include <asin.h>
     41#include <atan.h>
     42#include <atan2.h>
    3943#include <ceil.h>
     44#include <cosh.h>
    4045#include <exp.h>
     46#include <fabs.h>
    4147#include <floor.h>
     48#include <fmod.h>
     49#include <frexp.h>
     50#include <ldexp.h>
    4251#include <log.h>
     52#include <log10.h>
    4353#include <mathtypes.h>
    44 #include <mod.h>
     54#include <modf.h>
    4555#include <pow.h>
     56#include <sinh.h>
     57#include <sqrt.h>
     58#include <tan.h>
     59#include <tanh.h>
     60#include <trig.h>
    4661#include <trunc.h>
    47 #include <trig.h>
     62
     63#define HUGE_VAL FLOAT64_INF
     64
     65static inline float64_t acos_f64(float64_t val)
     66{
     67        return float64_acos(val);
     68}
     69
     70static inline float32_t acos_f32(float32_t val)
     71{
     72        return float32_acos(val);
     73}
     74
     75static inline float64_t asin_f64(float64_t val)
     76{
     77        return float64_asin(val);
     78}
     79
     80static inline float32_t asin_f32(float32_t val)
     81{
     82        return float32_asin(val);
     83}
     84
     85static inline float64_t atan_f64(float64_t val)
     86{
     87        return float64_atan(val);
     88}
     89
     90static inline float32_t atan_f32(float32_t val)
     91{
     92        return float32_atan(val);
     93}
     94
     95static inline float64_t atan2_f64(float64_t y, float64_t x)
     96{
     97        return float64_atan2(y, x);
     98}
     99
     100static inline float32_t atan2_f32(float32_t y, float32_t x)
     101{
     102        return float32_atan2(y, x);
     103}
    48104
    49105static inline float64_t ceil_f64(float64_t val)
    … …  
    67123}
    68124
     125static inline float64_t cosh_f64(float64_t val)
     126{
     127        return float64_cosh(val);
     128}
     129
     130static inline float32_t cosh_f32(float32_t val)
     131{
     132        return float32_cosh(val);
     133}
     134
    69135static inline float64_t exp_f64(float64_t val)
    70136{
    … …  
    77143}
    78144
     145static inline float64_t fabs_f64(float64_t val)
     146{
     147        return float64_fabs(val);
     148}
     149
     150static inline float32_t fabs_f32(float32_t val)
     151{
     152        return float32_fabs(val);
     153}
     154
    79155static inline float64_t floor_f64(float64_t val)
    80156{
    … …  
    86162        return float32_floor(val);
    87163}
    88 
    89164static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    90165{
    91         return float64_mod(dividend, divisor);
     166        return float64_fmod(dividend, divisor);
    92167}
    93168
    94169static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    95170{
    96         return float32_mod(dividend, divisor);
     171        return float32_fmod(dividend, divisor);
     172}
     173
     174static inline float64_t frexp_f64(float64_t x, int *exp)
     175{
     176        return float64_frexp(x, exp);
     177}
     178
     179static inline float64_t frexp_f32(float32_t x, int *exp)
     180{
     181        return float32_frexp(x, exp);
     182}
     183
     184static inline float64_t ldexp_f64(float64_t x, int exp)
     185{
     186        return float64_ldexp(x, exp);
     187}
     188
     189static inline float64_t ldexp_f32(float32_t x, int exp)
     190{
     191        return float32_ldexp(x, exp);
    97192}
    98193
    … …  
    107202}
    108203
     204static inline float64_t log10_f64(float64_t val)
     205{
     206        return float64_log10(val);
     207}
     208
     209static inline float32_t log10_f32(float32_t val)
     210{
     211        return float32_log10(val);
     212}
     213
     214static inline float64_t modf_f64(float64_t value, float64_t *iptr)
     215{
     216        return float64_modf(value, iptr);
     217}
     218
     219static inline float64_t modf_f32(float32_t value, float32_t *iptr)
     220{
     221        return float32_modf(value, iptr);
     222}
     223
    109224static inline float64_t pow_f64(float64_t x, float64_t y)
    110225{
    … …  
    127242}
    128243
     244static inline float64_t sinh_f64(float64_t val)
     245{
     246        return float64_sinh(val);
     247}
     248
     249static inline float32_t sinh_f32(float32_t val)
     250{
     251        return float32_sinh(val);
     252}
     253
     254static inline float64_t sqrt_f64(float64_t val)
     255{
     256        return float64_sqrt(val);
     257}
     258
     259static inline float32_t sqrt_f32(float32_t val)
     260{
     261        return float32_sqrt(val);
     262}
     263
     264static inline float64_t tan_f64(float64_t val)
     265{
     266        return float64_tan(val);
     267}
     268
     269static inline float32_t tan_f32(float32_t val)
     270{
     271        return float32_tan(val);
     272}
     273
     274static inline float64_t tanh_f64(float64_t val)
     275{
     276        return float64_tanh(val);
     277}
     278
     279static inline float32_t tanh_f32(float32_t val)
     280{
     281        return float32_tanh(val);
     282}
     283
    129284static inline float64_t trunc_f64(float64_t val)
    130285{
    … …  
    137292}
    138293
     294static inline float64_t acos(float64_t val)
     295{
     296        return acos_f64(val);
     297}
     298
     299static inline float32_t acosf(float32_t val)
     300{
     301        return acos_f32(val);
     302}
     303
     304static inline float64_t asin(float64_t val)
     305{
     306        return asin_f64(val);
     307}
     308
     309static inline float32_t asinf(float32_t val)
     310{
     311        return asin_f32(val);
     312}
     313
     314static inline float64_t atan(float64_t val)
     315{
     316        return atan_f64(val);
     317}
     318
     319static inline float32_t atanf(float32_t val)
     320{
     321        return atan_f32(val);
     322}
     323
     324static inline float64_t atan2(float64_t y, float64_t x)
     325{
     326        return atan2_f64(y, x);
     327}
     328
     329static inline float32_t atan2f(float32_t y, float32_t x)
     330{
     331        return atan2_f32(y, x);
     332}
     333
    139334static inline float64_t ceil(float64_t val)
    140335{
    … …  
    157352}
    158353
     354static inline float64_t cosh(float64_t val)
     355{
     356        return cosh_f64(val);
     357}
     358
     359static inline float32_t coshf(float32_t val)
     360{
     361        return cosh_f32(val);
     362}
     363
    159364static inline float64_t exp(float64_t val)
    160365{
    … …  
    167372}
    168373
     374static inline float64_t fabs(float64_t val)
     375{
     376        return fabs_f64(val);
     377}
     378
     379static inline float32_t fabsf(float32_t val)
     380{
     381        return fabs_f32(val);
     382}
     383
    169384static inline float64_t floor(float64_t val)
    170385{
    … …  
    187402}
    188403
     404static inline float64_t frexp(float64_t x, int *exp)
     405{
     406        return frexp_f64(x, exp);
     407}
     408
     409static inline float32_t frexpf(float32_t x, int *exp)
     410{
     411        return frexp_f32(x, exp);
     412}
     413
     414static inline float64_t ldexp(float64_t x, int exp)
     415{
     416        return ldexp_f64(x, exp);
     417}
     418
     419static inline float32_t ldexpf(float32_t x, int exp)
     420{
     421        return ldexp_f32(x, exp);
     422}
     423
    189424static inline float64_t log(float64_t val)
    190425{
    … …  
    197432}
    198433
     434static inline float64_t log10(float64_t val)
     435{
     436        return log10_f64(val);
     437}
     438
     439static inline float32_t log10f(float32_t val)
     440{
     441        return log10_f32(val);
     442}
     443
     444static inline float64_t modf(float64_t value, float64_t *iptr)
     445{
     446        return modf_f64(value, iptr);
     447}
     448
     449static inline float32_t modff(float32_t value, float32_t *iptr)
     450{
     451        return modf_f32(value, iptr);
     452}
     453
    199454static inline float64_t pow(float64_t x, float64_t y)
    200455{
    … …  
    215470{
    216471        return sin_f32(val);
     472}
     473
     474static inline float64_t sinh(float64_t val)
     475{
     476        return sinh_f64(val);
     477}
     478
     479static inline float32_t sinhf(float32_t val)
     480{
     481        return sinh_f32(val);
     482}
     483
     484static inline float64_t sqrt(float64_t val)
     485{
     486        return sqrt_f64(val);
     487}
     488
     489static inline float32_t sqrtf(float32_t val)
     490{
     491        return sqrt_f32(val);
     492}
     493
     494static inline float64_t tan(float64_t val)
     495{
     496        return tan_f64(val);
     497}
     498
     499static inline float32_t tanf(float32_t val)
     500{
     501        return tan_f32(val);
     502}
     503
     504static inline float64_t tanh(float64_t val)
     505{
     506        return tanh_f64(val);
     507}
     508
     509static inline float32_t tanhf(float32_t val)
     510{
     511        return tanh_f32(val);
    217512}
    218513

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

    r996dc042 r3b23d05  
    3636#include <exp.h>
    3737#include <math.h>
    38 #include <trunc.h>
    3938
    4039#define TAYLOR_DEGREE_32 13

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

    r996dc042 r3b23d05  
    3333 */
    3434
     35#include <fmod.h>
    3536#include <math.h>
    36 #include <mod.h>
    3737
    3838/** Remainder function (32-bit floating point)
    … …  
    5252 *
    5353 */
    54 float32_t float32_mod(float32_t dividend, float32_t divisor)
     54float32_t float32_fmod(float32_t dividend, float32_t divisor)
    5555{
    5656        // FIXME: replace with exact arithmetics
    … …  
    7777 *
    7878 */
    79 float64_t float64_mod(float64_t dividend, float64_t divisor)
     79float64_t float64_fmod(float64_t dividend, float64_t divisor)
    8080{
    8181        // FIXME: replace with exact arithmetics

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

    r996dc042 r3b23d05  
    3434 */
    3535
    36 #include <exp.h>
    37 #include <log.h>
    3836#include <math.h>
    3937#include <pow.h>

  • uspace/lib/math/include/fmod.h

    r996dc042 r3b23d05  
    3333 */
    3434
    35 #ifndef LIBMATH_MOD_H_
    36 #define LIBMATH_MOD_H_
     35#ifndef LIBMATH_FMOD_H_
     36#define LIBMATH_FMOD_H_
    3737
    38 extern float32_t float32_mod(float32_t, float32_t);
    39 extern float64_t float64_mod(float64_t, float64_t);
     38#include <mathtypes.h>
     39
     40extern float32_t float32_fmod(float32_t, float32_t);
     41extern float64_t float64_fmod(float64_t, float64_t);
    4042
    4143#endif

  • uspace/lib/math/include/math.h

    r996dc042 r3b23d05  
    11/*
    22 * Copyright (c) 2011 Petr Koupy
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    3839#include <libarch/math.h>
    3940
     41#define M_LN10 2.30258509299404568402
    4042#define M_LN2 0.69314718055994530942
    4143#define M_LOG2E 1.4426950408889634074
    4244#define M_PI 3.14159265358979323846
     45#define M_PI_2 1.57079632679489661923
    4346
    4447#endif
Note: See TracChangeset for help on using the changeset viewer.