Changeset b69786e in mainline for uspace/lib/math/arch


Ignore:
Timestamp:
2015-09-17T16:16:25Z (10 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
3b23d05
Parents:
ba8eecf
Message:

Add all functions required by C89 plus their single-precision variants from C99.

Location:
uspace/lib/math/arch
Files:
10 edited

Legend:

Unmodified
Added
Removed

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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