Changeset 9adb61d in mainline


Ignore:
Timestamp:
2015-09-05T11:50:00Z (9 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
Files:
28 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

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

    re6f5766 r9adb61d  
    3434
    3535#include <ceil.h>
     36#include <math.h>
    3637#include <mathtypes.h>
    37 #include <trunc.h>
    3838
    39 /** Ceiling (round towards positive infinity)
     39/** Ceiling (round towards positive infinity, 32-bit floating point)
     40 *
     41 * @param val Floating point number.
     42 *
     43 * @return Number rounded towards positive infinity.
     44 */
     45float32_t float32_ceil(float32_t val)
     46{
     47        float32_u t;
     48        float32_u v;
     49        float32_u r;
     50       
     51        v.val = val;
     52        t.val = trunc_f32(val);
     53       
     54        if (v.data.parts.sign == 1 || val == t.val) {
     55                r = t;
     56        } else {
     57                r.val = t.val + 1.0;
     58        }
     59       
     60        return r.val;
     61}
     62
     63/** Ceiling (round towards positive infinity, 64-bit floating point)
    4064 *
    4165 * @param val Floating point number.
    … …  
    5074       
    5175        v.val = val;
    52         t.val = float64_trunc(val);
     76        t.val = trunc_f64(val);
    5377       
    5478        if (v.data.parts.sign == 1 || val == t.val) {

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

    re6f5766 r9adb61d  
    4949};
    5050
    51 /** Exponential approximation by Taylor series (32-))
     51/** Exponential approximation by Taylor series (32-bit floating point)
    5252 *
    5353 * Compute the approximation of exponential by a Taylor
    … …  
    6161 *
    6262 */
    63 static float64_t taylor_exp_32(float64_t arg)
     63static float32_t taylor_exp_32(float32_t arg)
    6464{
    65         float64_t ret = 1;
    66         float64_t nom = 1;
     65        float32_t ret = 1;
     66        float32_t nom = 1;
    6767       
    6868        for (unsigned int i = 0; i < TAYLOR_DEGREE_32; i++) {
    … …  
    7474}
    7575
    76 /** Exponential approximation by Taylor series
     76/** Exponential approximation by Taylor series (64-bit floating point)
    7777 *
    7878 * Compute the approximation of exponential by a Taylor
    … …  
    9999}
    100100
    101 /** Single precision exponential
     101/** Exponential (32-bit floating point)
    102102 *
    103103 * Compute exponential value.
    … …  
    121121         */
    122122
    123         i = float32_trunc(arg * M_LOG2E);
     123        i = trunc_f32(arg * M_LOG2E);
    124124        f = arg * M_LOG2E - i;
    125125
    … …  
    129129}
    130130
    131 /** Double precision exponential
     131/** Exponential (64-bit floating point)
    132132 *
    133133 * Compute exponential value.
    … …  
    151151         */
    152152
    153         i = float64_trunc(arg * M_LOG2E);
     153        i = trunc_f64(arg * M_LOG2E);
    154154        f = arg * M_LOG2E - i;
    155155

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

    re6f5766 r9adb61d  
    3434
    3535#include <floor.h>
     36#include <math.h>
    3637#include <mathtypes.h>
    37 #include <trunc.h>
    3838
    39 /** Ceiling (round towards negative infinity)
     39/** Ceiling (round towards negative infinity, 32-bit floating point)
     40 *
     41 * @param val Floating point number.
     42 *
     43 * @return Number rounded towards negative infinity.
     44 */
     45
     46float32_t float32_floor(float32_t val)
     47{
     48        float32_t t;
     49        float32_u v;
     50       
     51        v.val = val;
     52        t = trunc_f32(val);
     53       
     54        if (v.data.parts.sign == 0 || val == t)
     55                return t;
     56        else
     57                return t - 1.0;
     58}
     59
     60/** Ceiling (round towards negative infinity, 64-bit floating point)
    4061 *
    4162 * @param val Floating point number.
    … …  
    5071       
    5172        v.val = val;
    52         t = float64_trunc(val);
     73        t = trunc_f64(val);
    5374       
    5475        if (v.data.parts.sign == 0 || val == t)

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

    re6f5766 r9adb61d  
    4040#define TAYLOR_DEGREE_64  63
    4141
    42 /** Single precision log(1 - arg) approximation by Taylor series
     42/** log(1 - arg) approximation by Taylor series (32-bit floating point)
    4343 *
    4444 * Compute the approximation of log(1 - arg) by a Taylor
    … …  
    6868}
    6969
    70 /** Double precision log(1 - arg) approximation by Taylor series
     70/** log(1 - arg) approximation by Taylor series (64-bit floating point)
    7171 *
    7272 * Compute the approximation of log(1 - arg) by a Taylor
    … …  
    9696}
    9797
    98 /** Single precision logarithm
     98/** Natural logarithm (32-bit floating point)
    9999 *
    100100 * @param arg Argument.
    … …  
    126126}
    127127
    128 /** Double precision logarithm
     128/** Natural logarithm (64-bit floating point)
    129129 *
    130130 * @param arg Argument.

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

    re6f5766 r9adb61d  
    3636#include <mod.h>
    3737
    38 /** Double precision modulo
     38/** Remainder function (32-bit floating point)
     39 *
     40 * Calculate the modulo of dividend by divisor.
     41 *
     42 * This is a very basic implementation that uses
     43 * division and multiplication (instead of exact
     44 * arithmetics). Thus the result might be very
     45 * imprecise (depending on the magnitude of the
     46 * arguments).
     47 *
     48 * @param dividend Dividend.
     49 * @param divisor  Divisor.
     50 *
     51 * @return Modulo.
     52 *
     53 */
     54float32_t float32_mod(float32_t dividend, float32_t divisor)
     55{
     56        // FIXME: replace with exact arithmetics
     57       
     58        float32_t quotient = trunc_f32(dividend / divisor);
     59       
     60        return (dividend - quotient * divisor);
     61}
     62
     63/** Remainder function (64-bit floating point)
    3964 *
    4065 * Calculate the modulo of dividend by divisor.
    … …  
    5681        // FIXME: replace with exact arithmetics
    5782       
    58         float64_t quotient = trunc(dividend / divisor);
     83        float64_t quotient = trunc_f64(dividend / divisor);
    5984       
    6085        return (dividend - quotient * divisor);

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

    re6f5766 r9adb61d  
    5252{
    5353        /* x^y = (e ^ log(x))^y = e ^ (log(x) * y) */
    54         return float32_exp(float32_log(x) * y);
     54        return exp_f32(log_f32(x) * y);
    5555}
    5656
    … …  
    6868{
    6969        /* x^y = (e ^ log(x))^y = e ^ (log(x) * y) */
    70         return float64_exp(float64_log(x) * y);
     70        return exp_f64(log_f64(x) * y);
    7171}
    7272

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

    re6f5766 r9adb61d  
    11/*
     2 * Copyright (c) 2015 Jiri Svoboda
    23 * Copyright (c) 2014 Martin Decky
    34 * All rights reserved.
    … …  
    4748};
    4849
    49 /** Sine approximation by Taylor series
     50/** Sine approximation by Taylor series (32-bit floating point)
    5051 *
    5152 * Compute the approximation of sine by a Taylor
    … …  
    5960 *
    6061 */
    61 static float64_t taylor_sin(float64_t arg)
     62static float32_t taylor_sin_32(float32_t arg)
     63{
     64        float32_t ret = 0;
     65        float32_t nom = 1;
     66       
     67        for (unsigned int i = 0; i < TAYLOR_DEGREE_32; i++) {
     68                nom *= arg;
     69               
     70                if ((i % 4) == 0)
     71                        ret += nom / factorials[i];
     72                else if ((i % 4) == 2)
     73                        ret -= nom / factorials[i];
     74        }
     75       
     76        return ret;
     77}
     78
     79/** Sine approximation by Taylor series (64-bit floating point)
     80 *
     81 * Compute the approximation of sine by a Taylor
     82 * series (using the first TAYLOR_DEGREE terms).
     83 * The approximation is reasonably accurate for
     84 * arguments within the interval [-pi/4, pi/4].
     85 *
     86 * @param arg Sine argument.
     87 *
     88 * @return Sine value approximation.
     89 *
     90 */
     91static float64_t taylor_sin_64(float64_t arg)
    6292{
    6393        float64_t ret = 0;
    … …  
    76106}
    77107
    78 /** Cosine approximation by Taylor series
     108/** Cosine approximation by Taylor series (32-bit floating point)
    79109 *
    80110 * Compute the approximation of cosine by a Taylor
    … …  
    88118 *
    89119 */
    90 static float64_t taylor_cos(float64_t arg)
     120static float32_t taylor_cos_32(float32_t arg)
     121{
     122        float32_t ret = 1;
     123        float32_t nom = 1;
     124       
     125        for (unsigned int i = 0; i < TAYLOR_DEGREE_32; i++) {
     126                nom *= arg;
     127               
     128                if ((i % 4) == 1)
     129                        ret -= nom / factorials[i];
     130                else if ((i % 4) == 3)
     131                        ret += nom / factorials[i];
     132        }
     133       
     134        return ret;
     135}
     136
     137/** Cosine approximation by Taylor series (64-bit floating point)
     138 *
     139 * Compute the approximation of cosine by a Taylor
     140 * series (using the first TAYLOR_DEGREE terms).
     141 * The approximation is reasonably accurate for
     142 * arguments within the interval [-pi/4, pi/4].
     143 *
     144 * @param arg Cosine argument.
     145 *
     146 * @return Cosine value approximation.
     147 *
     148 */
     149static float64_t taylor_cos_64(float64_t arg)
    91150{
    92151        float64_t ret = 1;
    … …  
    105164}
    106165
    107 /** Sine value for values within base period
     166/** Sine value for values within base period (32-bit floating point)
    108167 *
    109168 * Compute the value of sine for arguments within
    … …  
    117176 *
    118177 */
    119 static float64_t base_sin(float64_t arg)
     178static float32_t base_sin_32(float32_t arg)
    120179{
    121180        unsigned int period = arg / (M_PI / 4);
    … …  
    123182        switch (period) {
    124183        case 0:
    125                 return taylor_sin(arg);
     184                return taylor_sin_32(arg);
    126185        case 1:
    127186        case 2:
    128                 return taylor_cos(arg - M_PI / 2);
     187                return taylor_cos_32(arg - M_PI / 2);
    129188        case 3:
    130189        case 4:
    131                 return -taylor_sin(arg - M_PI);
     190                return -taylor_sin_32(arg - M_PI);
    132191        case 5:
    133192        case 6:
    134                 return -taylor_cos(arg - 3 * M_PI / 2);
     193                return -taylor_cos_32(arg - 3 * M_PI / 2);
    135194        default:
    136                 return taylor_sin(arg - 2 * M_PI);
    137         }
    138 }
    139 
    140 /** Cosine value for values within base period
     195                return taylor_sin_32(arg - 2 * M_PI);
     196        }
     197}
     198
     199/** Sine value for values within base period (64-bit floating point)
     200 *
     201 * Compute the value of sine for arguments within
     202 * the base period [0, 2pi]. For arguments outside
     203 * the base period the returned values can be
     204 * very inaccurate or even completely wrong.
     205 *
     206 * @param arg Sine argument.
     207 *
     208 * @return Sine value.
     209 *
     210 */
     211static float64_t base_sin_64(float64_t arg)
     212{
     213        unsigned int period = arg / (M_PI / 4);
     214       
     215        switch (period) {
     216        case 0:
     217                return taylor_sin_64(arg);
     218        case 1:
     219        case 2:
     220                return taylor_cos_64(arg - M_PI / 2);
     221        case 3:
     222        case 4:
     223                return -taylor_sin_64(arg - M_PI);
     224        case 5:
     225        case 6:
     226                return -taylor_cos_64(arg - 3 * M_PI / 2);
     227        default:
     228                return taylor_sin_64(arg - 2 * M_PI);
     229        }
     230}
     231
     232/** Cosine value for values within base period (32-bit floating point)
    141233 *
    142234 * Compute the value of cosine for arguments within
    … …  
    150242 *
    151243 */
    152 static float64_t base_cos(float64_t arg)
     244static float32_t base_cos_32(float32_t arg)
    153245{
    154246        unsigned int period = arg / (M_PI / 4);
    … …  
    156248        switch (period) {
    157249        case 0:
    158                 return taylor_cos(arg);
     250                return taylor_cos_32(arg);
    159251        case 1:
    160252        case 2:
    161                 return -taylor_sin(arg - M_PI / 2);
     253                return -taylor_sin_32(arg - M_PI / 2);
    162254        case 3:
    163255        case 4:
    164                 return -taylor_cos(arg - M_PI);
     256                return -taylor_cos_32(arg - M_PI);
    165257        case 5:
    166258        case 6:
    167                 return taylor_sin(arg - 3 * M_PI / 2);
     259                return taylor_sin_32(arg - 3 * M_PI / 2);
    168260        default:
    169                 return taylor_cos(arg - 2 * M_PI);
    170         }
    171 }
    172 
    173 /** Double precision sine
     261                return taylor_cos_32(arg - 2 * M_PI);
     262        }
     263}
     264
     265/** Cosine value for values within base period (64-bit floating point)
     266 *
     267 * Compute the value of cosine for arguments within
     268 * the base period [0, 2pi]. For arguments outside
     269 * the base period the returned values can be
     270 * very inaccurate or even completely wrong.
     271 *
     272 * @param arg Cosine argument.
     273 *
     274 * @return Cosine value.
     275 *
     276 */
     277static float64_t base_cos_64(float64_t arg)
     278{
     279        unsigned int period = arg / (M_PI / 4);
     280       
     281        switch (period) {
     282        case 0:
     283                return taylor_cos_64(arg);
     284        case 1:
     285        case 2:
     286                return -taylor_sin_64(arg - M_PI / 2);
     287        case 3:
     288        case 4:
     289                return -taylor_cos_64(arg - M_PI);
     290        case 5:
     291        case 6:
     292                return taylor_sin_64(arg - 3 * M_PI / 2);
     293        default:
     294                return taylor_cos_64(arg - 2 * M_PI);
     295        }
     296}
     297
     298/** Sine (32-bit floating point)
    174299 *
    175300 * Compute sine value.
    … …  
    180305 *
    181306 */
     307float32_t float32_sin(float32_t arg)
     308{
     309        float32_t base_arg = fmod_f32(arg, 2 * M_PI);
     310       
     311        if (base_arg < 0)
     312                return -base_sin_32(-base_arg);
     313       
     314        return base_sin_32(base_arg);
     315}
     316
     317/** Sine (64-bit floating point)
     318 *
     319 * Compute sine value.
     320 *
     321 * @param arg Sine argument.
     322 *
     323 * @return Sine value.
     324 *
     325 */
    182326float64_t float64_sin(float64_t arg)
    183327{
    184         float64_t base_arg = fmod(arg, 2 * M_PI);
     328        float64_t base_arg = fmod_f64(arg, 2 * M_PI);
    185329       
    186330        if (base_arg < 0)
    187                 return -base_sin(-base_arg);
    188        
    189         return base_sin(base_arg);
    190 }
    191 
    192 /** Double precision cosine
     331                return -base_sin_64(-base_arg);
     332       
     333        return base_sin_64(base_arg);
     334}
     335
     336/** Cosine (32-bit floating point)
    193337 *
    194338 * Compute cosine value.
    … …  
    199343 *
    200344 */
     345float32_t float32_cos(float32_t arg)
     346{
     347        float32_t base_arg = fmod_f32(arg, 2 * M_PI);
     348       
     349        if (base_arg < 0)
     350                return base_cos_32(-base_arg);
     351       
     352        return base_cos_32(base_arg);
     353}
     354
     355/** Cosine (64-bit floating point)
     356 *
     357 * Compute cosine value.
     358 *
     359 * @param arg Cosine argument.
     360 *
     361 * @return Cosine value.
     362 *
     363 */
    201364float64_t float64_cos(float64_t arg)
    202365{
    203         float64_t base_arg = fmod(arg, 2 * M_PI);
     366        float64_t base_arg = fmod_f64(arg, 2 * M_PI);
    204367       
    205368        if (base_arg < 0)
    206                 return base_cos(-base_arg);
    207        
    208         return base_cos(base_arg);
     369                return base_cos_64(-base_arg);
     370       
     371        return base_cos_64(base_arg);
    209372}
    210373

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

    re6f5766 r9adb61d  
    11/*
     2 * Copyright (c) 2015 Jiri Svoboda
    23 * Copyright (c) 2014 Martin Decky
    34 * All rights reserved.

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

    re6f5766 r9adb61d  
    3838#include <mathtypes.h>
    3939
     40extern float32_t float32_ceil(float32_t);
    4041extern float64_t float64_ceil(float64_t);
    4142

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

    re6f5766 r9adb61d  
    3838#include <mathtypes.h>
    3939
     40extern float32_t float32_floor(float32_t);
    4041extern float64_t float64_floor(float64_t);
    4142

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

    re6f5766 r9adb61d  
    3636#define LIBMATH_MOD_H_
    3737
     38extern float32_t float32_mod(float32_t, float32_t);
    3839extern float64_t float64_mod(float64_t, float64_t);
    3940

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

    re6f5766 r9adb61d  
    3838#include <mathtypes.h>
    3939
     40extern float32_t float32_sin(float32_t);
    4041extern float64_t float64_sin(float64_t);
     42extern float32_t float32_cos(float32_t);
    4143extern float64_t float64_cos(float64_t);
    4244
Note: See TracChangeset for help on using the changeset viewer.