Changes in / [3b23d05:996dc042] in mainline


Ignore:
Location:
uspace
Files:
2 added
30 deleted
17 edited

Legend:

Unmodified
Added
Removed

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

    r3b23d05 r996dc042  
    4242};
    4343
    44 static 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 
    50 static double arguments_asin[OPERANDS] = {
     44static double arguments_exp[OPERANDS] = {
     45        3.5, -2.1, 50.0, 0.0, 1.0, 13.2, -1.1, -5.5, 0.1, -66.0
     46};
     47
     48static double arguments_log[OPERANDS] = {
     49        3.5, 100.0, 50.0, 768.3156, 1080.499999, 1.0, 66.0,
     50        2.718281828459045, 9.9, 0.001
     51};
     52
     53
     54static double results_ceil[OPERANDS] = {
     55        4.0, -2.0, 100.0, 50.0, -1024.0, 0.0, 769.0, 1081.0, -600.0, 1.0
     56};
     57
     58static double results_floor[OPERANDS] = {
     59        3.0, -3.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
     60};
     61
     62static 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
     64};
     65
     66static double results_sin[OPERANDS] = {
    5167        -0.350783227690, -0.863209366649, -0.506365641110, -0.262374853704,
    5268        0.158533380044, 0.0, 0.980815184715, -0.206379975025, -0.044182448332,
    5369        0.841470984808
    54 };
    55 
    56 static 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 
    61 static double arguments_exp[OPERANDS] = {
    62         3.5, -2.1, 50.0, 0.0, 1.0, 13.2, -1.1, -5.5, 0.1, -66.0
    63 };
    64 
    65 static double arguments_log[OPERANDS] = {
    66         3.5, 100.0, 50.0, 768.3156, 1080.499999, 1.0, 66.0,
    67         2.718281828459045, 9.9, 0.001
    68 };
    69 
    70 static 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 
    75 static 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 
    79 static 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 
    85 static 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 
    91 static 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 };
    96 
    97 static double results_ceil[OPERANDS] = {
    98         4.0, -2.0, 100.0, 50.0, -1024.0, 0.0, 769.0, 1081.0, -600.0, 1.0
    9970};
    10071
    … …  
    10576};
    10677
    107 static 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 
    113 static 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 
    117 static double results_floor[OPERANDS] = {
    118         3.0, -3.0, 100.0, 50.0, -1024.0, 0.0, 768.0, 1080.0, -600.0, 1.0
     78static 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
    11982};
    12083
    … …  
    12386        1.000000000000, 2.718281828459, 540364.937246691552, 0.332871083698,
    12487        0.004086771438, 1.105170918076, 0.000000000000
    125 };
    126 
    127 static 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 
    133 static 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
    137 };
    138 
    139 static double results_sin[OPERANDS] = {
    140         -0.350783227690, -0.863209366649, -0.506365641110, -0.262374853704,
    141         0.158533380044, 0.0, 0.980815184715, -0.206379975025, -0.044182448332,
    142         0.841470984808
    143 };
    144 
    145 static 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 
    151 static 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 
    157 static 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 
    163 static 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 
    169 static 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
    17188};
    17289
    … …  
    208125{
    209126        bool fail = false;
    210 if (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);
     127
     128        for (unsigned int i = 0; i < OPERANDS; i++) {
     129                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);
    267136                        fail = true;
    268137                }
    … …  
    271140        for (unsigned int i = 0; i < OPERANDS; i++) {
    272141                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 
     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);
     148                        fail = true;
     149                }
     150        }
     151
     152        for (unsigned int i = 0; i < OPERANDS; i++) {
     153                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       
    291176        for (unsigned int i = 0; i < OPERANDS; i++) {
    292177                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 
     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       
    331218        for (unsigned int i = 0; i < OPERANDS; i++) {
    332219                double res = exp(arguments_exp[i]);
    333 
     220               
    334221                if (!cmp_double(res, results_exp[i])) {
    335                         TPRINTF("Double precision exp failed "
     222                        TPRINTF("Double precision exponential failed "
    336223                            "(%lf != %lf, arg %u)\n", res, results_exp[i], i);
    337224                        fail = true;
    338225                }
    339226        }
    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         }
    370 
    371         for (unsigned int i = 0; i < OPERANDS; i++) {
    372                 double res = floor(arguments[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);
    527                         fail = true;
    528                 }
    529         }
    530 
    531         for (unsigned int i = 0; i < OPERANDS; i++) {
    532                 double res = trunc(arguments[i]);
    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 
     227       
    551228        if (fail)
    552229                return "Floating point imprecision";
    553 
     230       
    554231        return NULL;
    555232}

  • uspace/app/tester/tester.h

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

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

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

  • uspace/lib/math/Makefile

    r3b23d05 r996dc042  
    4141
    4242GENERIC_SOURCES = \
    43         generic/acos.c \
    44         generic/asin.c \
    45         generic/atan.c \
    46         generic/atan2.c \
    4743        generic/ceil.c \
    48         generic/cosh.c \
    4944        generic/exp.c \
    50         generic/fabs.c \
    5145        generic/floor.c \
    52         generic/fmod.c \
    53         generic/frexp.c \
    54         generic/ldexp.c \
    5546        generic/log.c \
    56         generic/log10.c \
    57         generic/modf.c \
     47        generic/trig.c \
    5848        generic/pow.c \
    59         generic/sinh.c \
    60         generic/sqrt.c \
    61         generic/tan.c \
    62         generic/tanh.c \
    63         generic/trig.c \
     49        generic/mod.c \
    6450        generic/trunc.c
    6551

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_abs32le_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12367}
    12468
    125 static inline float64_t cosh_f64(float64_t val)
    126 {
    127         return float64_cosh(val);
    128 }
    129 
    130 static inline float32_t cosh_f32(float32_t val)
    131 {
    132         return float32_cosh(val);
    133 }
    134 
    13569static inline float64_t exp_f64(float64_t val)
    13670{
    … …  
    14377}
    14478
    145 static inline float64_t fabs_f64(float64_t val)
    146 {
    147         return float64_fabs(val);
    148 }
    149 
    150 static inline float32_t fabs_f32(float32_t val)
    151 {
    152         return float32_fabs(val);
    153 }
    154 
    15579static inline float64_t floor_f64(float64_t val)
    15680{
    … …  
    16286        return float32_floor(val);
    16387}
     88
    16489static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16590{
    166         return float64_fmod(dividend, divisor);
     91        return float64_mod(dividend, divisor);
    16792}
    16893
    16994static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    17095{
    171         return float32_fmod(dividend, divisor);
    172 }
    173 
    174 static inline float64_t frexp_f64(float64_t x, int *exp)
    175 {
    176         return float64_frexp(x, exp);
    177 }
    178 
    179 static inline float64_t frexp_f32(float32_t x, int *exp)
    180 {
    181         return float32_frexp(x, exp);
    182 }
    183 
    184 static inline float64_t ldexp_f64(float64_t x, int exp)
    185 {
    186         return float64_ldexp(x, exp);
    187 }
    188 
    189 static inline float64_t ldexp_f32(float32_t x, int exp)
    190 {
    191         return float32_ldexp(x, exp);
     96        return float32_mod(dividend, divisor);
    19297}
    19398
    … …  
    202107}
    203108
    204 static inline float64_t log10_f64(float64_t val)
    205 {
    206         return float64_log10(val);
    207 }
    208 
    209 static inline float32_t log10_f32(float32_t val)
    210 {
    211         return float32_log10(val);
    212 }
    213 
    214 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    215 {
    216         return float64_modf(value, iptr);
    217 }
    218 
    219 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    220 {
    221         return float32_modf(value, iptr);
    222 }
    223 
    224109static inline float64_t pow_f64(float64_t x, float64_t y)
    225110{
    … …  
    242127}
    243128
    244 static inline float64_t sinh_f64(float64_t val)
    245 {
    246         return float64_sinh(val);
    247 }
    248 
    249 static inline float32_t sinh_f32(float32_t val)
    250 {
    251         return float32_sinh(val);
    252 }
    253 
    254 static inline float64_t sqrt_f64(float64_t val)
    255 {
    256         return float64_sqrt(val);
    257 }
    258 
    259 static inline float32_t sqrt_f32(float32_t val)
    260 {
    261         return float32_sqrt(val);
    262 }
    263 
    264 static inline float64_t tan_f64(float64_t val)
    265 {
    266         return float64_tan(val);
    267 }
    268 
    269 static inline float32_t tan_f32(float32_t val)
    270 {
    271         return float32_tan(val);
    272 }
    273 
    274 static inline float64_t tanh_f64(float64_t val)
    275 {
    276         return float64_tanh(val);
    277 }
    278 
    279 static inline float32_t tanh_f32(float32_t val)
    280 {
    281         return float32_tanh(val);
    282 }
    283 
    284129static inline float64_t trunc_f64(float64_t val)
    285130{
    … …  
    292137}
    293138
    294 static inline float64_t acos(float64_t val)
    295 {
    296         return acos_f64(val);
    297 }
    298 
    299 static inline float32_t acosf(float32_t val)
    300 {
    301         return acos_f32(val);
    302 }
    303 
    304 static inline float64_t asin(float64_t val)
    305 {
    306         return asin_f64(val);
    307 }
    308 
    309 static inline float32_t asinf(float32_t val)
    310 {
    311         return asin_f32(val);
    312 }
    313 
    314 static inline float64_t atan(float64_t val)
    315 {
    316         return atan_f64(val);
    317 }
    318 
    319 static inline float32_t atanf(float32_t val)
    320 {
    321         return atan_f32(val);
    322 }
    323 
    324 static inline float64_t atan2(float64_t y, float64_t x)
    325 {
    326         return atan2_f64(y, x);
    327 }
    328 
    329 static inline float32_t atan2f(float32_t y, float32_t x)
    330 {
    331         return atan2_f32(y, x);
    332 }
    333 
    334139static inline float64_t ceil(float64_t val)
    335140{
    … …  
    352157}
    353158
    354 static inline float64_t cosh(float64_t val)
    355 {
    356         return cosh_f64(val);
    357 }
    358 
    359 static inline float32_t coshf(float32_t val)
    360 {
    361         return cosh_f32(val);
    362 }
    363 
    364159static inline float64_t exp(float64_t val)
    365160{
    … …  
    372167}
    373168
    374 static inline float64_t fabs(float64_t val)
    375 {
    376         return fabs_f64(val);
    377 }
    378 
    379 static inline float32_t fabsf(float32_t val)
    380 {
    381         return fabs_f32(val);
    382 }
    383 
    384169static inline float64_t floor(float64_t val)
    385170{
    … …  
    402187}
    403188
    404 static inline float64_t frexp(float64_t x, int *exp)
    405 {
    406         return frexp_f64(x, exp);
    407 }
    408 
    409 static inline float32_t frexpf(float32_t x, int *exp)
    410 {
    411         return frexp_f32(x, exp);
    412 }
    413 
    414 static inline float64_t ldexp(float64_t x, int exp)
    415 {
    416         return ldexp_f64(x, exp);
    417 }
    418 
    419 static inline float32_t ldexpf(float32_t x, int exp)
    420 {
    421         return ldexp_f32(x, exp);
    422 }
    423 
    424189static inline float64_t log(float64_t val)
    425190{
    … …  
    432197}
    433198
    434 static inline float64_t log10(float64_t val)
    435 {
    436         return log10_f64(val);
    437 }
    438 
    439 static inline float32_t log10f(float32_t val)
    440 {
    441         return log10_f32(val);
    442 }
    443 
    444 static inline float64_t modf(float64_t value, float64_t *iptr)
    445 {
    446         return modf_f64(value, iptr);
    447 }
    448 
    449 static inline float32_t modff(float32_t value, float32_t *iptr)
    450 {
    451         return modf_f32(value, iptr);
    452 }
    453 
    454199static inline float64_t pow(float64_t x, float64_t y)
    455200{
    … …  
    472217}
    473218
    474 static inline float64_t sinh(float64_t val)
    475 {
    476         return sinh_f64(val);
    477 }
    478 
    479 static inline float32_t sinhf(float32_t val)
    480 {
    481         return sinh_f32(val);
    482 }
    483 
    484 static inline float64_t sqrt(float64_t val)
    485 {
    486         return sqrt_f64(val);
    487 }
    488 
    489 static inline float32_t sqrtf(float32_t val)
    490 {
    491         return sqrt_f32(val);
    492 }
    493 
    494 static inline float64_t tan(float64_t val)
    495 {
    496         return tan_f64(val);
    497 }
    498 
    499 static inline float32_t tanf(float32_t val)
    500 {
    501         return tan_f32(val);
    502 }
    503 
    504 static inline float64_t tanh(float64_t val)
    505 {
    506         return tanh_f64(val);
    507 }
    508 
    509 static inline float32_t tanhf(float32_t val)
    510 {
    511         return tanh_f32(val);
    512 }
    513 
    514219static inline float64_t trunc(float64_t val)
    515220{

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_amd64_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12064}
    12165
    122 static inline float64_t cosh_f64(float64_t val)
    123 {
    124         return float64_cosh(val);
    125 }
    126 
    127 static inline float32_t cosh_f32(float32_t val)
    128 {
    129         return float32_cosh(val);
    130 }
    131 
    13266static inline float64_t exp_f64(float64_t val)
    13367{
    … …  
    14074}
    14175
    142 static inline float64_t fabs_f64(float64_t val)
    143 {
    144         return float64_fabs(val);
    145 }
    146 
    147 static inline float32_t fabs_f32(float32_t val)
    148 {
    149         return float32_fabs(val);
    150 }
    151 
    15276static inline float64_t floor_f64(float64_t val)
    15377{
    … …  
    15983        return float32_floor(val);
    16084}
     85
    16186static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16287{
    163         return float64_fmod(dividend, divisor);
     88        return float64_mod(dividend, divisor);
    16489}
    16590
    16691static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    16792{
    168         return float32_fmod(dividend, divisor);
    169 }
    170 
    171 static inline float64_t frexp_f64(float64_t x, int *exp)
    172 {
    173         return float64_frexp(x, exp);
    174 }
    175 
    176 static inline float64_t frexp_f32(float32_t x, int *exp)
    177 {
    178         return float32_frexp(x, exp);
    179 }
    180 
    181 static inline float64_t ldexp_f64(float64_t x, int exp)
    182 {
    183         return float64_ldexp(x, exp);
    184 }
    185 
    186 static inline float64_t ldexp_f32(float32_t x, int exp)
    187 {
    188         return float32_ldexp(x, exp);
     93        return float32_mod(dividend, divisor);
    18994}
    19095
    … …  
    199104}
    200105
    201 static inline float64_t log10_f64(float64_t val)
    202 {
    203         return float64_log10(val);
    204 }
    205 
    206 static inline float32_t log10_f32(float32_t val)
    207 {
    208         return float32_log10(val);
    209 }
    210 
    211 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    212 {
    213         return float64_modf(value, iptr);
    214 }
    215 
    216 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    217 {
    218         return float32_modf(value, iptr);
    219 }
    220 
    221106static inline float64_t pow_f64(float64_t x, float64_t y)
    222107{
    … …  
    236121}
    237122
    238 static inline float64_t sinh_f64(float64_t val)
    239 {
    240         return float64_sinh(val);
    241 }
    242 
    243 static inline float32_t sinh_f32(float32_t val)
    244 {
    245         return float32_sinh(val);
    246 }
    247 
    248 static inline float64_t sqrt_f64(float64_t val)
    249 {
    250         return float64_sqrt(val);
    251 }
    252 
    253 static inline float32_t sqrt_f32(float32_t val)
    254 {
    255         return float32_sqrt(val);
    256 }
    257 
    258 static inline float64_t tan_f64(float64_t val)
    259 {
    260         return float64_tan(val);
    261 }
    262 
    263 static inline float32_t tan_f32(float32_t val)
    264 {
    265         return float32_tan(val);
    266 }
    267 
    268 static inline float64_t tanh_f64(float64_t val)
    269 {
    270         return float64_tanh(val);
    271 }
    272 
    273 static inline float32_t tanh_f32(float32_t val)
    274 {
    275         return float32_tanh(val);
    276 }
    277 
    278123extern float64_t trunc_f64(float64_t);
    279124
    … …  
    283128}
    284129
    285 static inline float64_t acos(float64_t val)
    286 {
    287         return acos_f64(val);
    288 }
    289 
    290 static inline float32_t acosf(float32_t val)
    291 {
    292         return acos_f32(val);
    293 }
    294 
    295 static inline float64_t asin(float64_t val)
    296 {
    297         return asin_f64(val);
    298 }
    299 
    300 static inline float32_t asinf(float32_t val)
    301 {
    302         return asin_f32(val);
    303 }
    304 
    305 static inline float64_t atan(float64_t val)
    306 {
    307         return atan_f64(val);
    308 }
    309 
    310 static inline float32_t atanf(float32_t val)
    311 {
    312         return atan_f32(val);
    313 }
    314 
    315 static inline float64_t atan2(float64_t y, float64_t x)
    316 {
    317         return atan2_f64(y, x);
    318 }
    319 
    320 static inline float32_t atan2f(float32_t y, float32_t x)
    321 {
    322         return atan2_f32(y, x);
    323 }
    324 
    325130static inline float64_t ceil(float64_t val)
    326131{
    … …  
    343148}
    344149
    345 static inline float64_t cosh(float64_t val)
    346 {
    347         return cosh_f64(val);
    348 }
    349 
    350 static inline float32_t coshf(float32_t val)
    351 {
    352         return cosh_f32(val);
    353 }
    354 
    355150static inline float64_t exp(float64_t val)
    356151{
    … …  
    363158}
    364159
    365 static inline float64_t fabs(float64_t val)
    366 {
    367         return fabs_f64(val);
    368 }
    369 
    370 static inline float32_t fabsf(float32_t val)
    371 {
    372         return fabs_f32(val);
    373 }
    374 
    375160static inline float64_t floor(float64_t val)
    376161{
    … …  
    393178}
    394179
    395 static inline float64_t frexp(float64_t x, int *exp)
    396 {
    397         return frexp_f64(x, exp);
    398 }
    399 
    400 static inline float32_t frexpf(float32_t x, int *exp)
    401 {
    402         return frexp_f32(x, exp);
    403 }
    404 
    405 static inline float64_t ldexp(float64_t x, int exp)
    406 {
    407         return ldexp_f64(x, exp);
    408 }
    409 
    410 static inline float32_t ldexpf(float32_t x, int exp)
    411 {
    412         return ldexp_f32(x, exp);
    413 }
    414 
    415180static inline float64_t log(float64_t val)
    416181{
    … …  
    423188}
    424189
    425 static inline float64_t log10(float64_t val)
    426 {
    427         return log10_f64(val);
    428 }
    429 
    430 static inline float32_t log10f(float32_t val)
    431 {
    432         return log10_f32(val);
    433 }
    434 
    435 static inline float64_t modf(float64_t value, float64_t *iptr)
    436 {
    437         return modf_f64(value, iptr);
    438 }
    439 
    440 static inline float32_t modff(float32_t value, float32_t *iptr)
    441 {
    442         return modf_f32(value, iptr);
    443 }
    444 
    445190static inline float64_t pow(float64_t x, float64_t y)
    446191{
    … …  
    463208}
    464209
    465 static inline float64_t sinh(float64_t val)
    466 {
    467         return sinh_f64(val);
    468 }
    469 
    470 static inline float32_t sinhf(float32_t val)
    471 {
    472         return sinh_f32(val);
    473 }
    474 
    475 static inline float64_t sqrt(float64_t val)
    476 {
    477         return sqrt_f64(val);
    478 }
    479 
    480 static inline float32_t sqrtf(float32_t val)
    481 {
    482         return sqrt_f32(val);
    483 }
    484 
    485 static inline float64_t tan(float64_t val)
    486 {
    487         return tan_f64(val);
    488 }
    489 
    490 static inline float32_t tanf(float32_t val)
    491 {
    492         return tan_f32(val);
    493 }
    494 
    495 static inline float64_t tanh(float64_t val)
    496 {
    497         return tanh_f64(val);
    498 }
    499 
    500 static inline float32_t tanhf(float32_t val)
    501 {
    502         return tanh_f32(val);
    503 }
    504 
    505210static inline float64_t trunc(float64_t val)
    506211{

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_arm32_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12367}
    12468
    125 static inline float64_t cosh_f64(float64_t val)
    126 {
    127         return float64_cosh(val);
    128 }
    129 
    130 static inline float32_t cosh_f32(float32_t val)
    131 {
    132         return float32_cosh(val);
    133 }
    134 
    13569static inline float64_t exp_f64(float64_t val)
    13670{
    … …  
    14377}
    14478
    145 static inline float64_t fabs_f64(float64_t val)
    146 {
    147         return float64_fabs(val);
    148 }
    149 
    150 static inline float32_t fabs_f32(float32_t val)
    151 {
    152         return float32_fabs(val);
    153 }
    154 
    15579static inline float64_t floor_f64(float64_t val)
    15680{
    … …  
    16286        return float32_floor(val);
    16387}
     88
    16489static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16590{
    166         return float64_fmod(dividend, divisor);
     91        return float64_mod(dividend, divisor);
    16792}
    16893
    16994static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    17095{
    171         return float32_fmod(dividend, divisor);
    172 }
    173 
    174 static inline float64_t frexp_f64(float64_t x, int *exp)
    175 {
    176         return float64_frexp(x, exp);
    177 }
    178 
    179 static inline float64_t frexp_f32(float32_t x, int *exp)
    180 {
    181         return float32_frexp(x, exp);
    182 }
    183 
    184 static inline float64_t ldexp_f64(float64_t x, int exp)
    185 {
    186         return float64_ldexp(x, exp);
    187 }
    188 
    189 static inline float64_t ldexp_f32(float32_t x, int exp)
    190 {
    191         return float32_ldexp(x, exp);
     96        return float32_mod(dividend, divisor);
    19297}
    19398
    … …  
    202107}
    203108
    204 static inline float64_t log10_f64(float64_t val)
    205 {
    206         return float64_log10(val);
    207 }
    208 
    209 static inline float32_t log10_f32(float32_t val)
    210 {
    211         return float32_log10(val);
    212 }
    213 
    214 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    215 {
    216         return float64_modf(value, iptr);
    217 }
    218 
    219 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    220 {
    221         return float32_modf(value, iptr);
    222 }
    223 
    224109static inline float64_t pow_f64(float64_t x, float64_t y)
    225110{
    … …  
    242127}
    243128
    244 static inline float64_t sinh_f64(float64_t val)
    245 {
    246         return float64_sinh(val);
    247 }
    248 
    249 static inline float32_t sinh_f32(float32_t val)
    250 {
    251         return float32_sinh(val);
    252 }
    253 
    254 static inline float64_t sqrt_f64(float64_t val)
    255 {
    256         return float64_sqrt(val);
    257 }
    258 
    259 static inline float32_t sqrt_f32(float32_t val)
    260 {
    261         return float32_sqrt(val);
    262 }
    263 
    264 static inline float64_t tan_f64(float64_t val)
    265 {
    266         return float64_tan(val);
    267 }
    268 
    269 static inline float32_t tan_f32(float32_t val)
    270 {
    271         return float32_tan(val);
    272 }
    273 
    274 static inline float64_t tanh_f64(float64_t val)
    275 {
    276         return float64_tanh(val);
    277 }
    278 
    279 static inline float32_t tanh_f32(float32_t val)
    280 {
    281         return float32_tanh(val);
    282 }
    283 
    284129static inline float64_t trunc_f64(float64_t val)
    285130{
    … …  
    292137}
    293138
    294 static inline float64_t acos(float64_t val)
    295 {
    296         return acos_f64(val);
    297 }
    298 
    299 static inline float32_t acosf(float32_t val)
    300 {
    301         return acos_f32(val);
    302 }
    303 
    304 static inline float64_t asin(float64_t val)
    305 {
    306         return asin_f64(val);
    307 }
    308 
    309 static inline float32_t asinf(float32_t val)
    310 {
    311         return asin_f32(val);
    312 }
    313 
    314 static inline float64_t atan(float64_t val)
    315 {
    316         return atan_f64(val);
    317 }
    318 
    319 static inline float32_t atanf(float32_t val)
    320 {
    321         return atan_f32(val);
    322 }
    323 
    324 static inline float64_t atan2(float64_t y, float64_t x)
    325 {
    326         return atan2_f64(y, x);
    327 }
    328 
    329 static inline float32_t atan2f(float32_t y, float32_t x)
    330 {
    331         return atan2_f32(y, x);
    332 }
    333 
    334139static inline float64_t ceil(float64_t val)
    335140{
    … …  
    352157}
    353158
    354 static inline float64_t cosh(float64_t val)
    355 {
    356         return cosh_f64(val);
    357 }
    358 
    359 static inline float32_t coshf(float32_t val)
    360 {
    361         return cosh_f32(val);
    362 }
    363 
    364159static inline float64_t exp(float64_t val)
    365160{
    … …  
    372167}
    373168
    374 static inline float64_t fabs(float64_t val)
    375 {
    376         return fabs_f64(val);
    377 }
    378 
    379 static inline float32_t fabsf(float32_t val)
    380 {
    381         return fabs_f32(val);
    382 }
    383 
    384169static inline float64_t floor(float64_t val)
    385170{
    … …  
    402187}
    403188
    404 static inline float64_t frexp(float64_t x, int *exp)
    405 {
    406         return frexp_f64(x, exp);
    407 }
    408 
    409 static inline float32_t frexpf(float32_t x, int *exp)
    410 {
    411         return frexp_f32(x, exp);
    412 }
    413 
    414 static inline float64_t ldexp(float64_t x, int exp)
    415 {
    416         return ldexp_f64(x, exp);
    417 }
    418 
    419 static inline float32_t ldexpf(float32_t x, int exp)
    420 {
    421         return ldexp_f32(x, exp);
    422 }
    423 
    424189static inline float64_t log(float64_t val)
    425190{
    … …  
    432197}
    433198
    434 static inline float64_t log10(float64_t val)
    435 {
    436         return log10_f64(val);
    437 }
    438 
    439 static inline float32_t log10f(float32_t val)
    440 {
    441         return log10_f32(val);
    442 }
    443 
    444 static inline float64_t modf(float64_t value, float64_t *iptr)
    445 {
    446         return modf_f64(value, iptr);
    447 }
    448 
    449 static inline float32_t modff(float32_t value, float32_t *iptr)
    450 {
    451         return modf_f32(value, iptr);
    452 }
    453 
    454199static inline float64_t pow(float64_t x, float64_t y)
    455200{
    … …  
    472217}
    473218
    474 static inline float64_t sinh(float64_t val)
    475 {
    476         return sinh_f64(val);
    477 }
    478 
    479 static inline float32_t sinhf(float32_t val)
    480 {
    481         return sinh_f32(val);
    482 }
    483 
    484 static inline float64_t sqrt(float64_t val)
    485 {
    486         return sqrt_f64(val);
    487 }
    488 
    489 static inline float32_t sqrtf(float32_t val)
    490 {
    491         return sqrt_f32(val);
    492 }
    493 
    494 static inline float64_t tan(float64_t val)
    495 {
    496         return tan_f64(val);
    497 }
    498 
    499 static inline float32_t tanf(float32_t val)
    500 {
    501         return tan_f32(val);
    502 }
    503 
    504 static inline float64_t tanh(float64_t val)
    505 {
    506         return tanh_f64(val);
    507 }
    508 
    509 static inline float32_t tanhf(float32_t val)
    510 {
    511         return tanh_f32(val);
    512 }
    513 
    514219static inline float64_t trunc(float64_t val)
    515220{

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_ia32_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12064}
    12165
    122 static inline float64_t cosh_f64(float64_t val)
    123 {
    124         return float64_cosh(val);
    125 }
    126 
    127 static inline float32_t cosh_f32(float32_t val)
    128 {
    129         return float32_cosh(val);
    130 }
    131 
    13266static inline float64_t exp_f64(float64_t val)
    13367{
    … …  
    14074}
    14175
    142 static inline float64_t fabs_f64(float64_t val)
    143 {
    144         return float64_fabs(val);
    145 }
    146 
    147 static inline float32_t fabs_f32(float32_t val)
    148 {
    149         return float32_fabs(val);
    150 }
    151 
    15276static inline float64_t floor_f64(float64_t val)
    15377{
    … …  
    15983        return float32_floor(val);
    16084}
     85
    16186static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16287{
    163         return float64_fmod(dividend, divisor);
     88        return float64_mod(dividend, divisor);
    16489}
    16590
    16691static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    16792{
    168         return float32_fmod(dividend, divisor);
    169 }
    170 
    171 static inline float64_t frexp_f64(float64_t x, int *exp)
    172 {
    173         return float64_frexp(x, exp);
    174 }
    175 
    176 static inline float64_t frexp_f32(float32_t x, int *exp)
    177 {
    178         return float32_frexp(x, exp);
    179 }
    180 
    181 static inline float64_t ldexp_f64(float64_t x, int exp)
    182 {
    183         return float64_ldexp(x, exp);
    184 }
    185 
    186 static inline float64_t ldexp_f32(float32_t x, int exp)
    187 {
    188         return float32_ldexp(x, exp);
     93        return float32_mod(dividend, divisor);
    18994}
    19095
    … …  
    199104}
    200105
    201 static inline float64_t log10_f64(float64_t val)
    202 {
    203         return float64_log10(val);
    204 }
    205 
    206 static inline float32_t log10_f32(float32_t val)
    207 {
    208         return float32_log10(val);
    209 }
    210 
    211 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    212 {
    213         return float64_modf(value, iptr);
    214 }
    215 
    216 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    217 {
    218         return float32_modf(value, iptr);
    219 }
    220 
    221106static inline float64_t pow_f64(float64_t x, float64_t y)
    222107{
    … …  
    236121}
    237122
    238 static inline float64_t sinh_f64(float64_t val)
    239 {
    240         return float64_sinh(val);
    241 }
    242 
    243 static inline float32_t sinh_f32(float32_t val)
    244 {
    245         return float32_sinh(val);
    246 }
    247 
    248 static inline float64_t sqrt_f64(float64_t val)
    249 {
    250         return float64_sqrt(val);
    251 }
    252 
    253 static inline float32_t sqrt_f32(float32_t val)
    254 {
    255         return float32_sqrt(val);
    256 }
    257 
    258 static inline float64_t tan_f64(float64_t val)
    259 {
    260         return float64_tan(val);
    261 }
    262 
    263 static inline float32_t tan_f32(float32_t val)
    264 {
    265         return float32_tan(val);
    266 }
    267 
    268 static inline float64_t tanh_f64(float64_t val)
    269 {
    270         return float64_tanh(val);
    271 }
    272 
    273 static inline float32_t tanh_f32(float32_t val)
    274 {
    275         return float32_tanh(val);
    276 }
    277 
    278123extern float64_t trunc_f64(float64_t);
    279124
    … …  
    283128}
    284129
    285 static inline float64_t acos(float64_t val)
    286 {
    287         return acos_f64(val);
    288 }
    289 
    290 static inline float32_t acosf(float32_t val)
    291 {
    292         return acos_f32(val);
    293 }
    294 
    295 static inline float64_t asin(float64_t val)
    296 {
    297         return asin_f64(val);
    298 }
    299 
    300 static inline float32_t asinf(float32_t val)
    301 {
    302         return asin_f32(val);
    303 }
    304 
    305 static inline float64_t atan(float64_t val)
    306 {
    307         return atan_f64(val);
    308 }
    309 
    310 static inline float32_t atanf(float32_t val)
    311 {
    312         return atan_f32(val);
    313 }
    314 
    315 static inline float64_t atan2(float64_t y, float64_t x)
    316 {
    317         return atan2_f64(y, x);
    318 }
    319 
    320 static inline float32_t atan2f(float32_t y, float32_t x)
    321 {
    322         return atan2_f32(y, x);
    323 }
    324 
    325130static inline float64_t ceil(float64_t val)
    326131{
    … …  
    343148}
    344149
    345 static inline float64_t cosh(float64_t val)
    346 {
    347         return cosh_f64(val);
    348 }
    349 
    350 static inline float32_t coshf(float32_t val)
    351 {
    352         return cosh_f32(val);
    353 }
    354 
    355150static inline float64_t exp(float64_t val)
    356151{
    … …  
    363158}
    364159
    365 static inline float64_t fabs(float64_t val)
    366 {
    367         return fabs_f64(val);
    368 }
    369 
    370 static inline float32_t fabsf(float32_t val)
    371 {
    372         return fabs_f32(val);
    373 }
    374 
    375160static inline float64_t floor(float64_t val)
    376161{
    … …  
    393178}
    394179
    395 static inline float64_t frexp(float64_t x, int *exp)
    396 {
    397         return frexp_f64(x, exp);
    398 }
    399 
    400 static inline float32_t frexpf(float32_t x, int *exp)
    401 {
    402         return frexp_f32(x, exp);
    403 }
    404 
    405 static inline float64_t ldexp(float64_t x, int exp)
    406 {
    407         return ldexp_f64(x, exp);
    408 }
    409 
    410 static inline float32_t ldexpf(float32_t x, int exp)
    411 {
    412         return ldexp_f32(x, exp);
    413 }
    414 
    415180static inline float64_t log(float64_t val)
    416181{
    … …  
    423188}
    424189
    425 static inline float64_t log10(float64_t val)
    426 {
    427         return log10_f64(val);
    428 }
    429 
    430 static inline float32_t log10f(float32_t val)
    431 {
    432         return log10_f32(val);
    433 }
    434 
    435 static inline float64_t modf(float64_t value, float64_t *iptr)
    436 {
    437         return modf_f64(value, iptr);
    438 }
    439 
    440 static inline float32_t modff(float32_t value, float32_t *iptr)
    441 {
    442         return modf_f32(value, iptr);
    443 }
    444 
    445190static inline float64_t pow(float64_t x, float64_t y)
    446191{
    … …  
    463208}
    464209
    465 static inline float64_t sinh(float64_t val)
    466 {
    467         return sinh_f64(val);
    468 }
    469 
    470 static inline float32_t sinhf(float32_t val)
    471 {
    472         return sinh_f32(val);
    473 }
    474 
    475 static inline float64_t sqrt(float64_t val)
    476 {
    477         return sqrt_f64(val);
    478 }
    479 
    480 static inline float32_t sqrtf(float32_t val)
    481 {
    482         return sqrt_f32(val);
    483 }
    484 
    485 static inline float64_t tan(float64_t val)
    486 {
    487         return tan_f64(val);
    488 }
    489 
    490 static inline float32_t tanf(float32_t val)
    491 {
    492         return tan_f32(val);
    493 }
    494 
    495 static inline float64_t tanh(float64_t val)
    496 {
    497         return tanh_f64(val);
    498 }
    499 
    500 static inline float32_t tanhf(float32_t val)
    501 {
    502         return tanh_f32(val);
    503 }
    504 
    505210static inline float64_t trunc(float64_t val)
    506211{

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_ia64_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12367}
    12468
    125 static inline float64_t cosh_f64(float64_t val)
    126 {
    127         return float64_cosh(val);
    128 }
    129 
    130 static inline float32_t cosh_f32(float32_t val)
    131 {
    132         return float32_cosh(val);
    133 }
    134 
    13569static inline float64_t exp_f64(float64_t val)
    13670{
    … …  
    14377}
    14478
    145 static inline float64_t fabs_f64(float64_t val)
    146 {
    147         return float64_fabs(val);
    148 }
    149 
    150 static inline float32_t fabs_f32(float32_t val)
    151 {
    152         return float32_fabs(val);
    153 }
    154 
    15579static inline float64_t floor_f64(float64_t val)
    15680{
    … …  
    16286        return float32_floor(val);
    16387}
     88
    16489static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16590{
    166         return float64_fmod(dividend, divisor);
     91        return float64_mod(dividend, divisor);
    16792}
    16893
    16994static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    17095{
    171         return float32_fmod(dividend, divisor);
    172 }
    173 
    174 static inline float64_t frexp_f64(float64_t x, int *exp)
    175 {
    176         return float64_frexp(x, exp);
    177 }
    178 
    179 static inline float64_t frexp_f32(float32_t x, int *exp)
    180 {
    181         return float32_frexp(x, exp);
    182 }
    183 
    184 static inline float64_t ldexp_f64(float64_t x, int exp)
    185 {
    186         return float64_ldexp(x, exp);
    187 }
    188 
    189 static inline float64_t ldexp_f32(float32_t x, int exp)
    190 {
    191         return float32_ldexp(x, exp);
     96        return float32_mod(dividend, divisor);
    19297}
    19398
    … …  
    202107}
    203108
    204 static inline float64_t log10_f64(float64_t val)
    205 {
    206         return float64_log10(val);
    207 }
    208 
    209 static inline float32_t log10_f32(float32_t val)
    210 {
    211         return float32_log10(val);
    212 }
    213 
    214 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    215 {
    216         return float64_modf(value, iptr);
    217 }
    218 
    219 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    220 {
    221         return float32_modf(value, iptr);
    222 }
    223 
    224109static inline float64_t pow_f64(float64_t x, float64_t y)
    225110{
    … …  
    242127}
    243128
    244 static inline float64_t sinh_f64(float64_t val)
    245 {
    246         return float64_sinh(val);
    247 }
    248 
    249 static inline float32_t sinh_f32(float32_t val)
    250 {
    251         return float32_sinh(val);
    252 }
    253 
    254 static inline float64_t sqrt_f64(float64_t val)
    255 {
    256         return float64_sqrt(val);
    257 }
    258 
    259 static inline float32_t sqrt_f32(float32_t val)
    260 {
    261         return float32_sqrt(val);
    262 }
    263 
    264 static inline float64_t tan_f64(float64_t val)
    265 {
    266         return float64_tan(val);
    267 }
    268 
    269 static inline float32_t tan_f32(float32_t val)
    270 {
    271         return float32_tan(val);
    272 }
    273 
    274 static inline float64_t tanh_f64(float64_t val)
    275 {
    276         return float64_tanh(val);
    277 }
    278 
    279 static inline float32_t tanh_f32(float32_t val)
    280 {
    281         return float32_tanh(val);
    282 }
    283 
    284129static inline float64_t trunc_f64(float64_t val)
    285130{
    … …  
    292137}
    293138
    294 static inline float64_t acos(float64_t val)
    295 {
    296         return acos_f64(val);
    297 }
    298 
    299 static inline float32_t acosf(float32_t val)
    300 {
    301         return acos_f32(val);
    302 }
    303 
    304 static inline float64_t asin(float64_t val)
    305 {
    306         return asin_f64(val);
    307 }
    308 
    309 static inline float32_t asinf(float32_t val)
    310 {
    311         return asin_f32(val);
    312 }
    313 
    314 static inline float64_t atan(float64_t val)
    315 {
    316         return atan_f64(val);
    317 }
    318 
    319 static inline float32_t atanf(float32_t val)
    320 {
    321         return atan_f32(val);
    322 }
    323 
    324 static inline float64_t atan2(float64_t y, float64_t x)
    325 {
    326         return atan2_f64(y, x);
    327 }
    328 
    329 static inline float32_t atan2f(float32_t y, float32_t x)
    330 {
    331         return atan2_f32(y, x);
    332 }
    333 
    334139static inline float64_t ceil(float64_t val)
    335140{
    … …  
    352157}
    353158
    354 static inline float64_t cosh(float64_t val)
    355 {
    356         return cosh_f64(val);
    357 }
    358 
    359 static inline float32_t coshf(float32_t val)
    360 {
    361         return cosh_f32(val);
    362 }
    363 
    364159static inline float64_t exp(float64_t val)
    365160{
    … …  
    372167}
    373168
    374 static inline float64_t fabs(float64_t val)
    375 {
    376         return fabs_f64(val);
    377 }
    378 
    379 static inline float32_t fabsf(float32_t val)
    380 {
    381         return fabs_f32(val);
    382 }
    383 
    384169static inline float64_t floor(float64_t val)
    385170{
    … …  
    402187}
    403188
    404 static inline float64_t frexp(float64_t x, int *exp)
    405 {
    406         return frexp_f64(x, exp);
    407 }
    408 
    409 static inline float32_t frexpf(float32_t x, int *exp)
    410 {
    411         return frexp_f32(x, exp);
    412 }
    413 
    414 static inline float64_t ldexp(float64_t x, int exp)
    415 {
    416         return ldexp_f64(x, exp);
    417 }
    418 
    419 static inline float32_t ldexpf(float32_t x, int exp)
    420 {
    421         return ldexp_f32(x, exp);
    422 }
    423 
    424189static inline float64_t log(float64_t val)
    425190{
    … …  
    432197}
    433198
    434 static inline float64_t log10(float64_t val)
    435 {
    436         return log10_f64(val);
    437 }
    438 
    439 static inline float32_t log10f(float32_t val)
    440 {
    441         return log10_f32(val);
    442 }
    443 
    444 static inline float64_t modf(float64_t value, float64_t *iptr)
    445 {
    446         return modf_f64(value, iptr);
    447 }
    448 
    449 static inline float32_t modff(float32_t value, float32_t *iptr)
    450 {
    451         return modf_f32(value, iptr);
    452 }
    453 
    454199static inline float64_t pow(float64_t x, float64_t y)
    455200{
    … …  
    472217}
    473218
    474 static inline float64_t sinh(float64_t val)
    475 {
    476         return sinh_f64(val);
    477 }
    478 
    479 static inline float32_t sinhf(float32_t val)
    480 {
    481         return sinh_f32(val);
    482 }
    483 
    484 static inline float64_t sqrt(float64_t val)
    485 {
    486         return sqrt_f64(val);
    487 }
    488 
    489 static inline float32_t sqrtf(float32_t val)
    490 {
    491         return sqrt_f32(val);
    492 }
    493 
    494 static inline float64_t tan(float64_t val)
    495 {
    496         return tan_f64(val);
    497 }
    498 
    499 static inline float32_t tanf(float32_t val)
    500 {
    501         return tan_f32(val);
    502 }
    503 
    504 static inline float64_t tanh(float64_t val)
    505 {
    506         return tanh_f64(val);
    507 }
    508 
    509 static inline float32_t tanhf(float32_t val)
    510 {
    511         return tanh_f32(val);
    512 }
    513 
    514219static inline float64_t trunc(float64_t val)
    515220{

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_mips32_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12367}
    12468
    125 static inline float64_t cosh_f64(float64_t val)
    126 {
    127         return float64_cosh(val);
    128 }
    129 
    130 static inline float32_t cosh_f32(float32_t val)
    131 {
    132         return float32_cosh(val);
    133 }
    134 
    13569static inline float64_t exp_f64(float64_t val)
    13670{
    … …  
    14377}
    14478
    145 static inline float64_t fabs_f64(float64_t val)
    146 {
    147         return float64_fabs(val);
    148 }
    149 
    150 static inline float32_t fabs_f32(float32_t val)
    151 {
    152         return float32_fabs(val);
    153 }
    154 
    15579static inline float64_t floor_f64(float64_t val)
    15680{
    … …  
    16286        return float32_floor(val);
    16387}
     88
    16489static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16590{
    166         return float64_fmod(dividend, divisor);
     91        return float64_mod(dividend, divisor);
    16792}
    16893
    16994static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    17095{
    171         return float32_fmod(dividend, divisor);
    172 }
    173 
    174 static inline float64_t frexp_f64(float64_t x, int *exp)
    175 {
    176         return float64_frexp(x, exp);
    177 }
    178 
    179 static inline float64_t frexp_f32(float32_t x, int *exp)
    180 {
    181         return float32_frexp(x, exp);
    182 }
    183 
    184 static inline float64_t ldexp_f64(float64_t x, int exp)
    185 {
    186         return float64_ldexp(x, exp);
    187 }
    188 
    189 static inline float64_t ldexp_f32(float32_t x, int exp)
    190 {
    191         return float32_ldexp(x, exp);
     96        return float32_mod(dividend, divisor);
    19297}
    19398
    … …  
    202107}
    203108
    204 static inline float64_t log10_f64(float64_t val)
    205 {
    206         return float64_log10(val);
    207 }
    208 
    209 static inline float32_t log10_f32(float32_t val)
    210 {
    211         return float32_log10(val);
    212 }
    213 
    214 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    215 {
    216         return float64_modf(value, iptr);
    217 }
    218 
    219 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    220 {
    221         return float32_modf(value, iptr);
    222 }
    223 
    224109static inline float64_t pow_f64(float64_t x, float64_t y)
    225110{
    … …  
    242127}
    243128
    244 static inline float64_t sinh_f64(float64_t val)
    245 {
    246         return float64_sinh(val);
    247 }
    248 
    249 static inline float32_t sinh_f32(float32_t val)
    250 {
    251         return float32_sinh(val);
    252 }
    253 
    254 static inline float64_t sqrt_f64(float64_t val)
    255 {
    256         return float64_sqrt(val);
    257 }
    258 
    259 static inline float32_t sqrt_f32(float32_t val)
    260 {
    261         return float32_sqrt(val);
    262 }
    263 
    264 static inline float64_t tan_f64(float64_t val)
    265 {
    266         return float64_tan(val);
    267 }
    268 
    269 static inline float32_t tan_f32(float32_t val)
    270 {
    271         return float32_tan(val);
    272 }
    273 
    274 static inline float64_t tanh_f64(float64_t val)
    275 {
    276         return float64_tanh(val);
    277 }
    278 
    279 static inline float32_t tanh_f32(float32_t val)
    280 {
    281         return float32_tanh(val);
    282 }
    283 
    284129static inline float64_t trunc_f64(float64_t val)
    285130{
    … …  
    292137}
    293138
    294 static inline float64_t acos(float64_t val)
    295 {
    296         return acos_f64(val);
    297 }
    298 
    299 static inline float32_t acosf(float32_t val)
    300 {
    301         return acos_f32(val);
    302 }
    303 
    304 static inline float64_t asin(float64_t val)
    305 {
    306         return asin_f64(val);
    307 }
    308 
    309 static inline float32_t asinf(float32_t val)
    310 {
    311         return asin_f32(val);
    312 }
    313 
    314 static inline float64_t atan(float64_t val)
    315 {
    316         return atan_f64(val);
    317 }
    318 
    319 static inline float32_t atanf(float32_t val)
    320 {
    321         return atan_f32(val);
    322 }
    323 
    324 static inline float64_t atan2(float64_t y, float64_t x)
    325 {
    326         return atan2_f64(y, x);
    327 }
    328 
    329 static inline float32_t atan2f(float32_t y, float32_t x)
    330 {
    331         return atan2_f32(y, x);
    332 }
    333 
    334139static inline float64_t ceil(float64_t val)
    335140{
    … …  
    352157}
    353158
    354 static inline float64_t cosh(float64_t val)
    355 {
    356         return cosh_f64(val);
    357 }
    358 
    359 static inline float32_t coshf(float32_t val)
    360 {
    361         return cosh_f32(val);
    362 }
    363 
    364159static inline float64_t exp(float64_t val)
    365160{
    … …  
    372167}
    373168
    374 static inline float64_t fabs(float64_t val)
    375 {
    376         return fabs_f64(val);
    377 }
    378 
    379 static inline float32_t fabsf(float32_t val)
    380 {
    381         return fabs_f32(val);
    382 }
    383 
    384169static inline float64_t floor(float64_t val)
    385170{
    … …  
    402187}
    403188
    404 static inline float64_t frexp(float64_t x, int *exp)
    405 {
    406         return frexp_f64(x, exp);
    407 }
    408 
    409 static inline float32_t frexpf(float32_t x, int *exp)
    410 {
    411         return frexp_f32(x, exp);
    412 }
    413 
    414 static inline float64_t ldexp(float64_t x, int exp)
    415 {
    416         return ldexp_f64(x, exp);
    417 }
    418 
    419 static inline float32_t ldexpf(float32_t x, int exp)
    420 {
    421         return ldexp_f32(x, exp);
    422 }
    423 
    424189static inline float64_t log(float64_t val)
    425190{
    … …  
    432197}
    433198
    434 static inline float64_t log10(float64_t val)
    435 {
    436         return log10_f64(val);
    437 }
    438 
    439 static inline float32_t log10f(float32_t val)
    440 {
    441         return log10_f32(val);
    442 }
    443 
    444 static inline float64_t modf(float64_t value, float64_t *iptr)
    445 {
    446         return modf_f64(value, iptr);
    447 }
    448 
    449 static inline float32_t modff(float32_t value, float32_t *iptr)
    450 {
    451         return modf_f32(value, iptr);
    452 }
    453 
    454199static inline float64_t pow(float64_t x, float64_t y)
    455200{
    … …  
    472217}
    473218
    474 static inline float64_t sinh(float64_t val)
    475 {
    476         return sinh_f64(val);
    477 }
    478 
    479 static inline float32_t sinhf(float32_t val)
    480 {
    481         return sinh_f32(val);
    482 }
    483 
    484 static inline float64_t sqrt(float64_t val)
    485 {
    486         return sqrt_f64(val);
    487 }
    488 
    489 static inline float32_t sqrtf(float32_t val)
    490 {
    491         return sqrt_f32(val);
    492 }
    493 
    494 static inline float64_t tan(float64_t val)
    495 {
    496         return tan_f64(val);
    497 }
    498 
    499 static inline float32_t tanf(float32_t val)
    500 {
    501         return tan_f32(val);
    502 }
    503 
    504 static inline float64_t tanh(float64_t val)
    505 {
    506         return tanh_f64(val);
    507 }
    508 
    509 static inline float32_t tanhf(float32_t val)
    510 {
    511         return tanh_f32(val);
    512 }
    513 
    514219static inline float64_t trunc(float64_t val)
    515220{

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_mips32eb_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12367}
    12468
    125 static inline float64_t cosh_f64(float64_t val)
    126 {
    127         return float64_cosh(val);
    128 }
    129 
    130 static inline float32_t cosh_f32(float32_t val)
    131 {
    132         return float32_cosh(val);
    133 }
    134 
    13569static inline float64_t exp_f64(float64_t val)
    13670{
    … …  
    14377}
    14478
    145 static inline float64_t fabs_f64(float64_t val)
    146 {
    147         return float64_fabs(val);
    148 }
    149 
    150 static inline float32_t fabs_f32(float32_t val)
    151 {
    152         return float32_fabs(val);
    153 }
    154 
    15579static inline float64_t floor_f64(float64_t val)
    15680{
    … …  
    16286        return float32_floor(val);
    16387}
     88
    16489static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16590{
    166         return float64_fmod(dividend, divisor);
     91        return float64_mod(dividend, divisor);
    16792}
    16893
    16994static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    17095{
    171         return float32_fmod(dividend, divisor);
    172 }
    173 
    174 static inline float64_t frexp_f64(float64_t x, int *exp)
    175 {
    176         return float64_frexp(x, exp);
    177 }
    178 
    179 static inline float64_t frexp_f32(float32_t x, int *exp)
    180 {
    181         return float32_frexp(x, exp);
    182 }
    183 
    184 static inline float64_t ldexp_f64(float64_t x, int exp)
    185 {
    186         return float64_ldexp(x, exp);
    187 }
    188 
    189 static inline float64_t ldexp_f32(float32_t x, int exp)
    190 {
    191         return float32_ldexp(x, exp);
     96        return float32_mod(dividend, divisor);
    19297}
    19398
    … …  
    202107}
    203108
    204 static inline float64_t log10_f64(float64_t val)
    205 {
    206         return float64_log10(val);
    207 }
    208 
    209 static inline float32_t log10_f32(float32_t val)
    210 {
    211         return float32_log10(val);
    212 }
    213 
    214 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    215 {
    216         return float64_modf(value, iptr);
    217 }
    218 
    219 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    220 {
    221         return float32_modf(value, iptr);
    222 }
    223 
    224109static inline float64_t pow_f64(float64_t x, float64_t y)
    225110{
    … …  
    242127}
    243128
    244 static inline float64_t sinh_f64(float64_t val)
    245 {
    246         return float64_sinh(val);
    247 }
    248 
    249 static inline float32_t sinh_f32(float32_t val)
    250 {
    251         return float32_sinh(val);
    252 }
    253 
    254 static inline float64_t sqrt_f64(float64_t val)
    255 {
    256         return float64_sqrt(val);
    257 }
    258 
    259 static inline float32_t sqrt_f32(float32_t val)
    260 {
    261         return float32_sqrt(val);
    262 }
    263 
    264 static inline float64_t tan_f64(float64_t val)
    265 {
    266         return float64_tan(val);
    267 }
    268 
    269 static inline float32_t tan_f32(float32_t val)
    270 {
    271         return float32_tan(val);
    272 }
    273 
    274 static inline float64_t tanh_f64(float64_t val)
    275 {
    276         return float64_tanh(val);
    277 }
    278 
    279 static inline float32_t tanh_f32(float32_t val)
    280 {
    281         return float32_tanh(val);
    282 }
    283 
    284129static inline float64_t trunc_f64(float64_t val)
    285130{
    … …  
    292137}
    293138
    294 static inline float64_t acos(float64_t val)
    295 {
    296         return acos_f64(val);
    297 }
    298 
    299 static inline float32_t acosf(float32_t val)
    300 {
    301         return acos_f32(val);
    302 }
    303 
    304 static inline float64_t asin(float64_t val)
    305 {
    306         return asin_f64(val);
    307 }
    308 
    309 static inline float32_t asinf(float32_t val)
    310 {
    311         return asin_f32(val);
    312 }
    313 
    314 static inline float64_t atan(float64_t val)
    315 {
    316         return atan_f64(val);
    317 }
    318 
    319 static inline float32_t atanf(float32_t val)
    320 {
    321         return atan_f32(val);
    322 }
    323 
    324 static inline float64_t atan2(float64_t y, float64_t x)
    325 {
    326         return atan2_f64(y, x);
    327 }
    328 
    329 static inline float32_t atan2f(float32_t y, float32_t x)
    330 {
    331         return atan2_f32(y, x);
    332 }
    333 
    334139static inline float64_t ceil(float64_t val)
    335140{
    … …  
    352157}
    353158
    354 static inline float64_t cosh(float64_t val)
    355 {
    356         return cosh_f64(val);
    357 }
    358 
    359 static inline float32_t coshf(float32_t val)
    360 {
    361         return cosh_f32(val);
    362 }
    363 
    364159static inline float64_t exp(float64_t val)
    365160{
    … …  
    372167}
    373168
    374 static inline float64_t fabs(float64_t val)
    375 {
    376         return fabs_f64(val);
    377 }
    378 
    379 static inline float32_t fabsf(float32_t val)
    380 {
    381         return fabs_f32(val);
    382 }
    383 
    384169static inline float64_t floor(float64_t val)
    385170{
    … …  
    402187}
    403188
    404 static inline float64_t frexp(float64_t x, int *exp)
    405 {
    406         return frexp_f64(x, exp);
    407 }
    408 
    409 static inline float32_t frexpf(float32_t x, int *exp)
    410 {
    411         return frexp_f32(x, exp);
    412 }
    413 
    414 static inline float64_t ldexp(float64_t x, int exp)
    415 {
    416         return ldexp_f64(x, exp);
    417 }
    418 
    419 static inline float32_t ldexpf(float32_t x, int exp)
    420 {
    421         return ldexp_f32(x, exp);
    422 }
    423 
    424189static inline float64_t log(float64_t val)
    425190{
    … …  
    432197}
    433198
    434 static inline float64_t log10(float64_t val)
    435 {
    436         return log10_f64(val);
    437 }
    438 
    439 static inline float32_t log10f(float32_t val)
    440 {
    441         return log10_f32(val);
    442 }
    443 
    444 static inline float64_t modf(float64_t value, float64_t *iptr)
    445 {
    446         return modf_f64(value, iptr);
    447 }
    448 
    449 static inline float32_t modff(float32_t value, float32_t *iptr)
    450 {
    451         return modf_f32(value, iptr);
    452 }
    453 
    454199static inline float64_t pow(float64_t x, float64_t y)
    455200{
    … …  
    472217}
    473218
    474 static inline float64_t sinh(float64_t val)
    475 {
    476         return sinh_f64(val);
    477 }
    478 
    479 static inline float32_t sinhf(float32_t val)
    480 {
    481         return sinh_f32(val);
    482 }
    483 
    484 static inline float64_t sqrt(float64_t val)
    485 {
    486         return sqrt_f64(val);
    487 }
    488 
    489 static inline float32_t sqrtf(float32_t val)
    490 {
    491         return sqrt_f32(val);
    492 }
    493 
    494 static inline float64_t tan(float64_t val)
    495 {
    496         return tan_f64(val);
    497 }
    498 
    499 static inline float32_t tanf(float32_t val)
    500 {
    501         return tan_f32(val);
    502 }
    503 
    504 static inline float64_t tanh(float64_t val)
    505 {
    506         return tanh_f64(val);
    507 }
    508 
    509 static inline float32_t tanhf(float32_t val)
    510 {
    511         return tanh_f32(val);
    512 }
    513 
    514219static inline float64_t trunc(float64_t val)
    515220{

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_ppc32_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12367}
    12468
    125 static inline float64_t cosh_f64(float64_t val)
    126 {
    127         return float64_cosh(val);
    128 }
    129 
    130 static inline float32_t cosh_f32(float32_t val)
    131 {
    132         return float32_cosh(val);
    133 }
    134 
    13569static inline float64_t exp_f64(float64_t val)
    13670{
    … …  
    14377}
    14478
    145 static inline float64_t fabs_f64(float64_t val)
    146 {
    147         return float64_fabs(val);
    148 }
    149 
    150 static inline float32_t fabs_f32(float32_t val)
    151 {
    152         return float32_fabs(val);
    153 }
    154 
    15579static inline float64_t floor_f64(float64_t val)
    15680{
    … …  
    16286        return float32_floor(val);
    16387}
     88
    16489static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16590{
    166         return float64_fmod(dividend, divisor);
     91        return float64_mod(dividend, divisor);
    16792}
    16893
    16994static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    17095{
    171         return float32_fmod(dividend, divisor);
    172 }
    173 
    174 static inline float64_t frexp_f64(float64_t x, int *exp)
    175 {
    176         return float64_frexp(x, exp);
    177 }
    178 
    179 static inline float64_t frexp_f32(float32_t x, int *exp)
    180 {
    181         return float32_frexp(x, exp);
    182 }
    183 
    184 static inline float64_t ldexp_f64(float64_t x, int exp)
    185 {
    186         return float64_ldexp(x, exp);
    187 }
    188 
    189 static inline float64_t ldexp_f32(float32_t x, int exp)
    190 {
    191         return float32_ldexp(x, exp);
     96        return float32_mod(dividend, divisor);
    19297}
    19398
    … …  
    202107}
    203108
    204 static inline float64_t log10_f64(float64_t val)
    205 {
    206         return float64_log10(val);
    207 }
    208 
    209 static inline float32_t log10_f32(float32_t val)
    210 {
    211         return float32_log10(val);
    212 }
    213 
    214 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    215 {
    216         return float64_modf(value, iptr);
    217 }
    218 
    219 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    220 {
    221         return float32_modf(value, iptr);
    222 }
    223 
    224109static inline float64_t pow_f64(float64_t x, float64_t y)
    225110{
    … …  
    242127}
    243128
    244 static inline float64_t sinh_f64(float64_t val)
    245 {
    246         return float64_sinh(val);
    247 }
    248 
    249 static inline float32_t sinh_f32(float32_t val)
    250 {
    251         return float32_sinh(val);
    252 }
    253 
    254 static inline float64_t sqrt_f64(float64_t val)
    255 {
    256         return float64_sqrt(val);
    257 }
    258 
    259 static inline float32_t sqrt_f32(float32_t val)
    260 {
    261         return float32_sqrt(val);
    262 }
    263 
    264 static inline float64_t tan_f64(float64_t val)
    265 {
    266         return float64_tan(val);
    267 }
    268 
    269 static inline float32_t tan_f32(float32_t val)
    270 {
    271         return float32_tan(val);
    272 }
    273 
    274 static inline float64_t tanh_f64(float64_t val)
    275 {
    276         return float64_tanh(val);
    277 }
    278 
    279 static inline float32_t tanh_f32(float32_t val)
    280 {
    281         return float32_tanh(val);
    282 }
    283 
    284129static inline float64_t trunc_f64(float64_t val)
    285130{
    … …  
    292137}
    293138
    294 static inline float64_t acos(float64_t val)
    295 {
    296         return acos_f64(val);
    297 }
    298 
    299 static inline float32_t acosf(float32_t val)
    300 {
    301         return acos_f32(val);
    302 }
    303 
    304 static inline float64_t asin(float64_t val)
    305 {
    306         return asin_f64(val);
    307 }
    308 
    309 static inline float32_t asinf(float32_t val)
    310 {
    311         return asin_f32(val);
    312 }
    313 
    314 static inline float64_t atan(float64_t val)
    315 {
    316         return atan_f64(val);
    317 }
    318 
    319 static inline float32_t atanf(float32_t val)
    320 {
    321         return atan_f32(val);
    322 }
    323 
    324 static inline float64_t atan2(float64_t y, float64_t x)
    325 {
    326         return atan2_f64(y, x);
    327 }
    328 
    329 static inline float32_t atan2f(float32_t y, float32_t x)
    330 {
    331         return atan2_f32(y, x);
    332 }
    333 
    334139static inline float64_t ceil(float64_t val)
    335140{
    … …  
    352157}
    353158
    354 static inline float64_t cosh(float64_t val)
    355 {
    356         return cosh_f64(val);
    357 }
    358 
    359 static inline float32_t coshf(float32_t val)
    360 {
    361         return cosh_f32(val);
    362 }
    363 
    364159static inline float64_t exp(float64_t val)
    365160{
    … …  
    372167}
    373168
    374 static inline float64_t fabs(float64_t val)
    375 {
    376         return fabs_f64(val);
    377 }
    378 
    379 static inline float32_t fabsf(float32_t val)
    380 {
    381         return fabs_f32(val);
    382 }
    383 
    384169static inline float64_t floor(float64_t val)
    385170{
    … …  
    402187}
    403188
    404 static inline float64_t frexp(float64_t x, int *exp)
    405 {
    406         return frexp_f64(x, exp);
    407 }
    408 
    409 static inline float32_t frexpf(float32_t x, int *exp)
    410 {
    411         return frexp_f32(x, exp);
    412 }
    413 
    414 static inline float64_t ldexp(float64_t x, int exp)
    415 {
    416         return ldexp_f64(x, exp);
    417 }
    418 
    419 static inline float32_t ldexpf(float32_t x, int exp)
    420 {
    421         return ldexp_f32(x, exp);
    422 }
    423 
    424189static inline float64_t log(float64_t val)
    425190{
    … …  
    432197}
    433198
    434 static inline float64_t log10(float64_t val)
    435 {
    436         return log10_f64(val);
    437 }
    438 
    439 static inline float32_t log10f(float32_t val)
    440 {
    441         return log10_f32(val);
    442 }
    443 
    444 static inline float64_t modf(float64_t value, float64_t *iptr)
    445 {
    446         return modf_f64(value, iptr);
    447 }
    448 
    449 static inline float32_t modff(float32_t value, float32_t *iptr)
    450 {
    451         return modf_f32(value, iptr);
    452 }
    453 
    454199static inline float64_t pow(float64_t x, float64_t y)
    455200{
    … …  
    472217}
    473218
    474 static inline float64_t sinh(float64_t val)
    475 {
    476         return sinh_f64(val);
    477 }
    478 
    479 static inline float32_t sinhf(float32_t val)
    480 {
    481         return sinh_f32(val);
    482 }
    483 
    484 static inline float64_t sqrt(float64_t val)
    485 {
    486         return sqrt_f64(val);
    487 }
    488 
    489 static inline float32_t sqrtf(float32_t val)
    490 {
    491         return sqrt_f32(val);
    492 }
    493 
    494 static inline float64_t tan(float64_t val)
    495 {
    496         return tan_f64(val);
    497 }
    498 
    499 static inline float32_t tanf(float32_t val)
    500 {
    501         return tan_f32(val);
    502 }
    503 
    504 static inline float64_t tanh(float64_t val)
    505 {
    506         return tanh_f64(val);
    507 }
    508 
    509 static inline float32_t tanhf(float32_t val)
    510 {
    511         return tanh_f32(val);
    512 }
    513 
    514219static inline float64_t trunc(float64_t val)
    515220{

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_sparc32_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12367}
    12468
    125 static inline float64_t cosh_f64(float64_t val)
    126 {
    127         return float64_cosh(val);
    128 }
    129 
    130 static inline float32_t cosh_f32(float32_t val)
    131 {
    132         return float32_cosh(val);
    133 }
    134 
    13569static inline float64_t exp_f64(float64_t val)
    13670{
    … …  
    14377}
    14478
    145 static inline float64_t fabs_f64(float64_t val)
    146 {
    147         return float64_fabs(val);
    148 }
    149 
    150 static inline float32_t fabs_f32(float32_t val)
    151 {
    152         return float32_fabs(val);
    153 }
    154 
    15579static inline float64_t floor_f64(float64_t val)
    15680{
    … …  
    16286        return float32_floor(val);
    16387}
     88
    16489static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16590{
    166         return float64_fmod(dividend, divisor);
     91        return float64_mod(dividend, divisor);
    16792}
    16893
    16994static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    17095{
    171         return float32_fmod(dividend, divisor);
    172 }
    173 
    174 static inline float64_t frexp_f64(float64_t x, int *exp)
    175 {
    176         return float64_frexp(x, exp);
    177 }
    178 
    179 static inline float64_t frexp_f32(float32_t x, int *exp)
    180 {
    181         return float32_frexp(x, exp);
    182 }
    183 
    184 static inline float64_t ldexp_f64(float64_t x, int exp)
    185 {
    186         return float64_ldexp(x, exp);
    187 }
    188 
    189 static inline float64_t ldexp_f32(float32_t x, int exp)
    190 {
    191         return float32_ldexp(x, exp);
     96        return float32_mod(dividend, divisor);
    19297}
    19398
    … …  
    202107}
    203108
    204 static inline float64_t log10_f64(float64_t val)
    205 {
    206         return float64_log10(val);
    207 }
    208 
    209 static inline float32_t log10_f32(float32_t val)
    210 {
    211         return float32_log10(val);
    212 }
    213 
    214 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    215 {
    216         return float64_modf(value, iptr);
    217 }
    218 
    219 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    220 {
    221         return float32_modf(value, iptr);
    222 }
    223 
    224109static inline float64_t pow_f64(float64_t x, float64_t y)
    225110{
    … …  
    242127}
    243128
    244 static inline float64_t sinh_f64(float64_t val)
    245 {
    246         return float64_sinh(val);
    247 }
    248 
    249 static inline float32_t sinh_f32(float32_t val)
    250 {
    251         return float32_sinh(val);
    252 }
    253 
    254 static inline float64_t sqrt_f64(float64_t val)
    255 {
    256         return float64_sqrt(val);
    257 }
    258 
    259 static inline float32_t sqrt_f32(float32_t val)
    260 {
    261         return float32_sqrt(val);
    262 }
    263 
    264 static inline float64_t tan_f64(float64_t val)
    265 {
    266         return float64_tan(val);
    267 }
    268 
    269 static inline float32_t tan_f32(float32_t val)
    270 {
    271         return float32_tan(val);
    272 }
    273 
    274 static inline float64_t tanh_f64(float64_t val)
    275 {
    276         return float64_tanh(val);
    277 }
    278 
    279 static inline float32_t tanh_f32(float32_t val)
    280 {
    281         return float32_tanh(val);
    282 }
    283 
    284129static inline float64_t trunc_f64(float64_t val)
    285130{
    … …  
    292137}
    293138
    294 static inline float64_t acos(float64_t val)
    295 {
    296         return acos_f64(val);
    297 }
    298 
    299 static inline float32_t acosf(float32_t val)
    300 {
    301         return acos_f32(val);
    302 }
    303 
    304 static inline float64_t asin(float64_t val)
    305 {
    306         return asin_f64(val);
    307 }
    308 
    309 static inline float32_t asinf(float32_t val)
    310 {
    311         return asin_f32(val);
    312 }
    313 
    314 static inline float64_t atan(float64_t val)
    315 {
    316         return atan_f64(val);
    317 }
    318 
    319 static inline float32_t atanf(float32_t val)
    320 {
    321         return atan_f32(val);
    322 }
    323 
    324 static inline float64_t atan2(float64_t y, float64_t x)
    325 {
    326         return atan2_f64(y, x);
    327 }
    328 
    329 static inline float32_t atan2f(float32_t y, float32_t x)
    330 {
    331         return atan2_f32(y, x);
    332 }
    333 
    334139static inline float64_t ceil(float64_t val)
    335140{
    … …  
    352157}
    353158
    354 static inline float64_t cosh(float64_t val)
    355 {
    356         return cosh_f64(val);
    357 }
    358 
    359 static inline float32_t coshf(float32_t val)
    360 {
    361         return cosh_f32(val);
    362 }
    363 
    364159static inline float64_t exp(float64_t val)
    365160{
    … …  
    372167}
    373168
    374 static inline float64_t fabs(float64_t val)
    375 {
    376         return fabs_f64(val);
    377 }
    378 
    379 static inline float32_t fabsf(float32_t val)
    380 {
    381         return fabs_f32(val);
    382 }
    383 
    384169static inline float64_t floor(float64_t val)
    385170{
    … …  
    402187}
    403188
    404 static inline float64_t frexp(float64_t x, int *exp)
    405 {
    406         return frexp_f64(x, exp);
    407 }
    408 
    409 static inline float32_t frexpf(float32_t x, int *exp)
    410 {
    411         return frexp_f32(x, exp);
    412 }
    413 
    414 static inline float64_t ldexp(float64_t x, int exp)
    415 {
    416         return ldexp_f64(x, exp);
    417 }
    418 
    419 static inline float32_t ldexpf(float32_t x, int exp)
    420 {
    421         return ldexp_f32(x, exp);
    422 }
    423 
    424189static inline float64_t log(float64_t val)
    425190{
    … …  
    432197}
    433198
    434 static inline float64_t log10(float64_t val)
    435 {
    436         return log10_f64(val);
    437 }
    438 
    439 static inline float32_t log10f(float32_t val)
    440 {
    441         return log10_f32(val);
    442 }
    443 
    444 static inline float64_t modf(float64_t value, float64_t *iptr)
    445 {
    446         return modf_f64(value, iptr);
    447 }
    448 
    449 static inline float32_t modff(float32_t value, float32_t *iptr)
    450 {
    451         return modf_f32(value, iptr);
    452 }
    453 
    454199static inline float64_t pow(float64_t x, float64_t y)
    455200{
    … …  
    472217}
    473218
    474 static inline float64_t sinh(float64_t val)
    475 {
    476         return sinh_f64(val);
    477 }
    478 
    479 static inline float32_t sinhf(float32_t val)
    480 {
    481         return sinh_f32(val);
    482 }
    483 
    484 static inline float64_t sqrt(float64_t val)
    485 {
    486         return sqrt_f64(val);
    487 }
    488 
    489 static inline float32_t sqrtf(float32_t val)
    490 {
    491         return sqrt_f32(val);
    492 }
    493 
    494 static inline float64_t tan(float64_t val)
    495 {
    496         return tan_f64(val);
    497 }
    498 
    499 static inline float32_t tanf(float32_t val)
    500 {
    501         return tan_f32(val);
    502 }
    503 
    504 static inline float64_t tanh(float64_t val)
    505 {
    506         return tanh_f64(val);
    507 }
    508 
    509 static inline float32_t tanhf(float32_t val)
    510 {
    511         return tanh_f32(val);
    512 }
    513 
    514219static inline float64_t trunc(float64_t val)
    515220{

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

    r3b23d05 r996dc042  
    3737#define LIBMATH_sparc64_MATH_H_
    3838
    39 #include <acos.h>
    40 #include <asin.h>
    41 #include <atan.h>
    42 #include <atan2.h>
    4339#include <ceil.h>
    44 #include <cosh.h>
    4540#include <exp.h>
    46 #include <fabs.h>
    4741#include <floor.h>
    48 #include <fmod.h>
    49 #include <frexp.h>
    50 #include <ldexp.h>
    5142#include <log.h>
    52 #include <log10.h>
    5343#include <mathtypes.h>
    54 #include <modf.h>
     44#include <mod.h>
    5545#include <pow.h>
    56 #include <sinh.h>
    57 #include <sqrt.h>
    58 #include <tan.h>
    59 #include <tanh.h>
     46#include <trunc.h>
    6047#include <trig.h>
    61 #include <trunc.h>
    62 
    63 #define HUGE_VAL FLOAT64_INF
    64 
    65 static inline float64_t acos_f64(float64_t val)
    66 {
    67         return float64_acos(val);
    68 }
    69 
    70 static inline float32_t acos_f32(float32_t val)
    71 {
    72         return float32_acos(val);
    73 }
    74 
    75 static inline float64_t asin_f64(float64_t val)
    76 {
    77         return float64_asin(val);
    78 }
    79 
    80 static inline float32_t asin_f32(float32_t val)
    81 {
    82         return float32_asin(val);
    83 }
    84 
    85 static inline float64_t atan_f64(float64_t val)
    86 {
    87         return float64_atan(val);
    88 }
    89 
    90 static inline float32_t atan_f32(float32_t val)
    91 {
    92         return float32_atan(val);
    93 }
    94 
    95 static inline float64_t atan2_f64(float64_t y, float64_t x)
    96 {
    97         return float64_atan2(y, x);
    98 }
    99 
    100 static inline float32_t atan2_f32(float32_t y, float32_t x)
    101 {
    102         return float32_atan2(y, x);
    103 }
    10448
    10549static inline float64_t ceil_f64(float64_t val)
    … …  
    12367}
    12468
    125 static inline float64_t cosh_f64(float64_t val)
    126 {
    127         return float64_cosh(val);
    128 }
    129 
    130 static inline float32_t cosh_f32(float32_t val)
    131 {
    132         return float32_cosh(val);
    133 }
    134 
    13569static inline float64_t exp_f64(float64_t val)
    13670{
    … …  
    14377}
    14478
    145 static inline float64_t fabs_f64(float64_t val)
    146 {
    147         return float64_fabs(val);
    148 }
    149 
    150 static inline float32_t fabs_f32(float32_t val)
    151 {
    152         return float32_fabs(val);
    153 }
    154 
    15579static inline float64_t floor_f64(float64_t val)
    15680{
    … …  
    16286        return float32_floor(val);
    16387}
     88
    16489static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
    16590{
    166         return float64_fmod(dividend, divisor);
     91        return float64_mod(dividend, divisor);
    16792}
    16893
    16994static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
    17095{
    171         return float32_fmod(dividend, divisor);
    172 }
    173 
    174 static inline float64_t frexp_f64(float64_t x, int *exp)
    175 {
    176         return float64_frexp(x, exp);
    177 }
    178 
    179 static inline float64_t frexp_f32(float32_t x, int *exp)
    180 {
    181         return float32_frexp(x, exp);
    182 }
    183 
    184 static inline float64_t ldexp_f64(float64_t x, int exp)
    185 {
    186         return float64_ldexp(x, exp);
    187 }
    188 
    189 static inline float64_t ldexp_f32(float32_t x, int exp)
    190 {
    191         return float32_ldexp(x, exp);
     96        return float32_mod(dividend, divisor);
    19297}
    19398
    … …  
    202107}
    203108
    204 static inline float64_t log10_f64(float64_t val)
    205 {
    206         return float64_log10(val);
    207 }
    208 
    209 static inline float32_t log10_f32(float32_t val)
    210 {
    211         return float32_log10(val);
    212 }
    213 
    214 static inline float64_t modf_f64(float64_t value, float64_t *iptr)
    215 {
    216         return float64_modf(value, iptr);
    217 }
    218 
    219 static inline float64_t modf_f32(float32_t value, float32_t *iptr)
    220 {
    221         return float32_modf(value, iptr);
    222 }
    223 
    224109static inline float64_t pow_f64(float64_t x, float64_t y)
    225110{
    … …  
    242127}
    243128
    244 static inline float64_t sinh_f64(float64_t val)
    245 {
    246         return float64_sinh(val);
    247 }
    248 
    249 static inline float32_t sinh_f32(float32_t val)
    250 {
    251         return float32_sinh(val);
    252 }
    253 
    254 static inline float64_t sqrt_f64(float64_t val)
    255 {
    256         return float64_sqrt(val);
    257 }
    258 
    259 static inline float32_t sqrt_f32(float32_t val)
    260 {
    261         return float32_sqrt(val);
    262 }
    263 
    264 static inline float64_t tan_f64(float64_t val)
    265 {
    266         return float64_tan(val);
    267 }
    268 
    269 static inline float32_t tan_f32(float32_t val)
    270 {
    271         return float32_tan(val);
    272 }
    273 
    274 static inline float64_t tanh_f64(float64_t val)
    275 {
    276         return float64_tanh(val);
    277 }
    278 
    279 static inline float32_t tanh_f32(float32_t val)
    280 {
    281         return float32_tanh(val);
    282 }
    283 
    284129static inline float64_t trunc_f64(float64_t val)
    285130{
    … …  
    292137}
    293138
    294 static inline float64_t acos(float64_t val)
    295 {
    296         return acos_f64(val);
    297 }
    298 
    299 static inline float32_t acosf(float32_t val)
    300 {
    301         return acos_f32(val);
    302 }
    303 
    304 static inline float64_t asin(float64_t val)
    305 {
    306         return asin_f64(val);
    307 }
    308 
    309 static inline float32_t asinf(float32_t val)
    310 {
    311         return asin_f32(val);
    312 }
    313 
    314 static inline float64_t atan(float64_t val)
    315 {
    316         return atan_f64(val);
    317 }
    318 
    319 static inline float32_t atanf(float32_t val)
    320 {
    321         return atan_f32(val);
    322 }
    323 
    324 static inline float64_t atan2(float64_t y, float64_t x)
    325 {
    326         return atan2_f64(y, x);
    327 }
    328 
    329 static inline float32_t atan2f(float32_t y, float32_t x)
    330 {
    331         return atan2_f32(y, x);
    332 }
    333 
    334139static inline float64_t ceil(float64_t val)
    335140{
    … …  
    352157}
    353158
    354 static inline float64_t cosh(float64_t val)
    355 {
    356         return cosh_f64(val);
    357 }
    358 
    359 static inline float32_t coshf(float32_t val)
    360 {
    361         return cosh_f32(val);
    362 }
    363 
    364159static inline float64_t exp(float64_t val)
    365160{
    … …  
    372167}
    373168
    374 static inline float64_t fabs(float64_t val)
    375 {
    376         return fabs_f64(val);
    377 }
    378 
    379 static inline float32_t fabsf(float32_t val)
    380 {
    381         return fabs_f32(val);
    382 }
    383 
    384169static inline float64_t floor(float64_t val)
    385170{
    … …  
    402187}
    403188
    404 static inline float64_t frexp(float64_t x, int *exp)
    405 {
    406         return frexp_f64(x, exp);
    407 }
    408 
    409 static inline float32_t frexpf(float32_t x, int *exp)
    410 {
    411         return frexp_f32(x, exp);
    412 }
    413 
    414 static inline float64_t ldexp(float64_t x, int exp)
    415 {
    416         return ldexp_f64(x, exp);
    417 }
    418 
    419 static inline float32_t ldexpf(float32_t x, int exp)
    420 {
    421         return ldexp_f32(x, exp);
    422 }
    423 
    424189static inline float64_t log(float64_t val)
    425190{
    … …  
    432197}
    433198
    434 static inline float64_t log10(float64_t val)
    435 {
    436         return log10_f64(val);
    437 }
    438 
    439 static inline float32_t log10f(float32_t val)
    440 {
    441         return log10_f32(val);
    442 }
    443 
    444 static inline float64_t modf(float64_t value, float64_t *iptr)
    445 {
    446         return modf_f64(value, iptr);
    447 }
    448 
    449 static inline float32_t modff(float32_t value, float32_t *iptr)
    450 {
    451         return modf_f32(value, iptr);
    452 }
    453 
    454199static inline float64_t pow(float64_t x, float64_t y)
    455200{
    … …  
    472217}
    473218
    474 static inline float64_t sinh(float64_t val)
    475 {
    476         return sinh_f64(val);
    477 }
    478 
    479 static inline float32_t sinhf(float32_t val)
    480 {
    481         return sinh_f32(val);
    482 }
    483 
    484 static inline float64_t sqrt(float64_t val)
    485 {
    486         return sqrt_f64(val);
    487 }
    488 
    489 static inline float32_t sqrtf(float32_t val)
    490 {
    491         return sqrt_f32(val);
    492 }
    493 
    494 static inline float64_t tan(float64_t val)
    495 {
    496         return tan_f64(val);
    497 }
    498 
    499 static inline float32_t tanf(float32_t val)
    500 {
    501         return tan_f32(val);
    502 }
    503 
    504 static inline float64_t tanh(float64_t val)
    505 {
    506         return tanh_f64(val);
    507 }
    508 
    509 static inline float32_t tanhf(float32_t val)
    510 {
    511         return tanh_f32(val);
    512 }
    513 
    514219static inline float64_t trunc(float64_t val)
    515220{

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

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

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

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

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

    r3b23d05 r996dc042  
    11/*
    22 * Copyright (c) 2011 Petr Koupy
    3  * Copyright (c) 2015 Jiri Svoboda
    43 * All rights reserved.
    54 *
    … …  
    3938#include <libarch/math.h>
    4039
    41 #define M_LN10 2.30258509299404568402
    4240#define M_LN2 0.69314718055994530942
    4341#define M_LOG2E 1.4426950408889634074
    4442#define M_PI 3.14159265358979323846
    45 #define M_PI_2 1.57079632679489661923
    4643
    4744#endif
Note: See TracChangeset for help on using the changeset viewer.