Changeset 9adb61d in mainline for uspace/lib/math/arch


Ignore:
Timestamp:
2015-09-05T11:50:00Z (10 years ago)
Author:
Jiri Svoboda <jiri@…>
Branches:
lfn, master, serial, ticket/834-toolchain-update, topic/msim-upgrade, topic/simplify-dev-export
Children:
996dc042, ba8eecf
Parents:
e6f5766
Message:

Add single-precision variant for all functions. Allow generic implementations to call other functions while selecting the number of bits of precision, but not the implementation (generic or arch-specific).

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

Legend:

Unmodified
Added
Removed

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <trig.h>
    4748
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59static inline float64_t cos_f64(float64_t val)
     60{
     61        return float64_cos(val);
     62}
     63
     64static inline float32_t cos_f32(float32_t val)
     65{
     66        return float32_cos(val);
     67}
     68
     69static inline float64_t exp_f64(float64_t val)
     70{
     71        return float64_exp(val);
     72}
     73
     74static inline float32_t exp_f32(float32_t val)
     75{
     76        return float32_exp(val);
     77}
     78
     79static inline float64_t floor_f64(float64_t val)
     80{
     81        return float64_floor(val);
     82}
     83
     84static inline float32_t floor_f32(float32_t val)
     85{
     86        return float32_floor(val);
     87}
     88
     89static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     90{
     91        return float64_mod(dividend, divisor);
     92}
     93
     94static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     95{
     96        return float32_mod(dividend, divisor);
     97}
     98
     99static inline float64_t log_f64(float64_t val)
     100{
     101        return float64_log(val);
     102}
     103
     104static inline float32_t log_f32(float32_t val)
     105{
     106        return float32_log(val);
     107}
     108
     109static inline float64_t pow_f64(float64_t x, float64_t y)
     110{
     111        return float64_pow(x, y);
     112}
     113
     114static inline float32_t pow_f32(float32_t x, float32_t y)
     115{
     116        return float32_pow(x, y);
     117}
     118
     119static inline float64_t sin_f64(float64_t val)
     120{
     121        return float64_sin(val);
     122}
     123
     124static inline float32_t sin_f32(float32_t val)
     125{
     126        return float32_sin(val);
     127}
     128
     129static inline float64_t trunc_f64(float64_t val)
     130{
     131        return float64_trunc(val);
     132}
     133
     134static inline float32_t trunc_f32(float32_t val)
     135{
     136        return float32_trunc(val);
     137}
     138
     139static inline float64_t ceil(float64_t val)
     140{
     141        return ceil_f64(val);
     142}
     143
     144static inline float32_t ceilf(float32_t val)
     145{
     146        return ceil_f32(val);
     147}
     148
     149static inline float64_t cos(float64_t val)
     150{
     151        return cos_f64(val);
     152}
     153
     154static inline float32_t cosf(float32_t val)
     155{
     156        return cos_f32(val);
     157}
     158
     159static inline float64_t exp(float64_t val)
     160{
     161        return exp_f64(val);
     162}
     163
     164static inline float32_t expf(float32_t val)
     165{
     166        return exp_f32(val);
     167}
     168
     169static inline float64_t floor(float64_t val)
     170{
     171        return floor_f64(val);
     172}
     173
     174static inline float32_t floorf(float32_t val)
     175{
     176        return floor_f32(val);
     177}
     178
    48179static inline float64_t fmod(float64_t dividend, float64_t divisor)
    49180{
    50         return float64_mod(dividend, divisor);
     181        return fmod_f64(dividend, divisor);
     182}
     183
     184static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     185{
     186        return fmod_f32(dividend, divisor);
     187}
     188
     189static inline float64_t log(float64_t val)
     190{
     191        return log_f64(val);
     192}
     193
     194static inline float32_t logf(float32_t val)
     195{
     196        return log_f32(val);
     197}
     198
     199static inline float64_t pow(float64_t x, float64_t y)
     200{
     201        return pow_f64(x, y);
     202}
     203
     204static inline float32_t powf(float32_t x, float32_t y)
     205{
     206        return pow_f32(x, y);
     207}
     208
     209static inline float64_t sin(float64_t val)
     210{
     211        return sin_f64(val);
     212}
     213
     214static inline float32_t sinf(float32_t val)
     215{
     216        return sin_f32(val);
    51217}
    52218
    53219static inline float64_t trunc(float64_t val)
    54220{
    55         return float64_trunc(val);
    56 }
    57 
    58 static inline float64_t ceil(float64_t val)
    59 {
    60         return float64_ceil(val);
    61 }
    62 
    63 static inline float32_t expf(float32_t val)
    64 {
    65         return float32_exp(val);
    66 }
    67 
    68 static inline float64_t exp(float64_t val)
    69 {
    70         return float64_exp(val);
    71 }
    72 
    73 static inline float64_t floor(float64_t val)
    74 {
    75         return float64_floor(val);
    76 }
    77 
    78 static inline float32_t logf(float32_t val)
    79 {
    80         return float32_log(val);
    81 }
    82 
    83 static inline float64_t log(float64_t val)
    84 {
    85         return float64_log(val);
    86 }
    87 
    88 static inline float32_t powf(float32_t x, float32_t y)
    89 {
    90         return float32_pow(x, y);
    91 }
    92 
    93 static inline float64_t pow(float64_t x, float64_t y)
    94 {
    95         return float64_pow(x, y);
    96 }
    97 
    98 static inline float64_t sin(float64_t val)
    99 {
    100         return float64_sin(val);
    101 }
    102 
    103 static inline float64_t cos(float64_t val)
    104 {
    105         return float64_cos(val);
     221        return trunc_f64(val);
     222}
     223
     224static inline float32_t truncf(float32_t val)
     225{
     226        return trunc_f32(val);
    106227}
    107228

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4344#include <mod.h>
    4445#include <pow.h>
     46#include <trunc.h>
     47#include <trig.h>
     48
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59extern float64_t cos_f64(float64_t);
     60
     61static inline float32_t cos_f32(float32_t val)
     62{
     63        return (float32_t)cos_f64((float64_t)val);
     64}
     65
     66static inline float64_t exp_f64(float64_t val)
     67{
     68        return float64_exp(val);
     69}
     70
     71static inline float32_t exp_f32(float32_t val)
     72{
     73        return float32_exp(val);
     74}
     75
     76static inline float64_t floor_f64(float64_t val)
     77{
     78        return float64_floor(val);
     79}
     80
     81static inline float32_t floor_f32(float32_t val)
     82{
     83        return float32_floor(val);
     84}
     85
     86static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     87{
     88        return float64_mod(dividend, divisor);
     89}
     90
     91static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     92{
     93        return float32_mod(dividend, divisor);
     94}
     95
     96static inline float64_t log_f64(float64_t val)
     97{
     98        return float64_log(val);
     99}
     100
     101static inline float32_t log_f32(float32_t val)
     102{
     103        return float32_log(val);
     104}
     105
     106static inline float64_t pow_f64(float64_t x, float64_t y)
     107{
     108        return float64_pow(x, y);
     109}
     110
     111static inline float32_t pow_f32(float32_t x, float32_t y)
     112{
     113        return float32_pow(x, y);
     114}
     115
     116extern float64_t sin_f64(float64_t);
     117
     118static inline float32_t sin_f32(float32_t val)
     119{
     120        return (float32_t)sin_f64((float64_t)val);
     121}
     122
     123extern float64_t trunc_f64(float64_t);
     124
     125static inline float32_t trunc_f32(float32_t val)
     126{
     127        return (float32_t)trunc_f64((float64_t)val);
     128}
     129
     130static inline float64_t ceil(float64_t val)
     131{
     132        return ceil_f64(val);
     133}
     134
     135static inline float32_t ceilf(float32_t val)
     136{
     137        return ceil_f32(val);
     138}
     139
     140static inline float64_t cos(float64_t val)
     141{
     142        return cos_f64(val);
     143}
     144
     145static inline float32_t cosf(float32_t val)
     146{
     147        return cos_f32(val);
     148}
     149
     150static inline float64_t exp(float64_t val)
     151{
     152        return exp_f64(val);
     153}
     154
     155static inline float32_t expf(float32_t val)
     156{
     157        return exp_f32(val);
     158}
     159
     160static inline float64_t floor(float64_t val)
     161{
     162        return floor_f64(val);
     163}
     164
     165static inline float32_t floorf(float32_t val)
     166{
     167        return floor_f32(val);
     168}
    45169
    46170static inline float64_t fmod(float64_t dividend, float64_t divisor)
    47171{
    48         return float64_mod(dividend, divisor);
    49 }
    50 
    51 extern float64_t sin(float64_t);
    52 extern float64_t cos(float64_t);
    53 
    54 static inline float64_t ceil(float64_t val)
    55 {
    56         return float64_ceil(val);
    57 }
    58 
    59 static inline float32_t expf(float32_t val)
    60 {
    61         return float32_exp(val);
    62 }
    63 
    64 static inline float64_t exp(float64_t val)
    65 {
    66         return float64_exp(val);
    67 }
    68 
    69 static inline float64_t floor(float64_t val)
    70 {
    71         return float64_floor(val);
     172        return fmod_f64(dividend, divisor);
     173}
     174
     175static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     176{
     177        return fmod_f32(dividend, divisor);
     178}
     179
     180static inline float64_t log(float64_t val)
     181{
     182        return log_f64(val);
    72183}
    73184
    74185static inline float32_t logf(float32_t val)
    75186{
    76         return float32_log(val);
    77 }
    78 
    79 static inline float64_t log(float64_t val)
    80 {
    81         return float64_log(val);
     187        return log_f32(val);
     188}
     189
     190static inline float64_t pow(float64_t x, float64_t y)
     191{
     192        return pow_f64(x, y);
    82193}
    83194
    84195static inline float32_t powf(float32_t x, float32_t y)
    85196{
    86         return float32_pow(x, y);
    87 }
    88 
    89 static inline float64_t pow(float64_t x, float64_t y)
    90 {
    91         return float64_pow(x, y);
    92 }
    93 
    94 extern float64_t trunc(float64_t);
     197        return pow_f32(x, y);
     198}
     199
     200static inline float64_t sin(float64_t val)
     201{
     202        return sin_f64(val);
     203}
     204
     205static inline float32_t sinf(float32_t val)
     206{
     207        return sin_f32(val);
     208}
     209
     210static inline float64_t trunc(float64_t val)
     211{
     212        return trunc_f64(val);
     213}
     214
     215static inline float32_t truncf(float32_t val)
     216{
     217        return trunc_f32(val);
     218}
    95219
    96220#endif

  • uspace/lib/math/arch/amd64/src/cos.S

    re6f5766 r9adb61d  
    3131.text
    3232
    33 .global cos
     33.global cos_f64
    3434
    35 cos:
     35cos_f64:
    3636        pushq %rbp
    3737        movq %rsp, %rbp

  • uspace/lib/math/arch/amd64/src/sin.S

    re6f5766 r9adb61d  
    3131.text
    3232
    33 .global sin
     33.global sin_f64
    3434
    35 sin:
     35sin_f64:
    3636        pushq %rbp
    3737        movq %rsp, %rbp

  • uspace/lib/math/arch/amd64/src/trunc.S

    re6f5766 r9adb61d  
    3131.text
    3232
    33 .global trunc
     33.global trunc_f64
    3434
    35 trunc:
     35trunc_f64:
    3636        pushq %rbp
    3737        movq %rsp, %rbp

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <trig.h>
    4748
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59static inline float64_t cos_f64(float64_t val)
     60{
     61        return float64_cos(val);
     62}
     63
     64static inline float32_t cos_f32(float32_t val)
     65{
     66        return float32_cos(val);
     67}
     68
     69static inline float64_t exp_f64(float64_t val)
     70{
     71        return float64_exp(val);
     72}
     73
     74static inline float32_t exp_f32(float32_t val)
     75{
     76        return float32_exp(val);
     77}
     78
     79static inline float64_t floor_f64(float64_t val)
     80{
     81        return float64_floor(val);
     82}
     83
     84static inline float32_t floor_f32(float32_t val)
     85{
     86        return float32_floor(val);
     87}
     88
     89static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     90{
     91        return float64_mod(dividend, divisor);
     92}
     93
     94static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     95{
     96        return float32_mod(dividend, divisor);
     97}
     98
     99static inline float64_t log_f64(float64_t val)
     100{
     101        return float64_log(val);
     102}
     103
     104static inline float32_t log_f32(float32_t val)
     105{
     106        return float32_log(val);
     107}
     108
     109static inline float64_t pow_f64(float64_t x, float64_t y)
     110{
     111        return float64_pow(x, y);
     112}
     113
     114static inline float32_t pow_f32(float32_t x, float32_t y)
     115{
     116        return float32_pow(x, y);
     117}
     118
     119static inline float64_t sin_f64(float64_t val)
     120{
     121        return float64_sin(val);
     122}
     123
     124static inline float32_t sin_f32(float32_t val)
     125{
     126        return float32_sin(val);
     127}
     128
     129static inline float64_t trunc_f64(float64_t val)
     130{
     131        return float64_trunc(val);
     132}
     133
     134static inline float32_t trunc_f32(float32_t val)
     135{
     136        return float32_trunc(val);
     137}
     138
     139static inline float64_t ceil(float64_t val)
     140{
     141        return ceil_f64(val);
     142}
     143
     144static inline float32_t ceilf(float32_t val)
     145{
     146        return ceil_f32(val);
     147}
     148
     149static inline float64_t cos(float64_t val)
     150{
     151        return cos_f64(val);
     152}
     153
     154static inline float32_t cosf(float32_t val)
     155{
     156        return cos_f32(val);
     157}
     158
     159static inline float64_t exp(float64_t val)
     160{
     161        return exp_f64(val);
     162}
     163
     164static inline float32_t expf(float32_t val)
     165{
     166        return exp_f32(val);
     167}
     168
     169static inline float64_t floor(float64_t val)
     170{
     171        return floor_f64(val);
     172}
     173
     174static inline float32_t floorf(float32_t val)
     175{
     176        return floor_f32(val);
     177}
     178
    48179static inline float64_t fmod(float64_t dividend, float64_t divisor)
    49180{
    50         return float64_mod(dividend, divisor);
     181        return fmod_f64(dividend, divisor);
     182}
     183
     184static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     185{
     186        return fmod_f32(dividend, divisor);
     187}
     188
     189static inline float64_t log(float64_t val)
     190{
     191        return log_f64(val);
     192}
     193
     194static inline float32_t logf(float32_t val)
     195{
     196        return log_f32(val);
     197}
     198
     199static inline float64_t pow(float64_t x, float64_t y)
     200{
     201        return pow_f64(x, y);
     202}
     203
     204static inline float32_t powf(float32_t x, float32_t y)
     205{
     206        return pow_f32(x, y);
     207}
     208
     209static inline float64_t sin(float64_t val)
     210{
     211        return sin_f64(val);
     212}
     213
     214static inline float32_t sinf(float32_t val)
     215{
     216        return sin_f32(val);
    51217}
    52218
    53219static inline float64_t trunc(float64_t val)
    54220{
    55         return float64_trunc(val);
    56 }
    57 
    58 static inline float64_t ceil(float64_t val)
    59 {
    60         return float64_ceil(val);
    61 }
    62 
    63 static inline float32_t expf(float32_t val)
    64 {
    65         return float32_exp(val);
    66 }
    67 
    68 static inline float64_t exp(float64_t val)
    69 {
    70         return float64_exp(val);
    71 }
    72 
    73 static inline float64_t floor(float64_t val)
    74 {
    75         return float64_floor(val);
    76 }
    77 
    78 static inline float32_t logf(float32_t val)
    79 {
    80         return float32_log(val);
    81 }
    82 
    83 static inline float64_t log(float64_t val)
    84 {
    85         return float64_log(val);
    86 }
    87 
    88 static inline float32_t powf(float32_t x, float32_t y)
    89 {
    90         return float32_pow(x, y);
    91 }
    92 
    93 static inline float64_t pow(float64_t x, float64_t y)
    94 {
    95         return float64_pow(x, y);
    96 }
    97 
    98 static inline float64_t sin(float64_t val)
    99 {
    100         return float64_sin(val);
    101 }
    102 
    103 static inline float64_t cos(float64_t val)
    104 {
    105         return float64_cos(val);
     221        return trunc_f64(val);
     222}
     223
     224static inline float32_t truncf(float32_t val)
     225{
     226        return trunc_f32(val);
    106227}
    107228

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4344#include <mod.h>
    4445#include <pow.h>
     46#include <trunc.h>
     47#include <trig.h>
     48
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59extern float64_t cos_f64(float64_t);
     60
     61static inline float32_t cos_f32(float32_t val)
     62{
     63        return (float32_t)cos_f64((float64_t)val);
     64}
     65
     66static inline float64_t exp_f64(float64_t val)
     67{
     68        return float64_exp(val);
     69}
     70
     71static inline float32_t exp_f32(float32_t val)
     72{
     73        return float32_exp(val);
     74}
     75
     76static inline float64_t floor_f64(float64_t val)
     77{
     78        return float64_floor(val);
     79}
     80
     81static inline float32_t floor_f32(float32_t val)
     82{
     83        return float32_floor(val);
     84}
     85
     86static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     87{
     88        return float64_mod(dividend, divisor);
     89}
     90
     91static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     92{
     93        return float32_mod(dividend, divisor);
     94}
     95
     96static inline float64_t log_f64(float64_t val)
     97{
     98        return float64_log(val);
     99}
     100
     101static inline float32_t log_f32(float32_t val)
     102{
     103        return float32_log(val);
     104}
     105
     106static inline float64_t pow_f64(float64_t x, float64_t y)
     107{
     108        return float64_pow(x, y);
     109}
     110
     111static inline float32_t pow_f32(float32_t x, float32_t y)
     112{
     113        return float32_pow(x, y);
     114}
     115
     116extern float64_t sin_f64(float64_t);
     117
     118static inline float32_t sin_f32(float32_t val)
     119{
     120        return (float32_t)sin_f64((float64_t)val);
     121}
     122
     123extern float64_t trunc_f64(float64_t);
     124
     125static inline float32_t trunc_f32(float32_t val)
     126{
     127        return (float32_t)trunc_f64((float64_t)val);
     128}
     129
     130static inline float64_t ceil(float64_t val)
     131{
     132        return ceil_f64(val);
     133}
     134
     135static inline float32_t ceilf(float32_t val)
     136{
     137        return ceil_f32(val);
     138}
     139
     140static inline float64_t cos(float64_t val)
     141{
     142        return cos_f64(val);
     143}
     144
     145static inline float32_t cosf(float32_t val)
     146{
     147        return cos_f32(val);
     148}
     149
     150static inline float64_t exp(float64_t val)
     151{
     152        return exp_f64(val);
     153}
     154
     155static inline float32_t expf(float32_t val)
     156{
     157        return exp_f32(val);
     158}
     159
     160static inline float64_t floor(float64_t val)
     161{
     162        return floor_f64(val);
     163}
     164
     165static inline float32_t floorf(float32_t val)
     166{
     167        return floor_f32(val);
     168}
    45169
    46170static inline float64_t fmod(float64_t dividend, float64_t divisor)
    47171{
    48         return float64_mod(dividend, divisor);
    49 }
    50 
    51 extern float64_t sin(float64_t);
    52 extern float64_t cos(float64_t);
    53 
    54 static inline float64_t ceil(float64_t val)
    55 {
    56         return float64_ceil(val);
    57 }
    58 
    59 static inline float64_t floor(float64_t val)
    60 {
    61         return float64_floor(val);
    62 }
    63 
    64 static inline float32_t expf(float32_t val)
    65 {
    66         return float32_exp(val);
    67 }
    68 
    69 static inline float64_t exp(float64_t val)
    70 {
    71         return float64_exp(val);
     172        return fmod_f64(dividend, divisor);
     173}
     174
     175static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     176{
     177        return fmod_f32(dividend, divisor);
     178}
     179
     180static inline float64_t log(float64_t val)
     181{
     182        return log_f64(val);
    72183}
    73184
    74185static inline float32_t logf(float32_t val)
    75186{
    76         return float32_log(val);
    77 }
    78 
    79 static inline float64_t log(float64_t val)
    80 {
    81         return float64_log(val);
     187        return log_f32(val);
     188}
     189
     190static inline float64_t pow(float64_t x, float64_t y)
     191{
     192        return pow_f64(x, y);
    82193}
    83194
    84195static inline float32_t powf(float32_t x, float32_t y)
    85196{
    86         return float32_pow(x, y);
    87 }
    88 
    89 static inline float64_t pow(float64_t x, float64_t y)
    90 {
    91         return float64_pow(x, y);
    92 }
    93 
    94 extern float64_t trunc(float64_t);
     197        return pow_f32(x, y);
     198}
     199
     200static inline float64_t sin(float64_t val)
     201{
     202        return sin_f64(val);
     203}
     204
     205static inline float32_t sinf(float32_t val)
     206{
     207        return sin_f32(val);
     208}
     209
     210static inline float64_t trunc(float64_t val)
     211{
     212        return trunc_f64(val);
     213}
     214
     215static inline float32_t truncf(float32_t val)
     216{
     217        return trunc_f32(val);
     218}
    95219
    96220#endif

  • uspace/lib/math/arch/ia32/src/cos.S

    re6f5766 r9adb61d  
    3131.text
    3232
    33 .global cos
     33.global cos_f64
    3434
    35 cos:
     35cos_f64:
    3636        # compute cosine (no stack frame)
    3737       

  • uspace/lib/math/arch/ia32/src/sin.S

    re6f5766 r9adb61d  
    3131.text
    3232
    33 .global sin
     33.global sin_f64
    3434
    35 sin:
     35sin_f64:
    3636        # compute sine (no stack frame)
    3737       

  • uspace/lib/math/arch/ia32/src/trunc.S

    re6f5766 r9adb61d  
    3131.text
    3232
    33 .global trunc
     33.global trunc_f64
    3434
    35 trunc:
     35trunc_f64:
    3636        pushl %ebp
    3737        movl %esp, %ebp

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4041#include <floor.h>
    4142#include <log.h>
    42 #include <pow.h>
    4343#include <mathtypes.h>
    4444#include <mod.h>
     45#include <pow.h>
    4546#include <trunc.h>
    4647#include <trig.h>
    4748
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59static inline float64_t cos_f64(float64_t val)
     60{
     61        return float64_cos(val);
     62}
     63
     64static inline float32_t cos_f32(float32_t val)
     65{
     66        return float32_cos(val);
     67}
     68
     69static inline float64_t exp_f64(float64_t val)
     70{
     71        return float64_exp(val);
     72}
     73
     74static inline float32_t exp_f32(float32_t val)
     75{
     76        return float32_exp(val);
     77}
     78
     79static inline float64_t floor_f64(float64_t val)
     80{
     81        return float64_floor(val);
     82}
     83
     84static inline float32_t floor_f32(float32_t val)
     85{
     86        return float32_floor(val);
     87}
     88
     89static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     90{
     91        return float64_mod(dividend, divisor);
     92}
     93
     94static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     95{
     96        return float32_mod(dividend, divisor);
     97}
     98
     99static inline float64_t log_f64(float64_t val)
     100{
     101        return float64_log(val);
     102}
     103
     104static inline float32_t log_f32(float32_t val)
     105{
     106        return float32_log(val);
     107}
     108
     109static inline float64_t pow_f64(float64_t x, float64_t y)
     110{
     111        return float64_pow(x, y);
     112}
     113
     114static inline float32_t pow_f32(float32_t x, float32_t y)
     115{
     116        return float32_pow(x, y);
     117}
     118
     119static inline float64_t sin_f64(float64_t val)
     120{
     121        return float64_sin(val);
     122}
     123
     124static inline float32_t sin_f32(float32_t val)
     125{
     126        return float32_sin(val);
     127}
     128
     129static inline float64_t trunc_f64(float64_t val)
     130{
     131        return float64_trunc(val);
     132}
     133
     134static inline float32_t trunc_f32(float32_t val)
     135{
     136        return float32_trunc(val);
     137}
     138
     139static inline float64_t ceil(float64_t val)
     140{
     141        return ceil_f64(val);
     142}
     143
     144static inline float32_t ceilf(float32_t val)
     145{
     146        return ceil_f32(val);
     147}
     148
     149static inline float64_t cos(float64_t val)
     150{
     151        return cos_f64(val);
     152}
     153
     154static inline float32_t cosf(float32_t val)
     155{
     156        return cos_f32(val);
     157}
     158
     159static inline float64_t exp(float64_t val)
     160{
     161        return exp_f64(val);
     162}
     163
     164static inline float32_t expf(float32_t val)
     165{
     166        return exp_f32(val);
     167}
     168
     169static inline float64_t floor(float64_t val)
     170{
     171        return floor_f64(val);
     172}
     173
     174static inline float32_t floorf(float32_t val)
     175{
     176        return floor_f32(val);
     177}
     178
    48179static inline float64_t fmod(float64_t dividend, float64_t divisor)
    49180{
    50         return float64_mod(dividend, divisor);
     181        return fmod_f64(dividend, divisor);
     182}
     183
     184static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     185{
     186        return fmod_f32(dividend, divisor);
     187}
     188
     189static inline float64_t log(float64_t val)
     190{
     191        return log_f64(val);
     192}
     193
     194static inline float32_t logf(float32_t val)
     195{
     196        return log_f32(val);
     197}
     198
     199static inline float64_t pow(float64_t x, float64_t y)
     200{
     201        return pow_f64(x, y);
     202}
     203
     204static inline float32_t powf(float32_t x, float32_t y)
     205{
     206        return pow_f32(x, y);
     207}
     208
     209static inline float64_t sin(float64_t val)
     210{
     211        return sin_f64(val);
     212}
     213
     214static inline float32_t sinf(float32_t val)
     215{
     216        return sin_f32(val);
    51217}
    52218
    53219static inline float64_t trunc(float64_t val)
    54220{
    55         return float64_trunc(val);
    56 }
    57 
    58 static inline float64_t ceil(float64_t val)
    59 {
    60         return float64_ceil(val);
    61 }
    62 
    63 static inline float32_t expf(float32_t val)
    64 {
    65         return float32_exp(val);
    66 }
    67 
    68 static inline float64_t exp(float64_t val)
    69 {
    70         return float64_exp(val);
    71 }
    72 
    73 static inline float64_t floor(float64_t val)
    74 {
    75         return float64_floor(val);
    76 }
    77 
    78 static inline float32_t logf(float32_t val)
    79 {
    80         return float32_log(val);
    81 }
    82 
    83 static inline float64_t log(float64_t val)
    84 {
    85         return float64_log(val);
    86 }
    87 
    88 static inline float32_t powf(float32_t x, float32_t y)
    89 {
    90         return float32_pow(x, y);
    91 }
    92 
    93 static inline float64_t pow(float64_t x, float64_t y)
    94 {
    95         return float64_pow(x, y);
    96 }
    97 
    98 static inline float64_t sin(float64_t val)
    99 {
    100         return float64_sin(val);
    101 }
    102 
    103 static inline float64_t cos(float64_t val)
    104 {
    105         return float64_cos(val);
     221        return trunc_f64(val);
     222}
     223
     224static inline float32_t truncf(float32_t val)
     225{
     226        return trunc_f32(val);
    106227}
    107228

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <trig.h>
    4748
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59static inline float64_t cos_f64(float64_t val)
     60{
     61        return float64_cos(val);
     62}
     63
     64static inline float32_t cos_f32(float32_t val)
     65{
     66        return float32_cos(val);
     67}
     68
     69static inline float64_t exp_f64(float64_t val)
     70{
     71        return float64_exp(val);
     72}
     73
     74static inline float32_t exp_f32(float32_t val)
     75{
     76        return float32_exp(val);
     77}
     78
     79static inline float64_t floor_f64(float64_t val)
     80{
     81        return float64_floor(val);
     82}
     83
     84static inline float32_t floor_f32(float32_t val)
     85{
     86        return float32_floor(val);
     87}
     88
     89static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     90{
     91        return float64_mod(dividend, divisor);
     92}
     93
     94static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     95{
     96        return float32_mod(dividend, divisor);
     97}
     98
     99static inline float64_t log_f64(float64_t val)
     100{
     101        return float64_log(val);
     102}
     103
     104static inline float32_t log_f32(float32_t val)
     105{
     106        return float32_log(val);
     107}
     108
     109static inline float64_t pow_f64(float64_t x, float64_t y)
     110{
     111        return float64_pow(x, y);
     112}
     113
     114static inline float32_t pow_f32(float32_t x, float32_t y)
     115{
     116        return float32_pow(x, y);
     117}
     118
     119static inline float64_t sin_f64(float64_t val)
     120{
     121        return float64_sin(val);
     122}
     123
     124static inline float32_t sin_f32(float32_t val)
     125{
     126        return float32_sin(val);
     127}
     128
     129static inline float64_t trunc_f64(float64_t val)
     130{
     131        return float64_trunc(val);
     132}
     133
     134static inline float32_t trunc_f32(float32_t val)
     135{
     136        return float32_trunc(val);
     137}
     138
     139static inline float64_t ceil(float64_t val)
     140{
     141        return ceil_f64(val);
     142}
     143
     144static inline float32_t ceilf(float32_t val)
     145{
     146        return ceil_f32(val);
     147}
     148
     149static inline float64_t cos(float64_t val)
     150{
     151        return cos_f64(val);
     152}
     153
     154static inline float32_t cosf(float32_t val)
     155{
     156        return cos_f32(val);
     157}
     158
     159static inline float64_t exp(float64_t val)
     160{
     161        return exp_f64(val);
     162}
     163
     164static inline float32_t expf(float32_t val)
     165{
     166        return exp_f32(val);
     167}
     168
     169static inline float64_t floor(float64_t val)
     170{
     171        return floor_f64(val);
     172}
     173
     174static inline float32_t floorf(float32_t val)
     175{
     176        return floor_f32(val);
     177}
     178
    48179static inline float64_t fmod(float64_t dividend, float64_t divisor)
    49180{
    50         return float64_mod(dividend, divisor);
     181        return fmod_f64(dividend, divisor);
     182}
     183
     184static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     185{
     186        return fmod_f32(dividend, divisor);
     187}
     188
     189static inline float64_t log(float64_t val)
     190{
     191        return log_f64(val);
     192}
     193
     194static inline float32_t logf(float32_t val)
     195{
     196        return log_f32(val);
     197}
     198
     199static inline float64_t pow(float64_t x, float64_t y)
     200{
     201        return pow_f64(x, y);
     202}
     203
     204static inline float32_t powf(float32_t x, float32_t y)
     205{
     206        return pow_f32(x, y);
     207}
     208
     209static inline float64_t sin(float64_t val)
     210{
     211        return sin_f64(val);
     212}
     213
     214static inline float32_t sinf(float32_t val)
     215{
     216        return sin_f32(val);
    51217}
    52218
    53219static inline float64_t trunc(float64_t val)
    54220{
    55         return float64_trunc(val);
    56 }
    57 
    58 static inline float64_t ceil(float64_t val)
    59 {
    60         return float64_ceil(val);
    61 }
    62 
    63 static inline float32_t expf(float32_t val)
    64 {
    65         return float32_exp(val);
    66 }
    67 
    68 static inline float64_t exp(float64_t val)
    69 {
    70         return float64_exp(val);
    71 }
    72 
    73 static inline float64_t floor(float64_t val)
    74 {
    75         return float64_floor(val);
    76 }
    77 
    78 static inline float32_t logf(float32_t val)
    79 {
    80         return float32_log(val);
    81 }
    82 
    83 static inline float64_t log(float64_t val)
    84 {
    85         return float64_log(val);
    86 }
    87 
    88 static inline float32_t powf(float32_t x, float32_t y)
    89 {
    90         return float32_pow(x, y);
    91 }
    92 
    93 static inline float64_t pow(float64_t x, float64_t y)
    94 {
    95         return float64_pow(x, y);
    96 }
    97 
    98 static inline float64_t sin(float64_t val)
    99 {
    100         return float64_sin(val);
    101 }
    102 
    103 static inline float64_t cos(float64_t val)
    104 {
    105         return float64_cos(val);
     221        return trunc_f64(val);
     222}
     223
     224static inline float32_t truncf(float32_t val)
     225{
     226        return trunc_f32(val);
    106227}
    107228

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <trig.h>
    4748
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59static inline float64_t cos_f64(float64_t val)
     60{
     61        return float64_cos(val);
     62}
     63
     64static inline float32_t cos_f32(float32_t val)
     65{
     66        return float32_cos(val);
     67}
     68
     69static inline float64_t exp_f64(float64_t val)
     70{
     71        return float64_exp(val);
     72}
     73
     74static inline float32_t exp_f32(float32_t val)
     75{
     76        return float32_exp(val);
     77}
     78
     79static inline float64_t floor_f64(float64_t val)
     80{
     81        return float64_floor(val);
     82}
     83
     84static inline float32_t floor_f32(float32_t val)
     85{
     86        return float32_floor(val);
     87}
     88
     89static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     90{
     91        return float64_mod(dividend, divisor);
     92}
     93
     94static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     95{
     96        return float32_mod(dividend, divisor);
     97}
     98
     99static inline float64_t log_f64(float64_t val)
     100{
     101        return float64_log(val);
     102}
     103
     104static inline float32_t log_f32(float32_t val)
     105{
     106        return float32_log(val);
     107}
     108
     109static inline float64_t pow_f64(float64_t x, float64_t y)
     110{
     111        return float64_pow(x, y);
     112}
     113
     114static inline float32_t pow_f32(float32_t x, float32_t y)
     115{
     116        return float32_pow(x, y);
     117}
     118
     119static inline float64_t sin_f64(float64_t val)
     120{
     121        return float64_sin(val);
     122}
     123
     124static inline float32_t sin_f32(float32_t val)
     125{
     126        return float32_sin(val);
     127}
     128
     129static inline float64_t trunc_f64(float64_t val)
     130{
     131        return float64_trunc(val);
     132}
     133
     134static inline float32_t trunc_f32(float32_t val)
     135{
     136        return float32_trunc(val);
     137}
     138
     139static inline float64_t ceil(float64_t val)
     140{
     141        return ceil_f64(val);
     142}
     143
     144static inline float32_t ceilf(float32_t val)
     145{
     146        return ceil_f32(val);
     147}
     148
     149static inline float64_t cos(float64_t val)
     150{
     151        return cos_f64(val);
     152}
     153
     154static inline float32_t cosf(float32_t val)
     155{
     156        return cos_f32(val);
     157}
     158
     159static inline float64_t exp(float64_t val)
     160{
     161        return exp_f64(val);
     162}
     163
     164static inline float32_t expf(float32_t val)
     165{
     166        return exp_f32(val);
     167}
     168
     169static inline float64_t floor(float64_t val)
     170{
     171        return floor_f64(val);
     172}
     173
     174static inline float32_t floorf(float32_t val)
     175{
     176        return floor_f32(val);
     177}
     178
    48179static inline float64_t fmod(float64_t dividend, float64_t divisor)
    49180{
    50         return float64_mod(dividend, divisor);
     181        return fmod_f64(dividend, divisor);
     182}
     183
     184static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     185{
     186        return fmod_f32(dividend, divisor);
     187}
     188
     189static inline float64_t log(float64_t val)
     190{
     191        return log_f64(val);
     192}
     193
     194static inline float32_t logf(float32_t val)
     195{
     196        return log_f32(val);
     197}
     198
     199static inline float64_t pow(float64_t x, float64_t y)
     200{
     201        return pow_f64(x, y);
     202}
     203
     204static inline float32_t powf(float32_t x, float32_t y)
     205{
     206        return pow_f32(x, y);
     207}
     208
     209static inline float64_t sin(float64_t val)
     210{
     211        return sin_f64(val);
     212}
     213
     214static inline float32_t sinf(float32_t val)
     215{
     216        return sin_f32(val);
    51217}
    52218
    53219static inline float64_t trunc(float64_t val)
    54220{
    55         return float64_trunc(val);
    56 }
    57 
    58 static inline float64_t ceil(float64_t val)
    59 {
    60         return float64_ceil(val);
    61 }
    62 
    63 static inline float32_t expf(float32_t val)
    64 {
    65         return float32_exp(val);
    66 }
    67 
    68 static inline float64_t exp(float64_t val)
    69 {
    70         return float64_exp(val);
    71 }
    72 
    73 static inline float64_t floor(float64_t val)
    74 {
    75         return float64_floor(val);
    76 }
    77 
    78 static inline float32_t logf(float32_t val)
    79 {
    80         return float32_log(val);
    81 }
    82 
    83 static inline float64_t log(float64_t val)
    84 {
    85         return float64_log(val);
    86 }
    87 
    88 static inline float32_t powf(float32_t x, float32_t y)
    89 {
    90         return float32_pow(x, y);
    91 }
    92 
    93 static inline float64_t pow(float64_t x, float64_t y)
    94 {
    95         return float64_pow(x, y);
    96 }
    97 
    98 static inline float64_t sin(float64_t val)
    99 {
    100         return float64_sin(val);
    101 }
    102 
    103 static inline float64_t cos(float64_t val)
    104 {
    105         return float64_cos(val);
     221        return trunc_f64(val);
     222}
     223
     224static inline float32_t truncf(float32_t val)
     225{
     226        return trunc_f32(val);
    106227}
    107228

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <trig.h>
    4748
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59static inline float64_t cos_f64(float64_t val)
     60{
     61        return float64_cos(val);
     62}
     63
     64static inline float32_t cos_f32(float32_t val)
     65{
     66        return float32_cos(val);
     67}
     68
     69static inline float64_t exp_f64(float64_t val)
     70{
     71        return float64_exp(val);
     72}
     73
     74static inline float32_t exp_f32(float32_t val)
     75{
     76        return float32_exp(val);
     77}
     78
     79static inline float64_t floor_f64(float64_t val)
     80{
     81        return float64_floor(val);
     82}
     83
     84static inline float32_t floor_f32(float32_t val)
     85{
     86        return float32_floor(val);
     87}
     88
     89static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     90{
     91        return float64_mod(dividend, divisor);
     92}
     93
     94static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     95{
     96        return float32_mod(dividend, divisor);
     97}
     98
     99static inline float64_t log_f64(float64_t val)
     100{
     101        return float64_log(val);
     102}
     103
     104static inline float32_t log_f32(float32_t val)
     105{
     106        return float32_log(val);
     107}
     108
     109static inline float64_t pow_f64(float64_t x, float64_t y)
     110{
     111        return float64_pow(x, y);
     112}
     113
     114static inline float32_t pow_f32(float32_t x, float32_t y)
     115{
     116        return float32_pow(x, y);
     117}
     118
     119static inline float64_t sin_f64(float64_t val)
     120{
     121        return float64_sin(val);
     122}
     123
     124static inline float32_t sin_f32(float32_t val)
     125{
     126        return float32_sin(val);
     127}
     128
     129static inline float64_t trunc_f64(float64_t val)
     130{
     131        return float64_trunc(val);
     132}
     133
     134static inline float32_t trunc_f32(float32_t val)
     135{
     136        return float32_trunc(val);
     137}
     138
     139static inline float64_t ceil(float64_t val)
     140{
     141        return ceil_f64(val);
     142}
     143
     144static inline float32_t ceilf(float32_t val)
     145{
     146        return ceil_f32(val);
     147}
     148
     149static inline float64_t cos(float64_t val)
     150{
     151        return cos_f64(val);
     152}
     153
     154static inline float32_t cosf(float32_t val)
     155{
     156        return cos_f32(val);
     157}
     158
     159static inline float64_t exp(float64_t val)
     160{
     161        return exp_f64(val);
     162}
     163
     164static inline float32_t expf(float32_t val)
     165{
     166        return exp_f32(val);
     167}
     168
     169static inline float64_t floor(float64_t val)
     170{
     171        return floor_f64(val);
     172}
     173
     174static inline float32_t floorf(float32_t val)
     175{
     176        return floor_f32(val);
     177}
     178
    48179static inline float64_t fmod(float64_t dividend, float64_t divisor)
    49180{
    50         return float64_mod(dividend, divisor);
    51 }
    52 
    53 static inline double trunc(double val)
    54 {
    55         return float64_trunc(val);
    56 }
    57 
    58 static inline float64_t ceil(float64_t val)
    59 {
    60         return float64_ceil(val);
    61 }
    62 
    63 static inline float32_t expf(float32_t val)
    64 {
    65         return float32_exp(val);
    66 }
    67 
    68 static inline float64_t exp(float64_t val)
    69 {
    70         return float64_exp(val);
    71 }
    72 
    73 static inline float64_t floor(float64_t val)
    74 {
    75         return float64_floor(val);
     181        return fmod_f64(dividend, divisor);
     182}
     183
     184static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     185{
     186        return fmod_f32(dividend, divisor);
     187}
     188
     189static inline float64_t log(float64_t val)
     190{
     191        return log_f64(val);
    76192}
    77193
    78194static inline float32_t logf(float32_t val)
    79195{
    80         return float32_log(val);
    81 }
    82 
    83 static inline float64_t log(float64_t val)
    84 {
    85         return float64_log(val);
     196        return log_f32(val);
     197}
     198
     199static inline float64_t pow(float64_t x, float64_t y)
     200{
     201        return pow_f64(x, y);
    86202}
    87203
    88204static inline float32_t powf(float32_t x, float32_t y)
    89205{
    90         return float32_pow(x, y);
    91 }
    92 
    93 static inline float64_t pow(float64_t x, float64_t y)
    94 {
    95         return float64_pow(x, y);
    96 }
    97 
     206        return pow_f32(x, y);
     207}
    98208
    99209static inline float64_t sin(float64_t val)
    100210{
    101         return float64_sin(val);
    102 }
    103 
    104 static inline float64_t cos(float64_t val)
    105 {
    106         return float64_cos(val);
     211        return sin_f64(val);
     212}
     213
     214static inline float32_t sinf(float32_t val)
     215{
     216        return sin_f32(val);
     217}
     218
     219static inline float64_t trunc(float64_t val)
     220{
     221        return trunc_f64(val);
     222}
     223
     224static inline float32_t truncf(float32_t val)
     225{
     226        return trunc_f32(val);
    107227}
    108228

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <trig.h>
    4748
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59static inline float64_t cos_f64(float64_t val)
     60{
     61        return float64_cos(val);
     62}
     63
     64static inline float32_t cos_f32(float32_t val)
     65{
     66        return float32_cos(val);
     67}
     68
     69static inline float64_t exp_f64(float64_t val)
     70{
     71        return float64_exp(val);
     72}
     73
     74static inline float32_t exp_f32(float32_t val)
     75{
     76        return float32_exp(val);
     77}
     78
     79static inline float64_t floor_f64(float64_t val)
     80{
     81        return float64_floor(val);
     82}
     83
     84static inline float32_t floor_f32(float32_t val)
     85{
     86        return float32_floor(val);
     87}
     88
     89static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     90{
     91        return float64_mod(dividend, divisor);
     92}
     93
     94static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     95{
     96        return float32_mod(dividend, divisor);
     97}
     98
     99static inline float64_t log_f64(float64_t val)
     100{
     101        return float64_log(val);
     102}
     103
     104static inline float32_t log_f32(float32_t val)
     105{
     106        return float32_log(val);
     107}
     108
     109static inline float64_t pow_f64(float64_t x, float64_t y)
     110{
     111        return float64_pow(x, y);
     112}
     113
     114static inline float32_t pow_f32(float32_t x, float32_t y)
     115{
     116        return float32_pow(x, y);
     117}
     118
     119static inline float64_t sin_f64(float64_t val)
     120{
     121        return float64_sin(val);
     122}
     123
     124static inline float32_t sin_f32(float32_t val)
     125{
     126        return float32_sin(val);
     127}
     128
     129static inline float64_t trunc_f64(float64_t val)
     130{
     131        return float64_trunc(val);
     132}
     133
     134static inline float32_t trunc_f32(float32_t val)
     135{
     136        return float32_trunc(val);
     137}
     138
     139static inline float64_t ceil(float64_t val)
     140{
     141        return ceil_f64(val);
     142}
     143
     144static inline float32_t ceilf(float32_t val)
     145{
     146        return ceil_f32(val);
     147}
     148
     149static inline float64_t cos(float64_t val)
     150{
     151        return cos_f64(val);
     152}
     153
     154static inline float32_t cosf(float32_t val)
     155{
     156        return cos_f32(val);
     157}
     158
     159static inline float64_t exp(float64_t val)
     160{
     161        return exp_f64(val);
     162}
     163
     164static inline float32_t expf(float32_t val)
     165{
     166        return exp_f32(val);
     167}
     168
     169static inline float64_t floor(float64_t val)
     170{
     171        return floor_f64(val);
     172}
     173
     174static inline float32_t floorf(float32_t val)
     175{
     176        return floor_f32(val);
     177}
     178
    48179static inline float64_t fmod(float64_t dividend, float64_t divisor)
    49180{
    50         return float64_mod(dividend, divisor);
     181        return fmod_f64(dividend, divisor);
     182}
     183
     184static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     185{
     186        return fmod_f32(dividend, divisor);
     187}
     188
     189static inline float64_t log(float64_t val)
     190{
     191        return log_f64(val);
     192}
     193
     194static inline float32_t logf(float32_t val)
     195{
     196        return log_f32(val);
     197}
     198
     199static inline float64_t pow(float64_t x, float64_t y)
     200{
     201        return pow_f64(x, y);
     202}
     203
     204static inline float32_t powf(float32_t x, float32_t y)
     205{
     206        return pow_f32(x, y);
     207}
     208
     209static inline float64_t sin(float64_t val)
     210{
     211        return sin_f64(val);
     212}
     213
     214static inline float32_t sinf(float32_t val)
     215{
     216        return sin_f32(val);
    51217}
    52218
    53219static inline float64_t trunc(float64_t val)
    54220{
    55         return float64_trunc(val);
    56 }
    57 
    58 static inline float64_t ceil(float64_t val)
    59 {
    60         return float64_ceil(val);
    61 }
    62 
    63 static inline float32_t expf(float32_t val)
    64 {
    65         return float32_exp(val);
    66 }
    67 
    68 static inline float64_t exp(float64_t val)
    69 {
    70         return float64_exp(val);
    71 }
    72 
    73 static inline float64_t floor(float64_t val)
    74 {
    75         return float64_floor(val);
    76 }
    77 
    78 static inline float32_t logf(float32_t val)
    79 {
    80         return float32_log(val);
    81 }
    82 
    83 static inline float64_t log(float64_t val)
    84 {
    85         return float64_log(val);
    86 }
    87 
    88 static inline float32_t powf(float32_t x, float32_t y)
    89 {
    90         return float32_pow(x, y);
    91 }
    92 
    93 static inline float64_t pow(float64_t x, float64_t y)
    94 {
    95         return float64_pow(x, y);
    96 }
    97 
    98 static inline float64_t sin(float64_t val)
    99 {
    100         return float64_sin(val);
    101 }
    102 
    103 static inline float64_t cos(float64_t val)
    104 {
    105         return float64_cos(val);
     221        return trunc_f64(val);
     222}
     223
     224static inline float32_t truncf(float32_t val)
     225{
     226        return trunc_f32(val);
    106227}
    107228

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

    re6f5766 r9adb61d  
    11/*
    22 * Copyright (c) 2014 Martin Decky
     3 * Copyright (c) 2015 Jiri Svoboda
    34 * All rights reserved.
    45 *
    … …  
    4647#include <trig.h>
    4748
     49static inline float64_t ceil_f64(float64_t val)
     50{
     51        return float64_ceil(val);
     52}
     53
     54static inline float32_t ceil_f32(float32_t val)
     55{
     56        return float32_ceil(val);
     57}
     58
     59static inline float64_t cos_f64(float64_t val)
     60{
     61        return float64_cos(val);
     62}
     63
     64static inline float32_t cos_f32(float32_t val)
     65{
     66        return float32_cos(val);
     67}
     68
     69static inline float64_t exp_f64(float64_t val)
     70{
     71        return float64_exp(val);
     72}
     73
     74static inline float32_t exp_f32(float32_t val)
     75{
     76        return float32_exp(val);
     77}
     78
     79static inline float64_t floor_f64(float64_t val)
     80{
     81        return float64_floor(val);
     82}
     83
     84static inline float32_t floor_f32(float32_t val)
     85{
     86        return float32_floor(val);
     87}
     88
     89static inline float64_t fmod_f64(float64_t dividend, float64_t divisor)
     90{
     91        return float64_mod(dividend, divisor);
     92}
     93
     94static inline float64_t fmod_f32(float32_t dividend, float32_t divisor)
     95{
     96        return float32_mod(dividend, divisor);
     97}
     98
     99static inline float64_t log_f64(float64_t val)
     100{
     101        return float64_log(val);
     102}
     103
     104static inline float32_t log_f32(float32_t val)
     105{
     106        return float32_log(val);
     107}
     108
     109static inline float64_t pow_f64(float64_t x, float64_t y)
     110{
     111        return float64_pow(x, y);
     112}
     113
     114static inline float32_t pow_f32(float32_t x, float32_t y)
     115{
     116        return float32_pow(x, y);
     117}
     118
     119static inline float64_t sin_f64(float64_t val)
     120{
     121        return float64_sin(val);
     122}
     123
     124static inline float32_t sin_f32(float32_t val)
     125{
     126        return float32_sin(val);
     127}
     128
     129static inline float64_t trunc_f64(float64_t val)
     130{
     131        return float64_trunc(val);
     132}
     133
     134static inline float32_t trunc_f32(float32_t val)
     135{
     136        return float32_trunc(val);
     137}
     138
     139static inline float64_t ceil(float64_t val)
     140{
     141        return ceil_f64(val);
     142}
     143
     144static inline float32_t ceilf(float32_t val)
     145{
     146        return ceil_f32(val);
     147}
     148
     149static inline float64_t cos(float64_t val)
     150{
     151        return cos_f64(val);
     152}
     153
     154static inline float32_t cosf(float32_t val)
     155{
     156        return cos_f32(val);
     157}
     158
     159static inline float64_t exp(float64_t val)
     160{
     161        return exp_f64(val);
     162}
     163
     164static inline float32_t expf(float32_t val)
     165{
     166        return exp_f32(val);
     167}
     168
     169static inline float64_t floor(float64_t val)
     170{
     171        return floor_f64(val);
     172}
     173
     174static inline float32_t floorf(float32_t val)
     175{
     176        return floor_f32(val);
     177}
     178
    48179static inline float64_t fmod(float64_t dividend, float64_t divisor)
    49180{
    50         return float64_mod(dividend, divisor);
     181        return fmod_f64(dividend, divisor);
     182}
     183
     184static inline float32_t fmodf(float32_t dividend, float32_t divisor)
     185{
     186        return fmod_f32(dividend, divisor);
     187}
     188
     189static inline float64_t log(float64_t val)
     190{
     191        return log_f64(val);
     192}
     193
     194static inline float32_t logf(float32_t val)
     195{
     196        return log_f32(val);
     197}
     198
     199static inline float64_t pow(float64_t x, float64_t y)
     200{
     201        return pow_f64(x, y);
     202}
     203
     204static inline float32_t powf(float32_t x, float32_t y)
     205{
     206        return pow_f32(x, y);
     207}
     208
     209static inline float64_t sin(float64_t val)
     210{
     211        return sin_f64(val);
     212}
     213
     214static inline float32_t sinf(float32_t val)
     215{
     216        return sin_f32(val);
    51217}
    52218
    53219static inline float64_t trunc(float64_t val)
    54220{
    55         return float64_trunc(val);
    56 }
    57 
    58 static inline float64_t ceil(float64_t val)
    59 {
    60         return float64_ceil(val);
    61 }
    62 
    63 static inline float32_t expf(float32_t val)
    64 {
    65         return float32_exp(val);
    66 }
    67 
    68 static inline float64_t exp(float64_t val)
    69 {
    70         return float64_exp(val);
    71 }
    72 
    73 static inline float64_t floor(float64_t val)
    74 {
    75         return float64_floor(val);
    76 }
    77 
    78 static inline float32_t logf(float32_t val)
    79 {
    80         return float32_log(val);
    81 }
    82 
    83 static inline float64_t log(float64_t val)
    84 {
    85         return float64_log(val);
    86 }
    87 
    88 static inline float32_t powf(float32_t x, float32_t y)
    89 {
    90         return float32_pow(x, y);
    91 }
    92 
    93 static inline float64_t pow(float64_t x, float64_t y)
    94 {
    95         return float64_pow(x, y);
    96 }
    97 
    98 
    99 static inline float64_t sin(float64_t val)
    100 {
    101         return float64_sin(val);
    102 }
    103 
    104 static inline float64_t cos(float64_t val)
    105 {
    106         return float64_cos(val);
     221        return trunc_f64(val);
     222}
     223
     224static inline float32_t truncf(float32_t val)
     225{
     226        return trunc_f32(val);
    107227}
    108228
Note: See TracChangeset for help on using the changeset viewer.