Changeset add371c


Ignore:
Timestamp:
Apr 25, 2016, 2:50:14 PM (6 years ago)
Author:
Rob Schluntz <rschlunt@…>
Branches:
aaron-thesis, arm-eh, cleanup-dtors, ctor, deferred_resn, demangler, gc_noraii, jacob/cs343-translation, jenkins-sandbox, master, memory, new-ast, new-ast-unique-expr, new-env, no_list, persistent-indexer, resolv-new, with_gc
Children:
cf18eea
Parents:
845cedc (diff), dc5376a (diff)
Note: this is a merge changeset, the changes displayed below correspond to the merge itself.
Use the (diff) links above to see all the changes relative to each parent.
Message:

Merge branch 'master' into ctor

Location:
src
Files:
1 added
2 edited

Legend:

Unmodified
Added
Removed
  • src/libcfa/math

    r845cedc radd371c  
    1010// Created On       : Mon Apr 18 23:37:04 2016
    1111// Last Modified By : Peter A. Buhr
    12 // Last Modified On : Thu Apr 21 07:56:48 2016
    13 // Update Count     : 38
     12// Last Modified On : Sun Apr 24 12:45:02 2016
     13// Update Count     : 59
    1414//
    1515
     16extern "C" {
     17#include <math.h>                                                                               // fpclassify, isfinite, isnormal, isnan, isinf
     18} // extern "C"
     19
     20float fabs( float );
     21// extern "C" { double fabs( double ); }
     22long double fabs( long double );
     23float cabs( float _Complex );
     24// extern "C" { double cabs( double _Complex ); }
     25long double cabs( long double _Complex );
     26
     27float ?%?( float, float );
     28float fmod( float, float );
     29double ?%?( double, double );
     30// extern "C" { double fmod( double, double ); }
     31long double ?%?( long double, long double );
     32long double fmod( long double, long double );
     33
     34float remainder( float, float );
     35// extern "C" { double remainder( double, double ); }
     36long double remainder( long double, long double );
     37
     38[ int, float ] remquo( float, float );
     39float 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 );
     43long double remquo( long double, long double, int * );
     44
     45[ int, float ] div( float, float );                                             // alternative name for remquo
     46float 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 );
     50long double div( long double, long double, int * );
     51
     52float fma( float, float, float );
     53// extern "C" { double fma( double, double, double ); }
     54long double fma( long double, long double, long double );
     55
     56float fdim( float, float );
     57// extern "C" { double fdim( double, double ); }
     58long double fdim( long double, long double );
     59
     60float nan( const char * );
     61// extern "C" { double nan( const char * ); }
     62long double nan( const char * );
     63
     64//---------------------- Exponential ----------------------
     65
     66float exp( float );
     67// extern "C" { double exp( double ); }
     68long double exp( long double );
     69float _Complex exp( float _Complex );
     70double _Complex exp( double _Complex );
     71long double _Complex exp( long double _Complex );
     72
     73float exp2( float );
     74// extern "C" { double exp2( double ); }
     75long 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
     80float expm1( float );
     81// extern "C" { double expm1( double ); }
     82long double expm1( long double );
     83
     84float log( float );
     85// extern "C" { double log( double ); }
     86long double log( long double );
     87float _Complex log( float _Complex );
     88double _Complex log( double _Complex );
     89long double _Complex log( long double _Complex );
     90
     91float log2( float );
     92// extern "C" { double log2( double ); }
     93long 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
     98float log10( float );
     99// extern "C" { double log10( double ); }
     100long 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
     105float log1p( float );
     106// extern "C" { double log1p( double ); }
     107long double log1p( long double );
     108
     109int ilogb( float );
     110// extern "C" { int ilogb( double ); }
     111int ilogb( long double );
     112
     113float logb( float );
     114// extern "C" { double logb( double ); }
     115long double logb( long double );
     116
     117//---------------------- Power ----------------------
     118
     119float sqrt( float );
     120// extern "C" { double sqrt( double ); }
     121long double sqrt( long double );
     122float _Complex sqrt( float _Complex );
     123double _Complex sqrt( double _Complex );
     124long double _Complex sqrt( long double _Complex );
     125
     126float cbrt( float );
     127// extern "C" { double cbrt( double ); }
     128long double cbrt( long double );
     129
     130float hypot( float, float );
     131// extern "C" { double hypot( double, double ); }
     132long double hypot( long double, long double );
     133
     134float pow( float, float );
     135// extern "C" { double pow( double, double ); }
     136long double pow( long double, long double );
     137float _Complex pow( float _Complex, float _Complex );
     138double _Complex pow( double _Complex, double _Complex );
     139long double _Complex pow( long double _Complex, long double _Complex );
     140
     141//---------------------- Trigonometric ----------------------
     142
     143float sin( float );
     144// extern "C" { double sin( double ); }
     145long double sin( long double );
     146float _Complex sin( float _Complex );
     147double _Complex sin( double _Complex );
     148long double _Complex sin( long double _Complex );
     149
    16150float cos( float );
    17 extern "C" { double cos( double ); }
     151// extern "C" { double cos( double ); }
    18152long double cos( long double );
    19153float _Complex cos( float _Complex );
     
    21155long double _Complex cos( long double _Complex );
    22156
     157float tan( float );
     158// extern "C" { double tan( double ); }
     159long double tan( long double );
     160float _Complex tan( float _Complex );
     161double _Complex tan( double _Complex );
     162long double _Complex tan( long double _Complex );
     163
     164float asin( float );
     165// extern "C" { double asin( double ); }
     166long double asin( long double );
     167float _Complex asin( float _Complex );
     168double _Complex asin( double _Complex );
     169long double _Complex asin( long double _Complex );
     170
     171float acos( float );
     172// extern "C" { double acos( double ); }
     173long double acos( long double );
     174float _Complex acos( float _Complex );
     175double _Complex acos( double _Complex );
     176long double _Complex acos( long double _Complex );
     177
     178float atan( float );
     179// extern "C" { double atan( double ); }
     180long double atan( long double );
     181float _Complex atan( float _Complex );
     182double _Complex atan( double _Complex );
     183long double _Complex atan( long double _Complex );
     184
     185float atan2( float, float );
     186double atan2( double, double );
     187long double atan2( long double, long double );
     188
     189float atan( float, float );                                                             // alternative name for atan2
     190double atan( double, double );
     191long double atan( long double, long double );
     192
     193//---------------------- Hyperbolic ----------------------
     194
     195float sinh( float );
     196// extern "C" { double sinh( double ); }
     197long double sinh( long double );
     198float _Complex sinh( float _Complex );
     199double _Complex sinh( double _Complex );
     200long double _Complex sinh( long double _Complex );
     201
    23202float cosh( float );
    24 extern "C" { double cosh( double ); }
     203// extern "C" { double cosh( double ); }
    25204long double cosh( long double );
    26205float _Complex cosh( float _Complex );
     
    28207long double _Complex cosh( long double _Complex );
    29208
    30 float acos( float );
    31 extern "C" { double acos( double ); }
    32 long double acos( long double );
    33 float _Complex acos( float _Complex );
    34 double _Complex acos( double _Complex );
    35 long double _Complex acos( long double _Complex );
     209float tanh( float );
     210// extern "C" { double tanh( double ); }
     211long double tanh( long double );
     212float _Complex tanh( float _Complex );
     213double _Complex tanh( double _Complex );
     214long double _Complex tanh( long double _Complex );
     215
     216float asinh( float );
     217// extern "C" { double asinh( double ); }
     218long double asinh( long double );
     219float _Complex asinh( float _Complex );
     220double _Complex asinh( double _Complex );
     221long double _Complex asinh( long double _Complex );
    36222
    37223float acosh( float );
    38 extern "C" { double acosh( double ); }
     224// extern "C" { double acosh( double ); }
    39225long double acosh( long double );
    40226float _Complex acosh( float _Complex );
     
    42228long double _Complex acosh( long double _Complex );
    43229
    44 float sin( float );
    45 extern "C" { double sin( double ); }
    46 long double sin( long double );
    47 float _Complex sin( float _Complex );
    48 double _Complex sin( double _Complex );
    49 long double _Complex sin( long double _Complex );
    50 
    51 float sinh( float );
    52 extern "C" { double sinh( double ); }
    53 long double sinh( long double );
    54 float _Complex sinh( float _Complex );
    55 double _Complex sinh( double _Complex );
    56 long double _Complex sinh( long double _Complex );
    57 
    58 float asin( float );
    59 extern "C" { double asin( double ); }
    60 long double asin( long double );
    61 float _Complex asin( float _Complex );
    62 double _Complex asin( double _Complex );
    63 long double _Complex asin( long double _Complex );
    64 
    65 float asinh( float );
    66 extern "C" { double asinh( double ); }
    67 long double asinh( long double );
    68 float _Complex asinh( float _Complex );
    69 double _Complex asinh( double _Complex );
    70 long double _Complex asinh( long double _Complex );
    71 
    72 float tan( float );
    73 extern "C" { double tan( double ); }
    74 long double tan( long double );
    75 float _Complex tan( float _Complex );
    76 double _Complex tan( double _Complex );
    77 long double _Complex tan( long double _Complex );
    78 
    79 float tanh( float );
    80 extern "C" { double tanh( double ); }
    81 long double tanh( long double );
    82 float _Complex tanh( float _Complex );
    83 double _Complex tanh( double _Complex );
    84 long double _Complex tanh( long double _Complex );
    85 
    86 float atan( float );
    87 extern "C" { double atan( double ); }
    88 long double atan( long double );
    89 float _Complex atan( float _Complex );
    90 double _Complex atan( double _Complex );
    91 long double _Complex atan( long double _Complex );
    92 
    93 float _Complex atan( float, float );
    94 double atan( double, double );
    95 long double atan( long double, long double );
    96 
    97230float atanh( float );
    98 extern "C" { double atanh( double ); }
     231// extern "C" { double atanh( double ); }
    99232long double atanh( long double );
    100233float _Complex atanh( float _Complex );
     
    102235long double _Complex atanh( long double _Complex );
    103236
    104 float exp( float );
    105 extern "C" { double exp( double ); }
    106 long double exp( long double );
    107 float _Complex exp( float _Complex );
    108 double _Complex exp( double _Complex );
    109 long double _Complex exp( long double _Complex );
    110 
    111 float log( float );
    112 extern "C" { double log( double ); }
    113 long double log( long double );
    114 float _Complex log( float _Complex );
    115 double _Complex log( double _Complex );
    116 long double _Complex log( long double _Complex );
    117 
    118 float pow( float, float );
    119 extern "C" { double pow( double, double ); }
    120 long double pow( long double, long double );
    121 float _Complex pow( float _Complex, float _Complex );
    122 double _Complex pow( double _Complex, double _Complex );
    123 long double _Complex pow( long double _Complex, long double _Complex );
    124 
    125 float sqrt( float );
    126 extern "C" { double sqrt( double ); }
    127 long double sqrt( long double );
    128 float _Complex sqrt( float _Complex );
    129 double _Complex sqrt( double _Complex );
    130 long double _Complex sqrt( long double _Complex );
    131 
    132 float fabs( float );
    133 extern "C" { double fabs( double ); }
    134 long double fabs( long double );
    135 float cabs( float _Complex );
    136 extern "C" { double cabs( double _Complex ); }
    137 long double cabs( long double _Complex );
     237//---------------------- Error / Gamma ----------------------
     238
     239float erf( float );
     240// extern "C" { double erf( double ); }
     241long 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
     246float erfc( float );
     247// extern "C" { double erfc( double ); }
     248long double erfc( long double );
     249// float _Complex erfc( float _Complex );
     250// double _Complex erfc( double _Complex );
     251// long double _Complex erfc( long double _Complex );
     252
     253float lgamma( float );
     254// extern "C" { double lgamma( double ); }
     255long double lgamma( long double );
     256float lgamma( float, int * );
     257double lgamma( double, int * );
     258long double lgamma( long double, int * );
     259
     260float tgamma( float );
     261// extern "C" { double tgamma( double ); }
     262long double tgamma( long double );
     263
     264//---------------------- Nearest Integer ----------------------
    138265
    139266float floor( float );
    140 extern "C" { double floor( double ); }
     267// extern "C" { double floor( double ); }
    141268long double floor( long double );
    142269
    143270float ceil( float );
    144 extern "C" { double ceil( double ); }
     271// extern "C" { double ceil( double ); }
    145272long double ceil( long double );
    146273
    147 //---------------------------------------
    148 
    149 float cbrt( float );
    150 extern "C" { double cbrt( double ); }
    151 long double cbrt( long double );
    152 
    153 float copysign( float, float );
    154 extern "C" { double copysign( double, double ); }
    155 long double copysign( long double, long double );
    156 
    157 float erf( float );
    158 extern "C" { double erf( double ); }
    159 long double erf( long double );
    160 
    161 float erfc( float );
    162 extern "C" { double erfc( double ); }
    163 long double erfc( long double );
    164 
    165 float exp2( float );
    166 extern "C" { double exp2( double ); }
    167 long double exp2( long double );
    168 
    169 float expm1( float );
    170 extern "C" { double expm1( double ); }
    171 long double expm1( long double );
    172 
    173 float fdim( float, float );
    174 extern "C" { double fdim( double, double ); }
    175 long double fdim( long double, long double );
    176 
    177 float fma( float, float, float );
    178 extern "C" { double fma( double, double, double ); }
    179 long double fma( long double, long double, long double );
    180 
    181 float ?%?( float, float );
    182 float fmod( float, float );
    183 double ?%?( double, double );
    184 extern "C" { double fmod( double, double ); }
    185 long double ?%?( long double, long double );
    186 long double fmod( long double, long double );
    187 
    188 [ int, float ] div( float x );
    189 float frexp( float, int * );
    190 [ int, double ] div( double x );
    191 extern "C" { double frexp( double, int * ); }
    192 [ int, long double ] div( long double x );
    193 long double frexp( long double, int * );
    194 
    195 float hypot( float, float );
    196 extern "C" { double hypot( double, double ); }
    197 long double hypot( long double, long double );
    198 
    199 int ilogb( float );
    200 extern "C" { int ilogb( double ); }
    201 int ilogb( long double );
    202 
    203 float ldexp( float, int );
    204 extern "C" { double ldexp( double, int ); }
    205 long double ldexp( long double, int );
    206 
    207 float lgamma( float );
    208 extern "C" { double lgamma( double ); }
    209 long double lgamma( long double );
    210 
    211 float rint( float x );
    212 long double rint( long double x );
    213 long int rint( float x );
    214 long int rint( double x );
    215 long int rint( long double x );
    216 long long int rint( float x );
    217 long long int rint( double x );
    218 long long int rint( long double x );
     274float trunc( float );
     275// extern "C" { double trunc( double ); }
     276long double trunc( long double );
     277
     278float rint( float );
     279long double rint( long double );
     280long int rint( float );
     281long int rint( double );
     282long int rint( long double );
     283long long int rint( float );
     284long long int rint( double );
     285long long int rint( long double );
    219286
    220287long int lrint( float );
    221 extern "C" { long int lrint( double ); }
     288// extern "C" { long int lrint( double ); }
    222289long int lrint( long double );
    223290long long int llrint( float );
    224 extern "C" { long long int llrint( double ); }
     291// extern "C" { long long int llrint( double ); }
    225292long long int llrint( long double );
    226293
    227 float round( float x );
    228 long double round( long double x );
    229 long int round( float x );
    230 long int round( double x );
    231 long int round( long double x );
    232 long long int round( float x );
    233 long long int round( double x );
    234 long long int round( long double x );
     294float nearbyint( float );
     295// extern "C" { double nearbyint( double ); }
     296long double nearbyint( long double );
     297
     298float round( float );
     299long double round( long double );
     300long int round( float );
     301long int round( double );
     302long int round( long double );
     303long long int round( float );
     304long long int round( double );
     305long long int round( long double );
    235306
    236307long int lround( float );
    237 extern "C" { long int lround( double ); }
     308// extern "C" { long int lround( double ); }
    238309long int lround( long double );
    239310long long int llround( float );
    240 extern "C" { long long int llround( double ); }
     311// extern "C" { long long int llround( double ); }
    241312long long int llround( long double );
    242313
    243 float log10( float );
    244 extern "C" { double log10( double ); }
    245 long double log10( long double );
    246 
    247 float log1p( float );
    248 extern "C" { double log1p( double ); }
    249 long double log1p( long double );
    250 
    251 float log2( float );
    252 extern "C" { double log2( double ); }
    253 long double log2( long double );
    254 
    255 float logb( float );
    256 extern "C" { double logb( double ); }
    257 long double logb( long double );
    258 
    259 float nearbyint( float );
    260 extern "C" { double nearbyint( double ); }
    261 long double nearbyint( long double );
     314//---------------------- Manipulation ----------------------
     315
     316float copysign( float, float );
     317// extern "C" { double copysign( double, double ); }
     318long double copysign( long double, long double );
     319
     320float frexp( float, int * );
     321// extern "C" { double frexp( double, int * ); }
     322long double frexp( long double, int * );
     323
     324float ldexp( float, int );
     325// extern "C" { double ldexp( double, int ); }
     326long double ldexp( long double, int );
     327
     328[ float, float ] modf( float );
     329float modf( float, float * );
     330[ double, double ] modf( double );
     331// extern "C" { double modf( double, double * ); }
     332[ long double, long double ] modf( long double );
     333long double modf( long double, long double * );
    262334
    263335float nextafter( float, float );
    264 extern "C" { double nextafter( double, double ); }
     336// extern "C" { double nextafter( double, double ); }
    265337long double nextafter( long double, long double );
    266338
    267339float nexttoward( float, long double );
    268 extern "C" { double nexttoward( double, long double ); }
     340// extern "C" { double nexttoward( double, long double ); }
    269341long double nexttoward( long double, long double );
    270342
    271 float remainder( float, float );
    272 extern "C" { double remainder( double, double ); }
    273 long double remainder( long double, long double );
    274 
    275 [ int, float ] remquo( float x, float y );
    276 float remquo( float, float, int * );
    277 [ int, double ] remquo( double x, double y );
    278 extern "C" { double remquo( double, double, int * ); }
    279 [ int, long double ] remquo( long double x, long double y );
    280 long double remquo( long double, long double, int * );
    281 
    282343float scalbn( float, int );
    283 extern "C" { double scalbn( double, int ); }
     344// extern "C" { double scalbn( double, int ); }
    284345long double scalbn( long double, int );
    285346
    286347float scalbln( float, long int );
    287 extern "C" { double scalbln( double, long int ); }
     348// extern "C" { double scalbln( double, long int ); }
    288349long double scalbln( long double, long int );
    289 
    290 float tgamma( float );
    291 extern "C" { double tgamma( double ); }
    292 long double tgamma( long double );
    293 
    294 float trunc( float );
    295 extern "C" { double trunc( double ); }
    296 long double trunc( long double );
    297350
    298351// Local Variables: //
  • src/libcfa/math.c

    r845cedc radd371c  
    1 //                               -*- Mode: C -*-
    21//
    32// Cforall Version 1.0.0 Copyright (C) 2016 University of Waterloo
     
    1110// Created On       : Tue Apr 19 22:23:08 2016
    1211// Last Modified By : Peter A. Buhr
    13 // Last Modified On : Thu Apr 21 07:56:49 2016
    14 // Update Count     : 51
     12// Last Modified On : Sun Apr 24 08:52:31 2016
     13// Update Count     : 75
    1514//
    1615
    1716#include "math"
    1817
    19 //---------------------------------------
    20 
    2118extern "C" {
    22 #include <math.h>
    2319#include <complex.h>
    2420} // extern "C"
     21
     22float fabs( float x ) { return fabsf( x ); }
     23long double fabs( long double x ) { return fabsl( x ); }
     24float cabs( float _Complex x ) { return cabsf( x ); }
     25double cabs( double _Complex x ) { return cabs( x ); }
     26long double cabs( long double _Complex x ) { return cabsl( x ); }
     27
     28float ?%?( float x, float y ) { return fmodf( x, y ); }
     29float fmod( float x, float y ) { return fmodf( x, y ); }
     30double ?%?( double x, double y ) { return fmod( x, y ); }
     31long double ?%?( long double x, long double y ) { return fmodl( x, y ); }
     32long double fmod( long double x, long double y ) { return fmodl( x, y ); }
     33
     34float remainder( float x, float y ) { return remainderf( x, y ); }
     35long 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 ]; }
     38float 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 ]; }
     41long 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 ]; }
     44float 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 ]; }
     47long double div( long double x, long double y, int *quo ) { return remquol( x, y, quo ); }
     48
     49float fma( float x, float y, float z ) { return fmaf( x, y, z ); }
     50long double fma( long double x, long double y, long double z ) { return fmal( x, y, z ); }
     51
     52float fdim( float x, float y ) { return fdimf( x, y ); }
     53long double fdim( long double x, long double y ) { return fdiml( x, y ); }
     54
     55float nan( const char *tag ) { return nanf( tag ); }
     56long double nan( const char *tag ) { return nanl( tag ); }
     57
     58//---------------------- Exponential ----------------------
     59
     60float exp( float x ) { return expf( x ); }
     61long double exp( long double x ) { return expl( x ); }
     62float _Complex exp( float _Complex x ) { return cexpf( x ); }
     63double _Complex exp( double _Complex x ) { return cexp( x ); }
     64long double _Complex exp( long double _Complex x ) { return cexpl( x ); }
     65
     66float exp2( float x ) { return exp2f( x ); }
     67long 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
     72float expm1( float x ) { return expm1f( x ); }
     73long double expm1( long double x ) { return expm1l( x ); }
     74
     75float log( float x ) { return logf( x ); }
     76long double log( long double x ) { return logl( x ); }
     77float _Complex log( float _Complex x ) { return clogf( x ); }
     78double _Complex log( double _Complex x ) { return clog( x ); }
     79long double _Complex log( long double _Complex x ) { return clogl( x ); }
     80
     81float log2( float x ) { return log2f( x ); }
     82long 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
     87float log10( float x ) { return log10f( x ); }
     88long 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
     93float log1p( float x ) { return log1pf( x ); }
     94long double log1p( long double x ) { return log1pl( x ); }
     95
     96int ilogb( float x ) { return ilogbf( x ); }
     97int ilogb( long double x ) { return ilogbl( x ); }
     98
     99float logb( float x ) { return logbf( x ); }
     100long double logb( long double x ) { return logbl( x ); }
     101
     102//---------------------- Power ----------------------
     103
     104float sqrt( float x ) { return sqrtf( x ); }
     105long double sqrt( long double x ) { return sqrtl( x ); }
     106float _Complex sqrt( float _Complex x ) { return csqrtf( x ); }
     107double _Complex sqrt( double _Complex x ) { return csqrt( x ); }
     108long double _Complex sqrt( long double _Complex x ) { return csqrtl( x ); }
     109
     110float cbrt( float x ) { return cbrtf( x ); }
     111long double cbrt( long double x ) { return cbrtl( x ); }
     112
     113float hypot( float x, float y ) { return hypotf( x, y ); }
     114long double hypot( long double x, long double y ) { return hypotl( x, y ); }
     115
     116float pow( float x, float y ) { return powf( x, y ); }
     117long double pow( long double x, long double y ) { return powl( x, y ); }
     118float _Complex pow( float _Complex x, float _Complex y ) { return cpowf( x, y ); }
     119double _Complex pow( double _Complex x, double _Complex y ) { return cpow( x, y ); }
     120long double _Complex pow( long double _Complex x, long double _Complex y ) { return cpowl( x, y ); }
     121
     122//---------------------- Trigonometric ----------------------
     123
     124float sin( float x ) { return sinf( x ); }
     125long double sin( long double x ) { return sinl( x ); }
     126float _Complex sin( float _Complex x ) { return csinf( x ); }
     127double _Complex sin( double _Complex x ) { return csin( x ); }
     128long double _Complex sin( long double _Complex x ) { return csinl( x ); }
    25129
    26130float cos( float x ) { return cosf( x ); }
     
    30134long double _Complex cos( long double _Complex x ) { return ccosl( x ); }
    31135
     136float tan( float x ) { return tanf( x ); }
     137long double tan( long double x ) { return tanl( x ); }
     138float _Complex tan( float _Complex x ) { return ctanf( x ); }
     139double _Complex tan( double _Complex x ) { return ctan( x ); }
     140long double _Complex tan( long double _Complex x ) { return ctanl( x ); }
     141
     142float asin( float x ) { return asinf( x ); }
     143long double asin( long double x ) { return asinl( x ); }
     144float _Complex asin( float _Complex x ) { return casinf( x ); }
     145double _Complex asin( double _Complex x ) { return casin( x ); }
     146long double _Complex asin( long double _Complex x ) { return casinl( x ); }
     147
     148float acos( float x ) { return acosf( x ); }
     149long double acos( long double x ) { return acosl( x ); }
     150float _Complex acos( float _Complex x ) { return cacosf( x ); }
     151double _Complex acos( double _Complex x ) { return cacos( x ); }
     152long double _Complex acos( long double _Complex x ) { return cacosl( x ); }
     153
     154float atan( float x ) { return atanf( x ); }
     155long double atan( long double x ) { return atanl( x ); }
     156float _Complex atan( float _Complex x ) { return catanf( x ); }
     157double _Complex atan( double _Complex x ) { return catan( x ); }
     158long double _Complex atan( long double _Complex x ) { return catanl( x ); }
     159
     160float atan2( float x, float y ) { return atan2f( x, y ); }
     161double atan2( double x, double y ) { return atan2( x, y ); }
     162long double atan2( long double x, long double y ) { return atan2l( x, y ); }
     163
     164float atan( float x, float y ) { return atan2f( x, y ); }
     165double atan( double x, double y ) { return atan2( x, y ); }
     166long double atan( long double x, long double y ) { return atan2l( x, y ); }
     167
     168//---------------------- Hyperbolic ----------------------
     169
     170float sinh( float x ) { return sinhf( x ); }
     171long double sinh( long double x ) { return sinhl( x ); }
     172float _Complex sinh( float _Complex x ) { return csinhf( x ); }
     173double _Complex sinh( double _Complex x ) { return csinh( x ); }
     174long double _Complex sinh( long double _Complex x ) { return csinhl( x ); }
     175
    32176float cosh( float x ) { return coshf( x ); }
    33177long double cosh( long double x ) { return coshl( x ); }
     
    36180long double _Complex cosh( long double _Complex x ) { return ccoshl( x ); }
    37181
    38 float acos( float x ) { return acosf( x ); }
    39 long double acos( long double x ) { return acosl( x ); }
    40 float _Complex acos( float _Complex x ) { return cacosf( x ); }
    41 double _Complex acos( double _Complex x ) { return cacos( x ); }
    42 long double _Complex acos( long double _Complex x ) { return cacosl( x ); }
     182float tanh( float x ) { return tanhf( x ); }
     183long double tanh( long double x ) { return tanhl( x ); }
     184float _Complex tanh( float _Complex x ) { return ctanhf( x ); }
     185double _Complex tanh( double _Complex x ) { return ctanh( x ); }
     186long double _Complex tanh( long double _Complex x ) { return ctanhl( x ); }
     187
     188float asinh( float x ) { return asinhf( x ); }
     189long double asinh( long double x ) { return asinhl( x ); }
     190float _Complex asinh( float _Complex x ) { return casinhf( x ); }
     191double _Complex asinh( double _Complex x ) { return casinh( x ); }
     192long double _Complex asinh( long double _Complex x ) { return casinhl( x ); }
    43193
    44194float acosh( float x ) { return acoshf( x ); }
     
    48198long double _Complex acosh( long double _Complex x ) { return cacoshl( x ); }
    49199
    50 float sin( float x ) { return sinf( x ); }
    51 long double sin( long double x ) { return sinl( x ); }
    52 float _Complex sin( float _Complex x ) { return csinf( x ); }
    53 double _Complex sin( double _Complex x ) { return csin( x ); }
    54 long double _Complex sin( long double _Complex x ) { return csinl( x ); }
    55 
    56 float sinh( float x ) { return sinhf( x ); }
    57 long double sinh( long double x ) { return sinhl( x ); }
    58 float _Complex sinh( float _Complex x ) { return csinhf( x ); }
    59 double _Complex sinh( double _Complex x ) { return csinh( x ); }
    60 long double _Complex sinh( long double _Complex x ) { return csinhl( x ); }
    61 
    62 float asin( float x ) { return asinf( x ); }
    63 long double asin( long double x ) { return asinl( x ); }
    64 float _Complex asin( float _Complex x ) { return casinf( x ); }
    65 double _Complex asin( double _Complex x ) { return casin( x ); }
    66 long double _Complex asin( long double _Complex x ) { return casinl( x ); }
    67 
    68 float asinh( float x ) { return asinhf( x ); }
    69 long double asinh( long double x ) { return asinhl( x ); }
    70 float _Complex asinh( float _Complex x ) { return casinhf( x ); }
    71 double _Complex asinh( double _Complex x ) { return casinh( x ); }
    72 long double _Complex asinh( long double _Complex x ) { return casinhl( x ); }
    73 
    74 float tan( float x ) { return tanf( x ); }
    75 long double tan( long double x ) { return tanl( x ); }
    76 float _Complex tan( float _Complex x ) { return ctanf( x ); }
    77 double _Complex tan( double _Complex x ) { return ctan( x ); }
    78 long double _Complex tan( long double _Complex x ) { return ctanl( x ); }
    79 
    80 float tanh( float x ) { return tanhf( x ); }
    81 long double tanh( long double x ) { return tanhl( x ); }
    82 float _Complex tanh( float _Complex x ) { return ctanhf( x ); }
    83 double _Complex tanh( double _Complex x ) { return ctanh( x ); }
    84 long double _Complex tanh( long double _Complex x ) { return ctanhl( x ); }
    85 
    86 float atan( float x ) { return atanf( x ); }
    87 long double atan( long double x ) { return atanl( x ); }
    88 float _Complex atan( float _Complex x ) { return catanf( x ); }
    89 double _Complex atan( double _Complex x ) { return catan( x ); }
    90 long double _Complex atan( long double _Complex x ) { return catanl( x ); }
    91 
    92 float atan( float x, float y ) { return atan2f( x, y ); }
    93 double atan( double x, double y ) { return atan2( x, y ); }
    94 long double atan( long double x, long double y ) { return atan2l( x, y ); }
    95 
    96200float atanh( float x ) { return atanhf( x ); }
    97201long double atanh( long double x ) { return atanhl( x ); }
     
    100204long double _Complex atanh( long double _Complex x ) { return catanhl( x ); }
    101205
    102 float exp( float x ) { return expf( x ); }
    103 long double exp( long double x ) { return expl( x ); }
    104 float _Complex exp( float _Complex x ) { return cexpf( x ); }
    105 double _Complex exp( double _Complex x ) { return cexp( x ); }
    106 long double _Complex exp( long double _Complex x ) { return cexpl( x ); }
    107 
    108 float log( float x ) { return logf( x ); }
    109 long double log( long double x ) { return logl( x ); }
    110 float _Complex log( float _Complex x ) { return clogf( x ); }
    111 double _Complex log( double _Complex x ) { return clog( x ); }
    112 long double _Complex log( long double _Complex x ) { return clogl( x ); }
    113 
    114 float pow( float x, float y ) { return powf( x, y ); }
    115 long double pow( long double x, long double y ) { return powl( x, y ); }
    116 float _Complex pow( float _Complex x, float _Complex y ) { return cpowf( x, y ); }
    117 double _Complex pow( double _Complex x, double _Complex y ) { return cpow( x, y ); }
    118 long double _Complex pow( long double _Complex x, long double _Complex y ) { return cpowl( x, y ); }
    119 
    120 float sqrt( float x ) { return sqrtf( x ); }
    121 long double sqrt( long double x ) { return sqrtl( x ); }
    122 float _Complex sqrt( float _Complex x ) { return csqrtf( x ); }
    123 double _Complex sqrt( double _Complex x ) { return csqrt( x ); }
    124 long double _Complex sqrt( long double _Complex x ) { return csqrtl( x ); }
    125 
    126 float fabs( float x ) { return fabsf( x ); }
    127 long double fabs( long double x ) { return fabsl( x ); }
    128 float cabs( float _Complex x ) { return cabsf( x ); }
    129 long double cabs( long double _Complex x ) { return cabsl( x ); }
     206//---------------------- Error / Gamma ----------------------
     207
     208float erf( float x ) { return erff( x ); }
     209long 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
     214float erfc( float x ) { return erfcf( x ); }
     215long 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 ); }
     219
     220float lgamma( float x ) { return lgammaf( x ); }
     221long double lgamma( long double x ) { return lgammal( x ); }
     222float lgamma( float x, int *sign ) { return lgammaf_r( x, sign ); }
     223double lgamma( double x, int *sign ) { return lgamma_r( x, sign ); }
     224long double lgamma( long double x, int *sign ) { return lgammal_r( x, sign ); }
     225
     226float tgamma( float x ) { return tgammaf( x ); }
     227long double tgamma( long double x ) { return tgammal( x ); }
     228
     229//---------------------- Nearest Integer ----------------------
    130230
    131231float floor( float x ) { return floorf( x ); }
     
    135235long double ceil( long double x ) { return ceill( x ); }
    136236
    137 //---------------------------------------
    138 
    139 float cbrt( float x ) { return cbrtf( x ); }
    140 long double cbrt( long double x ) { return cbrtl( x ); }
    141 
    142 float copysign( float x, float y ) { return copysignf( x, y ); }
    143 long double copysign( long double x, long double y ) { return copysignl( x, y ); }
    144 
    145 float erf( float x ) { return erff( x ); }
    146 long double erf( long double x ) { return erfl( x ); }
    147 
    148 float erfc( float x ) { return erfcf( x ); }
    149 long double erfc( long double x ) { return erfcl( x ); }
    150 
    151 float exp2( float x ) { return exp2f( x ); }
    152 long double exp2( long double x ) { return exp2l( x ); }
    153 
    154 float expm1( float x ) { return expm1f( x ); }
    155 long double expm1( long double x ) { return expm1l( x ); }
    156 
    157 float fdim( float x, float y ) { return fdimf( x, y ); }
    158 long double fdim( long double x, long double y ) { return fdiml( x, y ); }
    159 
    160 float fma( float x, float y, float z ) { return fmaf( x, y, z ); }
    161 long double fma( long double x, long double y, long double z ) { return fmal( x, y, z ); }
    162 
    163 float ?%?( float x, float y ) { return fmodf( x, y ); }
    164 float fmod( float x, float y ) { return fmodf( x, y ); }
    165 double ?%?( double x, double y ) { return fmod( x, y ); }
    166 long double ?%?( long double x, long double y ) { return fmodl( x, y ); }
    167 long double fmod( long double x, long double y ) { return fmodl( x, y ); }
    168 
    169 //[ int, float ] div( float x ) { int i; x = frexpf( x, &i ); return [ i, x ]; }
    170 float 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 ]; }
    173 long double frexp( long double x, int *ip ) { return frexpl( x, ip ); }
    174 
    175 float hypot( float x, float y ) { return hypotf( x, y ); }
    176 long double hypot( long double x, long double y ) { return hypotl( x, y ); }
    177 
    178 int ilogb( float x ) { return ilogbf( x ); }
    179 int ilogb( long double x ) { return ilogbl( x ); }
    180 
    181 float ldexp( float x, int exp2 ) { return ldexpf( x, exp2 ); }
    182 long double ldexp( long double x, int exp2 ) { return ldexpl( x, exp2 ); }
    183 
    184 float lgamma( float x ) { return lgammaf( x ); }
    185 long double lgamma( long double x ) { return lgammal( x ); }
     237float trunc( float x ) { return truncf( x ); }
     238long double trunc( long double x ) { return truncl( x ); }
    186239
    187240float rint( float x ) { return rintf( x ); }
     
    199252long long int llrint( long double x ) { return llrintl( x ); }
    200253
     254float nearbyint( float x ) { return nearbyintf( x ); }
     255long double nearbyint( long double x ) { return nearbyintl( x ); }
     256
    201257float round( float x ) { return roundf( x ); }
    202258long double round( long double x ) { return roundl( x ); }
     
    213269long long int llround( long double x ) { return llroundl( x ); }
    214270
    215 float log10( float x ) { return log10f( x ); }
    216 long double log10( long double x ) { return log10l( x ); }
    217 
    218 float log1p( float x ) { return log1pf( x ); }
    219 long double log1p( long double x ) { return log1pl( x ); }
    220 
    221 float log2( float x ) { return log2f( x ); }
    222 long double log2( long double x ) { return log2l( x ); }
    223 
    224 float logb( float x ) { return logbf( x ); }
    225 long double logb( long double x ) { return logbl( x ); }
    226 
    227 float nearbyint( float x ) { return nearbyintf( x ); }
    228 long double nearbyint( long double x ) { return nearbyintl( x ); }
     271//---------------------- Manipulation ----------------------
     272
     273float copysign( float x, float y ) { return copysignf( x, y ); }
     274long double copysign( long double x, long double y ) { return copysignl( x, y ); }
     275
     276float frexp( float x, int *ip ) { return frexpf( x, ip ); }
     277long double frexp( long double x, int *ip ) { return frexpl( x, ip ); }
     278
     279float ldexp( float x, int exp2 ) { return ldexpf( x, exp2 ); }
     280long 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 ]; }
     283float 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 ]; }
     286long double modf( long double x, long double *i ) { return modfl( x, i ); }
    229287
    230288float nextafter( float x, float y ) { return nextafterf( x, y ); }
     
    233291float nexttoward( float x, long double y ) { return nexttowardf( x, y ); }
    234292long double nexttoward( long double x, long double y ) { return nexttowardl( x, y ); }
    235 
    236 float remainder( float x, float y ) { return remainderf( x, y ); }
    237 long 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 ]; }
    240 float 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 ]; }
    243 long double remquo( long double x, long double y, int *quo ) { return remquol( x, y, quo ); }
    244293
    245294float scalbn( float x, int exp ) { return scalbnf( x, exp ); }
     
    252301long double scalbln( long double x, long int exp ) { return scalblnl( x, exp ); }
    253302
    254 float tgamma( float x ) { return tgammaf( x ); }
    255 long double tgamma( long double x ) { return tgammal( x ); }
    256 
    257 float trunc( float x ) { return truncf( x ); }
    258 long double trunc( long double x ) { return truncl( x ); }
    259 
    260303// Local Variables: //
    261304// mode: c //
Note: See TracChangeset for help on using the changeset viewer.