Changes in / [add371c:845cedc]


Ignore:
Location:
src
Files:
1 deleted
2 edited

Legend:

Unmodified
Added
Removed
  • src/libcfa/math

    radd371c r845cedc  
    1010// Created On       : Mon Apr 18 23:37:04 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Apr 24 12:45:02 2016
    13 // Update Count     : 59
     12// Last Modified On : Thu Apr 21 07:56:48 2016
     13// Update Count     : 38
    1414//
    1515
    16 extern "C" {
    17 #include <math.h>                                                                               // fpclassify, isfinite, isnormal, isnan, isinf
    18 } // extern "C"
    19 
    20 float fabs( float );
    21 // extern "C" { double fabs( double ); }
    22 long double fabs( long double );
    23 float cabs( float _Complex );
    24 // extern "C" { double cabs( double _Complex ); }
    25 long double cabs( long double _Complex );
    26 
    27 float ?%?( float, float );
    28 float fmod( float, float );
    29 double ?%?( double, double );
    30 // extern "C" { double fmod( double, double ); }
    31 long double ?%?( long double, long double );
    32 long double fmod( long double, long double );
    33 
    34 float remainder( float, float );
    35 // extern "C" { double remainder( double, double ); }
    36 long double remainder( long double, long double );
    37 
    38 [ int, float ] remquo( float, float );
    39 float remquo( float, float, int * );
    40 [ int, double ] remquo( double, double );
    41 // extern "C" { double remquo( double, double, int * ); }
    42 [ int, long double ] remquo( long double, long double );
    43 long double remquo( long double, long double, int * );
    44 
    45 [ int, float ] div( float, float );                                             // alternative name for remquo
    46 float div( float, float, int * );
    47 [ int, double ] div( double, double );
    48 // extern "C" { double div( double, double, int * ); }
    49 [ int, long double ] div( long double, long double );
    50 long double div( long double, long double, int * );
    51 
    52 float fma( float, float, float );
    53 // extern "C" { double fma( double, double, double ); }
    54 long double fma( long double, long double, long double );
    55 
    56 float fdim( float, float );
    57 // extern "C" { double fdim( double, double ); }
    58 long double fdim( long double, long double );
    59 
    60 float nan( const char * );
    61 // extern "C" { double nan( const char * ); }
    62 long double nan( const char * );
    63 
    64 //---------------------- Exponential ----------------------
     16float cos( float );
     17extern "C" { double cos( double ); }
     18long double cos( long double );
     19float _Complex cos( float _Complex );
     20double _Complex cos( double _Complex );
     21long double _Complex cos( long double _Complex );
     22
     23float cosh( float );
     24extern "C" { double cosh( double ); }
     25long double cosh( long double );
     26float _Complex cosh( float _Complex );
     27double _Complex cosh( double _Complex );
     28long double _Complex cosh( long double _Complex );
     29
     30float acos( float );
     31extern "C" { double acos( double ); }
     32long double acos( long double );
     33float _Complex acos( float _Complex );
     34double _Complex acos( double _Complex );
     35long double _Complex acos( long double _Complex );
     36
     37float acosh( float );
     38extern "C" { double acosh( double ); }
     39long double acosh( long double );
     40float _Complex acosh( float _Complex );
     41double _Complex acosh( double _Complex );
     42long double _Complex acosh( long double _Complex );
     43
     44float sin( float );
     45extern "C" { double sin( double ); }
     46long double sin( long double );
     47float _Complex sin( float _Complex );
     48double _Complex sin( double _Complex );
     49long double _Complex sin( long double _Complex );
     50
     51float sinh( float );
     52extern "C" { double sinh( double ); }
     53long double sinh( long double );
     54float _Complex sinh( float _Complex );
     55double _Complex sinh( double _Complex );
     56long double _Complex sinh( long double _Complex );
     57
     58float asin( float );
     59extern "C" { double asin( double ); }
     60long double asin( long double );
     61float _Complex asin( float _Complex );
     62double _Complex asin( double _Complex );
     63long double _Complex asin( long double _Complex );
     64
     65float asinh( float );
     66extern "C" { double asinh( double ); }
     67long double asinh( long double );
     68float _Complex asinh( float _Complex );
     69double _Complex asinh( double _Complex );
     70long double _Complex asinh( long double _Complex );
     71
     72float tan( float );
     73extern "C" { double tan( double ); }
     74long double tan( long double );
     75float _Complex tan( float _Complex );
     76double _Complex tan( double _Complex );
     77long double _Complex tan( long double _Complex );
     78
     79float tanh( float );
     80extern "C" { double tanh( double ); }
     81long double tanh( long double );
     82float _Complex tanh( float _Complex );
     83double _Complex tanh( double _Complex );
     84long double _Complex tanh( long double _Complex );
     85
     86float atan( float );
     87extern "C" { double atan( double ); }
     88long double atan( long double );
     89float _Complex atan( float _Complex );
     90double _Complex atan( double _Complex );
     91long double _Complex atan( long double _Complex );
     92
     93float _Complex atan( float, float );
     94double atan( double, double );
     95long double atan( long double, long double );
     96
     97float atanh( float );
     98extern "C" { double atanh( double ); }
     99long double atanh( long double );
     100float _Complex atanh( float _Complex );
     101double _Complex atanh( double _Complex );
     102long double _Complex atanh( long double _Complex );
    65103
    66104float exp( float );
    67 // extern "C" { double exp( double ); }
     105extern "C" { double exp( double ); }
    68106long double exp( long double );
    69107float _Complex exp( float _Complex );
     
    71109long double _Complex exp( long double _Complex );
    72110
    73 float exp2( float );
    74 // extern "C" { double exp2( double ); }
    75 long double exp2( long double );
    76 // float _Complex exp2( float _Complex );
    77 // double _Complex exp2( double _Complex );
    78 // long double _Complex exp2( long double _Complex );
    79 
    80 float expm1( float );
    81 // extern "C" { double expm1( double ); }
    82 long double expm1( long double );
    83 
    84111float log( float );
    85 // extern "C" { double log( double ); }
     112extern "C" { double log( double ); }
    86113long double log( long double );
    87114float _Complex log( float _Complex );
     
    89116long double _Complex log( long double _Complex );
    90117
    91 float log2( float );
    92 // extern "C" { double log2( double ); }
    93 long double log2( long double );
    94 // float _Complex log2( float _Complex );
    95 // double _Complex log2( double _Complex );
    96 // long double _Complex log2( long double _Complex );
    97 
    98 float log10( float );
    99 // extern "C" { double log10( double ); }
    100 long double log10( long double );
    101 // float _Complex log10( float _Complex );
    102 // double _Complex log10( double _Complex );
    103 // long double _Complex log10( long double _Complex );
    104 
    105 float log1p( float );
    106 // extern "C" { double log1p( double ); }
    107 long double log1p( long double );
    108 
    109 int ilogb( float );
    110 // extern "C" { int ilogb( double ); }
    111 int ilogb( long double );
    112 
    113 float logb( float );
    114 // extern "C" { double logb( double ); }
    115 long double logb( long double );
    116 
    117 //---------------------- Power ----------------------
     118float pow( float, float );
     119extern "C" { double pow( double, double ); }
     120long double pow( long double, long double );
     121float _Complex pow( float _Complex, float _Complex );
     122double _Complex pow( double _Complex, double _Complex );
     123long double _Complex pow( long double _Complex, long double _Complex );
    118124
    119125float sqrt( float );
    120 // extern "C" { double sqrt( double ); }
     126extern "C" { double sqrt( double ); }
    121127long double sqrt( long double );
    122128float _Complex sqrt( float _Complex );
     
    124130long double _Complex sqrt( long double _Complex );
    125131
     132float fabs( float );
     133extern "C" { double fabs( double ); }
     134long double fabs( long double );
     135float cabs( float _Complex );
     136extern "C" { double cabs( double _Complex ); }
     137long double cabs( long double _Complex );
     138
     139float floor( float );
     140extern "C" { double floor( double ); }
     141long double floor( long double );
     142
     143float ceil( float );
     144extern "C" { double ceil( double ); }
     145long double ceil( long double );
     146
     147//---------------------------------------
     148
    126149float cbrt( float );
    127 // extern "C" { double cbrt( double ); }
     150extern "C" { double cbrt( double ); }
    128151long double cbrt( long double );
    129152
     153float copysign( float, float );
     154extern "C" { double copysign( double, double ); }
     155long double copysign( long double, long double );
     156
     157float erf( float );
     158extern "C" { double erf( double ); }
     159long double erf( long double );
     160
     161float erfc( float );
     162extern "C" { double erfc( double ); }
     163long double erfc( long double );
     164
     165float exp2( float );
     166extern "C" { double exp2( double ); }
     167long double exp2( long double );
     168
     169float expm1( float );
     170extern "C" { double expm1( double ); }
     171long double expm1( long double );
     172
     173float fdim( float, float );
     174extern "C" { double fdim( double, double ); }
     175long double fdim( long double, long double );
     176
     177float fma( float, float, float );
     178extern "C" { double fma( double, double, double ); }
     179long double fma( long double, long double, long double );
     180
     181float ?%?( float, float );
     182float fmod( float, float );
     183double ?%?( double, double );
     184extern "C" { double fmod( double, double ); }
     185long double ?%?( long double, long double );
     186long double fmod( long double, long double );
     187
     188[ int, float ] div( float x );
     189float frexp( float, int * );
     190[ int, double ] div( double x );
     191extern "C" { double frexp( double, int * ); }
     192[ int, long double ] div( long double x );
     193long double frexp( long double, int * );
     194
    130195float hypot( float, float );
    131 // extern "C" { double hypot( double, double ); }
     196extern "C" { double hypot( double, double ); }
    132197long double hypot( long double, long double );
    133198
    134 float pow( float, float );
    135 // extern "C" { double pow( double, double ); }
    136 long double pow( long double, long double );
    137 float _Complex pow( float _Complex, float _Complex );
    138 double _Complex pow( double _Complex, double _Complex );
    139 long double _Complex pow( long double _Complex, long double _Complex );
    140 
    141 //---------------------- Trigonometric ----------------------
    142 
    143 float sin( float );
    144 // extern "C" { double sin( double ); }
    145 long double sin( long double );
    146 float _Complex sin( float _Complex );
    147 double _Complex sin( double _Complex );
    148 long double _Complex sin( long double _Complex );
    149 
    150 float cos( float );
    151 // extern "C" { double cos( double ); }
    152 long double cos( long double );
    153 float _Complex cos( float _Complex );
    154 double _Complex cos( double _Complex );
    155 long double _Complex cos( long double _Complex );
    156 
    157 float tan( float );
    158 // extern "C" { double tan( double ); }
    159 long double tan( long double );
    160 float _Complex tan( float _Complex );
    161 double _Complex tan( double _Complex );
    162 long double _Complex tan( long double _Complex );
    163 
    164 float asin( float );
    165 // extern "C" { double asin( double ); }
    166 long double asin( long double );
    167 float _Complex asin( float _Complex );
    168 double _Complex asin( double _Complex );
    169 long double _Complex asin( long double _Complex );
    170 
    171 float acos( float );
    172 // extern "C" { double acos( double ); }
    173 long double acos( long double );
    174 float _Complex acos( float _Complex );
    175 double _Complex acos( double _Complex );
    176 long double _Complex acos( long double _Complex );
    177 
    178 float atan( float );
    179 // extern "C" { double atan( double ); }
    180 long double atan( long double );
    181 float _Complex atan( float _Complex );
    182 double _Complex atan( double _Complex );
    183 long double _Complex atan( long double _Complex );
    184 
    185 float atan2( float, float );
    186 double atan2( double, double );
    187 long double atan2( long double, long double );
    188 
    189 float atan( float, float );                                                             // alternative name for atan2
    190 double atan( double, double );
    191 long double atan( long double, long double );
    192 
    193 //---------------------- Hyperbolic ----------------------
    194 
    195 float sinh( float );
    196 // extern "C" { double sinh( double ); }
    197 long double sinh( long double );
    198 float _Complex sinh( float _Complex );
    199 double _Complex sinh( double _Complex );
    200 long double _Complex sinh( long double _Complex );
    201 
    202 float cosh( float );
    203 // extern "C" { double cosh( double ); }
    204 long double cosh( long double );
    205 float _Complex cosh( float _Complex );
    206 double _Complex cosh( double _Complex );
    207 long double _Complex cosh( long double _Complex );
    208 
    209 float tanh( float );
    210 // extern "C" { double tanh( double ); }
    211 long double tanh( long double );
    212 float _Complex tanh( float _Complex );
    213 double _Complex tanh( double _Complex );
    214 long double _Complex tanh( long double _Complex );
    215 
    216 float asinh( float );
    217 // extern "C" { double asinh( double ); }
    218 long double asinh( long double );
    219 float _Complex asinh( float _Complex );
    220 double _Complex asinh( double _Complex );
    221 long double _Complex asinh( long double _Complex );
    222 
    223 float acosh( float );
    224 // extern "C" { double acosh( double ); }
    225 long double acosh( long double );
    226 float _Complex acosh( float _Complex );
    227 double _Complex acosh( double _Complex );
    228 long double _Complex acosh( long double _Complex );
    229 
    230 float atanh( float );
    231 // extern "C" { double atanh( double ); }
    232 long double atanh( long double );
    233 float _Complex atanh( float _Complex );
    234 double _Complex atanh( double _Complex );
    235 long double _Complex atanh( long double _Complex );
    236 
    237 //---------------------- Error / Gamma ----------------------
    238 
    239 float erf( float );
    240 // extern "C" { double erf( double ); }
    241 long double erf( long double );
    242 // float _Complex erf( float _Complex );
    243 // double _Complex erf( double _Complex );
    244 // long double _Complex erf( long double _Complex );
    245 
    246 float erfc( float );
    247 // extern "C" { double erfc( double ); }
    248 long double erfc( long double );
    249 // float _Complex erfc( float _Complex );
    250 // double _Complex erfc( double _Complex );
    251 // long double _Complex erfc( long double _Complex );
     199int ilogb( float );
     200extern "C" { int ilogb( double ); }
     201int ilogb( long double );
     202
     203float ldexp( float, int );
     204extern "C" { double ldexp( double, int ); }
     205long double ldexp( long double, int );
    252206
    253207float lgamma( float );
    254 // extern "C" { double lgamma( double ); }
     208extern "C" { double lgamma( double ); }
    255209long double lgamma( long double );
    256 float lgamma( float, int * );
    257 double lgamma( double, int * );
    258 long double lgamma( long double, int * );
    259 
    260 float tgamma( float );
    261 // extern "C" { double tgamma( double ); }
    262 long double tgamma( long double );
    263 
    264 //---------------------- Nearest Integer ----------------------
    265 
    266 float floor( float );
    267 // extern "C" { double floor( double ); }
    268 long double floor( long double );
    269 
    270 float ceil( float );
    271 // extern "C" { double ceil( double ); }
    272 long double ceil( long double );
    273 
    274 float trunc( float );
    275 // extern "C" { double trunc( double ); }
    276 long double trunc( long double );
    277 
    278 float rint( float );
    279 long double rint( long double );
    280 long int rint( float );
    281 long int rint( double );
    282 long int rint( long double );
    283 long long int rint( float );
    284 long long int rint( double );
    285 long long int rint( long double );
     210
     211float rint( float x );
     212long double rint( long double x );
     213long int rint( float x );
     214long int rint( double x );
     215long int rint( long double x );
     216long long int rint( float x );
     217long long int rint( double x );
     218long long int rint( long double x );
    286219
    287220long int lrint( float );
    288 // extern "C" { long int lrint( double ); }
     221extern "C" { long int lrint( double ); }
    289222long int lrint( long double );
    290223long long int llrint( float );
    291 // extern "C" { long long int llrint( double ); }
     224extern "C" { long long int llrint( double ); }
    292225long long int llrint( long double );
    293226
    294 float nearbyint( float );
    295 // extern "C" { double nearbyint( double ); }
    296 long double nearbyint( long double );
    297 
    298 float round( float );
    299 long double round( long double );
    300 long int round( float );
    301 long int round( double );
    302 long int round( long double );
    303 long long int round( float );
    304 long long int round( double );
    305 long long int round( long double );
     227float round( float x );
     228long double round( long double x );
     229long int round( float x );
     230long int round( double x );
     231long int round( long double x );
     232long long int round( float x );
     233long long int round( double x );
     234long long int round( long double x );
    306235
    307236long int lround( float );
    308 // extern "C" { long int lround( double ); }
     237extern "C" { long int lround( double ); }
    309238long int lround( long double );
    310239long long int llround( float );
    311 // extern "C" { long long int llround( double ); }
     240extern "C" { long long int llround( double ); }
    312241long long int llround( long double );
    313242
    314 //---------------------- Manipulation ----------------------
    315 
    316 float copysign( float, float );
    317 // extern "C" { double copysign( double, double ); }
    318 long double copysign( long double, long double );
    319 
    320 float frexp( float, int * );
    321 // extern "C" { double frexp( double, int * ); }
    322 long double frexp( long double, int * );
    323 
    324 float ldexp( float, int );
    325 // extern "C" { double ldexp( double, int ); }
    326 long double ldexp( long double, int );
    327 
    328 [ float, float ] modf( float );
    329 float modf( float, float * );
    330 [ double, double ] modf( double );
    331 // extern "C" { double modf( double, double * ); }
    332 [ long double, long double ] modf( long double );
    333 long double modf( long double, long double * );
     243float log10( float );
     244extern "C" { double log10( double ); }
     245long double log10( long double );
     246
     247float log1p( float );
     248extern "C" { double log1p( double ); }
     249long double log1p( long double );
     250
     251float log2( float );
     252extern "C" { double log2( double ); }
     253long double log2( long double );
     254
     255float logb( float );
     256extern "C" { double logb( double ); }
     257long double logb( long double );
     258
     259float nearbyint( float );
     260extern "C" { double nearbyint( double ); }
     261long double nearbyint( long double );
    334262
    335263float nextafter( float, float );
    336 // extern "C" { double nextafter( double, double ); }
     264extern "C" { double nextafter( double, double ); }
    337265long double nextafter( long double, long double );
    338266
    339267float nexttoward( float, long double );
    340 // extern "C" { double nexttoward( double, long double ); }
     268extern "C" { double nexttoward( double, long double ); }
    341269long double nexttoward( long double, long double );
    342270
     271float remainder( float, float );
     272extern "C" { double remainder( double, double ); }
     273long double remainder( long double, long double );
     274
     275[ int, float ] remquo( float x, float y );
     276float remquo( float, float, int * );
     277[ int, double ] remquo( double x, double y );
     278extern "C" { double remquo( double, double, int * ); }
     279[ int, long double ] remquo( long double x, long double y );
     280long double remquo( long double, long double, int * );
     281
    343282float scalbn( float, int );
    344 // extern "C" { double scalbn( double, int ); }
     283extern "C" { double scalbn( double, int ); }
    345284long double scalbn( long double, int );
    346285
    347286float scalbln( float, long int );
    348 // extern "C" { double scalbln( double, long int ); }
     287extern "C" { double scalbln( double, long int ); }
    349288long double scalbln( long double, long int );
     289
     290float tgamma( float );
     291extern "C" { double tgamma( double ); }
     292long double tgamma( long double );
     293
     294float trunc( float );
     295extern "C" { double trunc( double ); }
     296long double trunc( long double );
    350297
    351298// Local Variables: //
  • src/libcfa/math.c

    radd371c r845cedc  
     1//                               -*- Mode: C -*-
    12//
    23// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
     
    1011// Created On       : Tue Apr 19 22:23:08 2016
    1112// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Sun Apr 24 08:52:31 2016
    13 // Update Count     : 75
     13// Last Modified On : Thu Apr 21 07:56:49 2016
     14// Update Count     : 51
    1415//
    1516
    1617#include "math"
    1718
     19//---------------------------------------
     20
    1821extern "C" {
     22#include <math.h>
    1923#include <complex.h>
    2024} // extern "C"
     25
     26float cos( float x ) { return cosf( x ); }
     27long double cos( long double x ) { return cosl( x ); }
     28float _Complex cos( float _Complex x ) { return ccosf( x ); }
     29double _Complex cos( double _Complex x ) { return ccos( x ); }
     30long double _Complex cos( long double _Complex x ) { return ccosl( x ); }
     31
     32float cosh( float x ) { return coshf( x ); }
     33long double cosh( long double x ) { return coshl( x ); }
     34float _Complex cosh( float _Complex x ) { return ccoshf( x ); }
     35double _Complex cosh( double _Complex x ) { return ccosh( x ); }
     36long double _Complex cosh( long double _Complex x ) { return ccoshl( x ); }
     37
     38float acos( float x ) { return acosf( x ); }
     39long double acos( long double x ) { return acosl( x ); }
     40float _Complex acos( float _Complex x ) { return cacosf( x ); }
     41double _Complex acos( double _Complex x ) { return cacos( x ); }
     42long double _Complex acos( long double _Complex x ) { return cacosl( x ); }
     43
     44float acosh( float x ) { return acoshf( x ); }
     45long double acosh( long double x ) { return acoshl( x ); }
     46float _Complex acosh( float _Complex x ) { return cacoshf( x ); }
     47double _Complex acosh( double _Complex x ) { return cacosh( x ); }
     48long double _Complex acosh( long double _Complex x ) { return cacoshl( x ); }
     49
     50float sin( float x ) { return sinf( x ); }
     51long double sin( long double x ) { return sinl( x ); }
     52float _Complex sin( float _Complex x ) { return csinf( x ); }
     53double _Complex sin( double _Complex x ) { return csin( x ); }
     54long double _Complex sin( long double _Complex x ) { return csinl( x ); }
     55
     56float sinh( float x ) { return sinhf( x ); }
     57long double sinh( long double x ) { return sinhl( x ); }
     58float _Complex sinh( float _Complex x ) { return csinhf( x ); }
     59double _Complex sinh( double _Complex x ) { return csinh( x ); }
     60long double _Complex sinh( long double _Complex x ) { return csinhl( x ); }
     61
     62float asin( float x ) { return asinf( x ); }
     63long double asin( long double x ) { return asinl( x ); }
     64float _Complex asin( float _Complex x ) { return casinf( x ); }
     65double _Complex asin( double _Complex x ) { return casin( x ); }
     66long double _Complex asin( long double _Complex x ) { return casinl( x ); }
     67
     68float asinh( float x ) { return asinhf( x ); }
     69long double asinh( long double x ) { return asinhl( x ); }
     70float _Complex asinh( float _Complex x ) { return casinhf( x ); }
     71double _Complex asinh( double _Complex x ) { return casinh( x ); }
     72long double _Complex asinh( long double _Complex x ) { return casinhl( x ); }
     73
     74float tan( float x ) { return tanf( x ); }
     75long double tan( long double x ) { return tanl( x ); }
     76float _Complex tan( float _Complex x ) { return ctanf( x ); }
     77double _Complex tan( double _Complex x ) { return ctan( x ); }
     78long double _Complex tan( long double _Complex x ) { return ctanl( x ); }
     79
     80float tanh( float x ) { return tanhf( x ); }
     81long double tanh( long double x ) { return tanhl( x ); }
     82float _Complex tanh( float _Complex x ) { return ctanhf( x ); }
     83double _Complex tanh( double _Complex x ) { return ctanh( x ); }
     84long double _Complex tanh( long double _Complex x ) { return ctanhl( x ); }
     85
     86float atan( float x ) { return atanf( x ); }
     87long double atan( long double x ) { return atanl( x ); }
     88float _Complex atan( float _Complex x ) { return catanf( x ); }
     89double _Complex atan( double _Complex x ) { return catan( x ); }
     90long double _Complex atan( long double _Complex x ) { return catanl( x ); }
     91
     92float atan( float x, float y ) { return atan2f( x, y ); }
     93double atan( double x, double y ) { return atan2( x, y ); }
     94long double atan( long double x, long double y ) { return atan2l( x, y ); }
     95
     96float atanh( float x ) { return atanhf( x ); }
     97long double atanh( long double x ) { return atanhl( x ); }
     98float _Complex atanh( float _Complex x ) { return catanhf( x ); }
     99double _Complex atanh( double _Complex x ) { return catanh( x ); }
     100long double _Complex atanh( long double _Complex x ) { return catanhl( x ); }
     101
     102float exp( float x ) { return expf( x ); }
     103long double exp( long double x ) { return expl( x ); }
     104float _Complex exp( float _Complex x ) { return cexpf( x ); }
     105double _Complex exp( double _Complex x ) { return cexp( x ); }
     106long double _Complex exp( long double _Complex x ) { return cexpl( x ); }
     107
     108float log( float x ) { return logf( x ); }
     109long double log( long double x ) { return logl( x ); }
     110float _Complex log( float _Complex x ) { return clogf( x ); }
     111double _Complex log( double _Complex x ) { return clog( x ); }
     112long double _Complex log( long double _Complex x ) { return clogl( x ); }
     113
     114float pow( float x, float y ) { return powf( x, y ); }
     115long double pow( long double x, long double y ) { return powl( x, y ); }
     116float _Complex pow( float _Complex x, float _Complex y ) { return cpowf( x, y ); }
     117double _Complex pow( double _Complex x, double _Complex y ) { return cpow( x, y ); }
     118long double _Complex pow( long double _Complex x, long double _Complex y ) { return cpowl( x, y ); }
     119
     120float sqrt( float x ) { return sqrtf( x ); }
     121long double sqrt( long double x ) { return sqrtl( x ); }
     122float _Complex sqrt( float _Complex x ) { return csqrtf( x ); }
     123double _Complex sqrt( double _Complex x ) { return csqrt( x ); }
     124long double _Complex sqrt( long double _Complex x ) { return csqrtl( x ); }
    21125
    22126float fabs( float x ) { return fabsf( x ); }
    23127long double fabs( long double x ) { return fabsl( x ); }
    24128float cabs( float _Complex x ) { return cabsf( x ); }
    25 double cabs( double _Complex x ) { return cabs( x ); }
    26129long double cabs( long double _Complex x ) { return cabsl( x ); }
     130
     131float floor( float x ) { return floorf( x ); }
     132long double floor( long double x ) { return floorl( x ); }
     133
     134float ceil( float x ) { return ceilf( x ); }
     135long double ceil( long double x ) { return ceill( x ); }
     136
     137//---------------------------------------
     138
     139float cbrt( float x ) { return cbrtf( x ); }
     140long double cbrt( long double x ) { return cbrtl( x ); }
     141
     142float copysign( float x, float y ) { return copysignf( x, y ); }
     143long double copysign( long double x, long double y ) { return copysignl( x, y ); }
     144
     145float erf( float x ) { return erff( x ); }
     146long double erf( long double x ) { return erfl( x ); }
     147
     148float erfc( float x ) { return erfcf( x ); }
     149long double erfc( long double x ) { return erfcl( x ); }
     150
     151float exp2( float x ) { return exp2f( x ); }
     152long double exp2( long double x ) { return exp2l( x ); }
     153
     154float expm1( float x ) { return expm1f( x ); }
     155long double expm1( long double x ) { return expm1l( x ); }
     156
     157float fdim( float x, float y ) { return fdimf( x, y ); }
     158long double fdim( long double x, long double y ) { return fdiml( x, y ); }
     159
     160float fma( float x, float y, float z ) { return fmaf( x, y, z ); }
     161long double fma( long double x, long double y, long double z ) { return fmal( x, y, z ); }
    27162
    28163float ?%?( float x, float y ) { return fmodf( x, y ); }
     
    32167long double fmod( long double x, long double y ) { return fmodl( x, y ); }
    33168
    34 float remainder( float x, float y ) { return remainderf( x, y ); }
    35 long double remainder( long double x, long double y ) { return remainderl( x, y ); }
    36 
    37 // [ int, float ] remquo( float x, float y ) { int quo; x = remquof( x, y, &quo ); return [ quo, x ]; }
    38 float remquo( float x, float y, int *quo ) { return remquof( x, y, quo ); }
    39 // [ int, double ] remquo( double x, double y ) { int quo; x = remquo( x, y, &quo ); return [ quo, x ]; }
    40 // [ int, long double ] remquo( long double x, long double y ) { int quo; x = remquol( x, y, &quo ); return [ quo, x ]; }
    41 long double remquo( long double x, long double y, int *quo ) { return remquol( x, y, quo ); }
    42 
    43 // [ int, float ] div( float x, float y ) { int quo; x = remquof( x, y, &quo ); return [ quo, x ]; }
    44 float div( float x, float y, int *quo ) { return remquof( x, y, quo ); }
    45 // [ int, double ] div( double x, double y ) { int quo; x = remquo( x, y, &quo ); return [ quo, x ]; }
    46 // [ int, long double ] div( long double x, long double y ) { int quo; x = remquol( x, y, &quo ); return [ quo, x ]; }
    47 long double div( long double x, long double y, int *quo ) { return remquol( x, y, quo ); }
    48 
    49 float fma( float x, float y, float z ) { return fmaf( x, y, z ); }
    50 long double fma( long double x, long double y, long double z ) { return fmal( x, y, z ); }
    51 
    52 float fdim( float x, float y ) { return fdimf( x, y ); }
    53 long double fdim( long double x, long double y ) { return fdiml( x, y ); }
    54 
    55 float nan( const char *tag ) { return nanf( tag ); }
    56 long double nan( const char *tag ) { return nanl( tag ); }
    57 
    58 //---------------------- Exponential ----------------------
    59 
    60 float exp( float x ) { return expf( x ); }
    61 long double exp( long double x ) { return expl( x ); }
    62 float _Complex exp( float _Complex x ) { return cexpf( x ); }
    63 double _Complex exp( double _Complex x ) { return cexp( x ); }
    64 long double _Complex exp( long double _Complex x ) { return cexpl( x ); }
    65 
    66 float exp2( float x ) { return exp2f( x ); }
    67 long double exp2( long double x ) { return exp2l( x ); }
    68 // float _Complex exp2( float _Complex x ) { return cexp2f( x ); }
    69 // double _Complex exp2( double _Complex x ) { return cexp2( x ); }
    70 // long double _Complex exp2( long double _Complex x ) { return cexp2l( x ); }
    71 
    72 float expm1( float x ) { return expm1f( x ); }
    73 long double expm1( long double x ) { return expm1l( x ); }
    74 
    75 float log( float x ) { return logf( x ); }
    76 long double log( long double x ) { return logl( x ); }
    77 float _Complex log( float _Complex x ) { return clogf( x ); }
    78 double _Complex log( double _Complex x ) { return clog( x ); }
    79 long double _Complex log( long double _Complex x ) { return clogl( x ); }
    80 
    81 float log2( float x ) { return log2f( x ); }
    82 long double log2( long double x ) { return log2l( x ); }
    83 // float _Complex log2( float _Complex x ) { return clog2f( x ); }
    84 // double _Complex log2( double _Complex x ) { return clog2( x ); }
    85 // long double _Complex log2( long double _Complex x ) { return clog2l( x ); }
    86 
    87 float log10( float x ) { return log10f( x ); }
    88 long double log10( long double x ) { return log10l( x ); }
    89 // float _Complex log10( float _Complex x ) { return clog10f( x ); }
    90 // double _Complex log10( double _Complex x ) { return clog10( x ); }
    91 // long double _Complex log10( long double _Complex x ) { return clog10l( x ); }
    92 
    93 float log1p( float x ) { return log1pf( x ); }
    94 long double log1p( long double x ) { return log1pl( x ); }
     169//[ int, float ] div( float x ) { int i; x = frexpf( x, &i ); return [ i, x ]; }
     170float frexp( float x, int *ip ) { return frexpf( x, ip ); }
     171//[ int, double ] div( double x ) { int i; x = frexp( x, &i ); return [ i, x ]; }
     172//[ int, long double ] div( long double x ) { int i; x = frexpl( x, &i ); return [ i, x ]; }
     173long double frexp( long double x, int *ip ) { return frexpl( x, ip ); }
     174
     175float hypot( float x, float y ) { return hypotf( x, y ); }
     176long double hypot( long double x, long double y ) { return hypotl( x, y ); }
    95177
    96178int ilogb( float x ) { return ilogbf( x ); }
    97179int ilogb( long double x ) { return ilogbl( x ); }
    98180
    99 float logb( float x ) { return logbf( x ); }
    100 long double logb( long double x ) { return logbl( x ); }
    101 
    102 //---------------------- Power ----------------------
    103 
    104 float sqrt( float x ) { return sqrtf( x ); }
    105 long double sqrt( long double x ) { return sqrtl( x ); }
    106 float _Complex sqrt( float _Complex x ) { return csqrtf( x ); }
    107 double _Complex sqrt( double _Complex x ) { return csqrt( x ); }
    108 long double _Complex sqrt( long double _Complex x ) { return csqrtl( x ); }
    109 
    110 float cbrt( float x ) { return cbrtf( x ); }
    111 long double cbrt( long double x ) { return cbrtl( x ); }
    112 
    113 float hypot( float x, float y ) { return hypotf( x, y ); }
    114 long double hypot( long double x, long double y ) { return hypotl( x, y ); }
    115 
    116 float pow( float x, float y ) { return powf( x, y ); }
    117 long double pow( long double x, long double y ) { return powl( x, y ); }
    118 float _Complex pow( float _Complex x, float _Complex y ) { return cpowf( x, y ); }
    119 double _Complex pow( double _Complex x, double _Complex y ) { return cpow( x, y ); }
    120 long double _Complex pow( long double _Complex x, long double _Complex y ) { return cpowl( x, y ); }
    121 
    122 //---------------------- Trigonometric ----------------------
    123 
    124 float sin( float x ) { return sinf( x ); }
    125 long double sin( long double x ) { return sinl( x ); }
    126 float _Complex sin( float _Complex x ) { return csinf( x ); }
    127 double _Complex sin( double _Complex x ) { return csin( x ); }
    128 long double _Complex sin( long double _Complex x ) { return csinl( x ); }
    129 
    130 float cos( float x ) { return cosf( x ); }
    131 long double cos( long double x ) { return cosl( x ); }
    132 float _Complex cos( float _Complex x ) { return ccosf( x ); }
    133 double _Complex cos( double _Complex x ) { return ccos( x ); }
    134 long double _Complex cos( long double _Complex x ) { return ccosl( x ); }
    135 
    136 float tan( float x ) { return tanf( x ); }
    137 long double tan( long double x ) { return tanl( x ); }
    138 float _Complex tan( float _Complex x ) { return ctanf( x ); }
    139 double _Complex tan( double _Complex x ) { return ctan( x ); }
    140 long double _Complex tan( long double _Complex x ) { return ctanl( x ); }
    141 
    142 float asin( float x ) { return asinf( x ); }
    143 long double asin( long double x ) { return asinl( x ); }
    144 float _Complex asin( float _Complex x ) { return casinf( x ); }
    145 double _Complex asin( double _Complex x ) { return casin( x ); }
    146 long double _Complex asin( long double _Complex x ) { return casinl( x ); }
    147 
    148 float acos( float x ) { return acosf( x ); }
    149 long double acos( long double x ) { return acosl( x ); }
    150 float _Complex acos( float _Complex x ) { return cacosf( x ); }
    151 double _Complex acos( double _Complex x ) { return cacos( x ); }
    152 long double _Complex acos( long double _Complex x ) { return cacosl( x ); }
    153 
    154 float atan( float x ) { return atanf( x ); }
    155 long double atan( long double x ) { return atanl( x ); }
    156 float _Complex atan( float _Complex x ) { return catanf( x ); }
    157 double _Complex atan( double _Complex x ) { return catan( x ); }
    158 long double _Complex atan( long double _Complex x ) { return catanl( x ); }
    159 
    160 float atan2( float x, float y ) { return atan2f( x, y ); }
    161 double atan2( double x, double y ) { return atan2( x, y ); }
    162 long double atan2( long double x, long double y ) { return atan2l( x, y ); }
    163 
    164 float atan( float x, float y ) { return atan2f( x, y ); }
    165 double atan( double x, double y ) { return atan2( x, y ); }
    166 long double atan( long double x, long double y ) { return atan2l( x, y ); }
    167 
    168 //---------------------- Hyperbolic ----------------------
    169 
    170 float sinh( float x ) { return sinhf( x ); }
    171 long double sinh( long double x ) { return sinhl( x ); }
    172 float _Complex sinh( float _Complex x ) { return csinhf( x ); }
    173 double _Complex sinh( double _Complex x ) { return csinh( x ); }
    174 long double _Complex sinh( long double _Complex x ) { return csinhl( x ); }
    175 
    176 float cosh( float x ) { return coshf( x ); }
    177 long double cosh( long double x ) { return coshl( x ); }
    178 float _Complex cosh( float _Complex x ) { return ccoshf( x ); }
    179 double _Complex cosh( double _Complex x ) { return ccosh( x ); }
    180 long double _Complex cosh( long double _Complex x ) { return ccoshl( x ); }
    181 
    182 float tanh( float x ) { return tanhf( x ); }
    183 long double tanh( long double x ) { return tanhl( x ); }
    184 float _Complex tanh( float _Complex x ) { return ctanhf( x ); }
    185 double _Complex tanh( double _Complex x ) { return ctanh( x ); }
    186 long double _Complex tanh( long double _Complex x ) { return ctanhl( x ); }
    187 
    188 float asinh( float x ) { return asinhf( x ); }
    189 long double asinh( long double x ) { return asinhl( x ); }
    190 float _Complex asinh( float _Complex x ) { return casinhf( x ); }
    191 double _Complex asinh( double _Complex x ) { return casinh( x ); }
    192 long double _Complex asinh( long double _Complex x ) { return casinhl( x ); }
    193 
    194 float acosh( float x ) { return acoshf( x ); }
    195 long double acosh( long double x ) { return acoshl( x ); }
    196 float _Complex acosh( float _Complex x ) { return cacoshf( x ); }
    197 double _Complex acosh( double _Complex x ) { return cacosh( x ); }
    198 long double _Complex acosh( long double _Complex x ) { return cacoshl( x ); }
    199 
    200 float atanh( float x ) { return atanhf( x ); }
    201 long double atanh( long double x ) { return atanhl( x ); }
    202 float _Complex atanh( float _Complex x ) { return catanhf( x ); }
    203 double _Complex atanh( double _Complex x ) { return catanh( x ); }
    204 long double _Complex atanh( long double _Complex x ) { return catanhl( x ); }
    205 
    206 //---------------------- Error / Gamma ----------------------
    207 
    208 float erf( float x ) { return erff( x ); }
    209 long double erf( long double x ) { return erfl( x ); }
    210 // float _Complex erf( float _Complex x ) { return crflf( x ); }
    211 // double _Complex erf( double _Complex x ) { return crfl( x ); }
    212 // long double _Complex erf( long double _Complex x ) { return crfll( x ); }
    213 
    214 float erfc( float x ) { return erfcf( x ); }
    215 long double erfc( long double x ) { return erfcl( x ); }
    216 // float _Complex erfc( float _Complex x ) { return cerfcf( x ); }
    217 // double _Complex erfc( double _Complex x ) { return cerfc( x ); }
    218 // long double _Complex erfc( long double _Complex x ) { return cerfcl( x ); }
     181float ldexp( float x, int exp2 ) { return ldexpf( x, exp2 ); }
     182long double ldexp( long double x, int exp2 ) { return ldexpl( x, exp2 ); }
    219183
    220184float lgamma( float x ) { return lgammaf( x ); }
    221185long double lgamma( long double x ) { return lgammal( x ); }
    222 float lgamma( float x, int *sign ) { return lgammaf_r( x, sign ); }
    223 double lgamma( double x, int *sign ) { return lgamma_r( x, sign ); }
    224 long double lgamma( long double x, int *sign ) { return lgammal_r( x, sign ); }
    225 
    226 float tgamma( float x ) { return tgammaf( x ); }
    227 long double tgamma( long double x ) { return tgammal( x ); }
    228 
    229 //---------------------- Nearest Integer ----------------------
    230 
    231 float floor( float x ) { return floorf( x ); }
    232 long double floor( long double x ) { return floorl( x ); }
    233 
    234 float ceil( float x ) { return ceilf( x ); }
    235 long double ceil( long double x ) { return ceill( x ); }
    236 
    237 float trunc( float x ) { return truncf( x ); }
    238 long double trunc( long double x ) { return truncl( x ); }
    239186
    240187float rint( float x ) { return rintf( x ); }
     
    252199long long int llrint( long double x ) { return llrintl( x ); }
    253200
    254 float nearbyint( float x ) { return nearbyintf( x ); }
    255 long double nearbyint( long double x ) { return nearbyintl( x ); }
    256 
    257201float round( float x ) { return roundf( x ); }
    258202long double round( long double x ) { return roundl( x ); }
     
    269213long long int llround( long double x ) { return llroundl( x ); }
    270214
    271 //---------------------- Manipulation ----------------------
    272 
    273 float copysign( float x, float y ) { return copysignf( x, y ); }
    274 long double copysign( long double x, long double y ) { return copysignl( x, y ); }
    275 
    276 float frexp( float x, int *ip ) { return frexpf( x, ip ); }
    277 long double frexp( long double x, int *ip ) { return frexpl( x, ip ); }
    278 
    279 float ldexp( float x, int exp2 ) { return ldexpf( x, exp2 ); }
    280 long double ldexp( long double x, int exp2 ) { return ldexpl( x, exp2 ); }
    281 
    282 // [ float, float ] modf( float x ) { float i; x = modff( x, &i ); return [ i, x ]; }
    283 float modf( float x, float *i ) { return modff( x, i ); }
    284 // [ double, double ] modf( double x ) { double i; x = modf( x, &i ); return [ i, x ]; }
    285 // [ long double, long double ] modf( long double x ) { long double i; x = modfl( x, &i ); return [ i, x ]; }
    286 long double modf( long double x, long double *i ) { return modfl( x, i ); }
     215float log10( float x ) { return log10f( x ); }
     216long double log10( long double x ) { return log10l( x ); }
     217
     218float log1p( float x ) { return log1pf( x ); }
     219long double log1p( long double x ) { return log1pl( x ); }
     220
     221float log2( float x ) { return log2f( x ); }
     222long double log2( long double x ) { return log2l( x ); }
     223
     224float logb( float x ) { return logbf( x ); }
     225long double logb( long double x ) { return logbl( x ); }
     226
     227float nearbyint( float x ) { return nearbyintf( x ); }
     228long double nearbyint( long double x ) { return nearbyintl( x ); }
    287229
    288230float nextafter( float x, float y ) { return nextafterf( x, y ); }
     
    291233float nexttoward( float x, long double y ) { return nexttowardf( x, y ); }
    292234long double nexttoward( long double x, long double y ) { return nexttowardl( x, y ); }
     235
     236float remainder( float x, float y ) { return remainderf( x, y ); }
     237long double remainder( long double x, long double y ) { return remainderl( x, y ); }
     238
     239//[ int, float ] remquo( float x, float y ) { int quo; x = remquof( x, y, &quo ); return [ quo, x ]; }
     240float remquo( float x, float y, int *quo ) { return remquof( x, y, quo ); }
     241//[ int, double ] remquo( double x, double y ) { int quo; x = remquo( x, y, &quo ); return [ quo, x ]; }
     242//[ int, long double ] remquo( long double x, long double y ) { int quo; x = remquol( x, y, &quo ); return [ quo, x ]; }
     243long double remquo( long double x, long double y, int *quo ) { return remquol( x, y, quo ); }
    293244
    294245float scalbn( float x, int exp ) { return scalbnf( x, exp ); }
     
    301252long double scalbln( long double x, long int exp ) { return scalblnl( x, exp ); }
    302253
     254float tgamma( float x ) { return tgammaf( x ); }
     255long double tgamma( long double x ) { return tgammal( x ); }
     256
     257float trunc( float x ) { return truncf( x ); }
     258long double trunc( long double x ) { return truncl( x ); }
     259
    303260// Local Variables: //
    304261// mode: c //
Note: See TracChangeset for help on using the changeset viewer.