fn_impl.c

   1 /*
   2  * Copyright (C) 2024 Mikulas Patocka
   3  *
   4  * This file is part of Ajla.
   5  *
   6  * Ajla is free software: you can redistribute it and/or modify it under the
   7  * terms of the GNU General Public License as published by the Free Software
   8  * Foundation, either version 3 of the License, or (at your option) any later
   9  * version.
  10  *
  11  * Ajla is distributed in the hope that it will be useful, but WITHOUT ANY
  12  * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
  13  * A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License along with
  16  * Ajla. If not, see <https://www.gnu.org/licenses/>.
  17  */
  18
  19 #include "ajla.h"
  20
  21 #include "str.h"
  22
  23 #ifndef HAVE_GETENV
  24 char *getenv(const char attr_unused *name)
  25 {
  26         return NULL;
  27 }
  28 #endif
  29
  30 #ifndef HAVE_MEMPCPY
  31 void *mempcpy(void *dst, const void *src, size_t length)
  32 {
  33         (void)memcpy(dst, src, length);
  34         return (char *)dst + length;
  35 }
  36 #endif
  37
  38 #ifndef HAVE_STRERROR
  39 char *strerror(int errnum)
  40 {
  41         static char buffer[6 + 1 + (sizeof(int) * 5 / 2 + 1) + 1] = "error ";
  42         char *b = buffer + 6;
  43         str_add_signed(&b, NULL, (intbig_t)errnum, 10);
  44         return buffer;
  45 }
  46 #endif
  47
  48 #ifndef HAVE_STRNLEN
  49 size_t strnlen(const char *s, size_t maxlen)
  50 {
  51         size_t l;
  52         for (l = 0; l < maxlen; l++)
  53                 if (unlikely(!s[l]))
  54                         break;
  55         return l;
  56 }
  57 #endif
  58
  59 #if !defined(HAVE_CBRT)
  60 double cbrt(double x)
  61 {
  62         if (unlikely(x <= 0)) {
  63                 if (x == 0)
  64                         return x;
  65                 else
  66                         return -pow(-x, 1./3.);
  67         }
  68         return pow(x, 1./3.);
  69 }
  70 #endif
  71
  72 #if !defined(HAVE_CBRTF)
  73 float cbrtf(float x)
  74 {
  75         if (unlikely(x <= 0)) {
  76                 if (x == 0)
  77                         return x;
  78                 else
  79                         return -powf(-x, 1./3.);
  80         }
  81         return powf(x, 1./3.);
  82 }
  83 #endif
  84
  85 #if defined(HAVE_LONG_DOUBLE) && !defined(HAVE_CBRTL)
  86 float cbrtl(float x)
  87 {
  88         if (unlikely(x <= 0)) {
  89                 if (x == 0)
  90                         return x;
  91                 else
  92                         return -powl(-x, 1./3.);
  93         }
  94         return powl(x, 1.L/3.L);
  95 }
  96 #endif
  97
  98 #if !defined(HAVE_ASINH)
  99 double asinh(double x)
 100 {
 101         return log(x + sqrt(x * x + 1));
 102 }
 103 #endif
 104
 105 #if defined(HAVE_LONG_DOUBLE) && !defined(HAVE_ASINHL)
 106 long double asinhl(long double x)
 107 {
 108         return logl(x + sqrtl(x * x + 1));
 109 }
 110 #endif
 111
 112 #if !defined(HAVE_ACOSH)
 113 double acosh(double x)
 114 {
 115         return log(x + sqrt(x * x - 1));
 116 }
 117 #endif
 118
 119 #if defined(HAVE_LONG_DOUBLE) && !defined(HAVE_ACOSHL)
 120 long double acoshl(long double x)
 121 {
 122         return logl(x + sqrtl(x * x - 1));
 123 }
 124 #endif
 125
 126 #if !defined(HAVE_ATANH)
 127 double atanh(double x)
 128 {
 129         return 0.5 * log((1 + x) / (1 - x));
 130 }
 131 #endif
 132
 133 #if defined(HAVE_LONG_DOUBLE) && !defined(HAVE_ATANHL)
 134 long double atanhl(long double x)
 135 {
 136         return 0.5 * logl((1 + x) / (1 - x));
 137 }
 138 #endif
 139
 140 #if !defined(HAVE_EXP2)
 141 double exp2(double x)
 142 {
 143         return pow(2, x);
 144 }
 145 #endif
 146
 147 #if !defined(HAVE_EXP2F)
 148 float exp2f(float x)
 149 {
 150         return powf(2, x);
 151 }
 152 #endif
 153
 154 #if defined(HAVE_LONG_DOUBLE) && !defined(HAVE_EXP2L)
 155 long double exp2l(long double x)
 156 {
 157         return powl(2, x);
 158 }
 159 #endif
 160
 161 #if defined(HAVE___FLOAT128) && defined(HAVE_LIBQUADMATH) && defined(HAVE_QUADMATH_H) && !defined(HAVE_EXP2Q)
 162 __float128 exp2q(__float128 x)
 163 {
 164         return powq(2, x);
 165 }
 166 #endif
 167
 168 #if !defined(HAVE_EXP10)
 169 double exp10(double x)
 170 {
 171         return pow(10, x);
 172 }
 173 #endif
 174
 175 #if !defined(HAVE_EXP10F)
 176 float exp10f(float x)
 177 {
 178         return powf(10, x);
 179 }
 180 #endif
 181
 182 #if defined(HAVE_LONG_DOUBLE) && !defined(HAVE_EXP10L)
 183 long double exp10l(long double x)
 184 {
 185         return powl(10, x);
 186 }
 187 #endif
 188
 189 #if defined(HAVE___FLOAT128) && defined(HAVE_LIBQUADMATH) && defined(HAVE_QUADMATH_H) && !defined(HAVE_EXP10Q)
 190 __float128 exp10q(__float128 x)
 191 {
 192         return powq(10, x);
 193 }
 194 #endif
 195
 196 #if !defined(HAVE_LOG2)
 197 double log2(double x)
 198 {
 199         return log(x) / log(2);
 200 }
 201 #endif
 202
 203 #if !defined(HAVE_LOG2F)
 204 float log2f(float x)
 205 {
 206         return logf(x) / logf(2);
 207 }
 208 #endif
 209
 210 #if defined(HAVE_LONG_DOUBLE) && !defined(HAVE_LOG2L)
 211 long double log2l(long double x)
 212 {
 213         return logl(x) / logl(2);
 214 }
 215 #endif
 216
 217 #if !defined(HAVE_TRUNC)
 218 double trunc(double x)
 219 {
 220         if (x >= 0)
 221                 return floor(x);
 222         else
 223                 return ceil(x);
 224 }
 225 #endif
 226
 227 #if !defined(HAVE_TRUNCF)
 228 float truncf(float x)
 229 {
 230         if (x >= 0)
 231                 return floorf(x);
 232         else
 233                 return ceilf(x);
 234 }
 235 #endif
 236
 237 #if defined(HAVE_LONG_DOUBLE) && !defined(HAVE_TRUNCL)
 238 long double truncl(long double x)
 239 {
 240         if (x >= 0)
 241                 return floorl(x);
 242         else
 243                 return ceill(x);
 244 }
 245 #endif
 246
 247 #if !defined(HAVE_RINT)
 248 double rint(double x)
 249 {
 250         if (x >= 0)
 251                 return floor(x + 0.5);
 252         else
 253                 return ceil(x - 0.5);
 254 }
 255 #endif
 256
 257 #if !defined(HAVE_RINTF)
 258 float rintf(float x)
 259 {
 260         return rint(x);
 261 }
 262 #endif
 263
 264 #if !defined(HAVE_MODFF)
 265 float modff(float x, float *iflt)
 266 {
 267         double idbl;
 268         double r = modf(x, &idbl);
 269         *iflt = idbl;
 270         return r;
 271 }
 272 #endif
 273
 274 #if defined(HAVE_BUGGY_LDEXP) && defined(SIZEOF_LONG_DOUBLE) && SIZEOF_LONG_DOUBLE > 8 && defined(HAVE_LDEXPL)
 275 double ldexp(double x, int exp)
 276 {
 277         return ldexpl(x, exp);
 278 }
 279 #endif