Stanislav Erokhin
f624800b84
I was forced to manually do update the following files, because otherwise they would be ignored according .gitignore settings. Probably they should be deleted from repo. Interop/.idea/compiler.xml Interop/.idea/gradle.xml Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_runtime_1_0_3.xml Interop/.idea/libraries/Gradle__org_jetbrains_kotlin_kotlin_stdlib_1_0_3.xml Interop/.idea/modules.xml Interop/.idea/modules/Indexer/Indexer.iml Interop/.idea/modules/Runtime/Runtime.iml Interop/.idea/modules/StubGenerator/StubGenerator.iml backend.native/backend.native.iml backend.native/bc.frontend/bc.frontend.iml backend.native/cli.bc/cli.bc.iml backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2Native.kt backend.native/cli.bc/src/org/jetbrains/kotlin/cli/bc/K2NativeCompilerArguments.kt backend.native/tests/link/lib/foo.kt backend.native/tests/link/lib/foo2.kt backend.native/tests/teamcity-test.property
581 lines
21 KiB
C++
581 lines
21 KiB
C++
/*
|
|
* Copyright 2010-2018 JetBrains s.r.o.
|
|
*
|
|
* Licensed under the Apache License, Version 2.0 (the "License");
|
|
* you may not use this file except in compliance with the License.
|
|
* You may obtain a copy of the License at
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS,
|
|
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
* See the License for the specific language governing permissions and
|
|
* limitations under the License.
|
|
*/
|
|
|
|
#include <float.h>
|
|
#include <math.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "DoubleConversions.h"
|
|
#include "Exceptions.h"
|
|
#include "KotlinMath.h"
|
|
#include "ReturnSlot.h"
|
|
#include "Types.h"
|
|
|
|
#if (__MINGW32__ || __MINGW64__)
|
|
#define KONAN_NEED_ASINH_ACOSH 1
|
|
#else
|
|
#define KONAN_NEED_ASINH_ACOSH 0
|
|
#endif
|
|
|
|
|
|
#if KONAN_NEED_ASINH_ACOSH
|
|
namespace {
|
|
|
|
// MinGW's implmenetation of asinh/acosh function returns NaN for large arguments so we use another implementation.
|
|
// Both implementations derived from boost special math functions and are also used by Kotlin/JVM.
|
|
// Copyright Eric Ford & Hubert Holin 2001.
|
|
|
|
constexpr KDouble LN2 = 0.69314718055994530942;
|
|
constexpr KDouble SQRT2 = 1.41421356237309504880;
|
|
|
|
KDouble taylor_2_bound = sqrt(DBL_EPSILON);
|
|
KDouble taylor_n_bound = sqrt(taylor_2_bound);
|
|
KDouble upper_taylor_2_bound = 1.0 / taylor_2_bound;
|
|
KDouble upper_taylor_n_bound = 1.0 / taylor_n_bound;
|
|
|
|
KDouble custom_asinh(KDouble x) {
|
|
if (x >= +taylor_n_bound) {
|
|
if (x > upper_taylor_n_bound) {
|
|
if (x > upper_taylor_2_bound) {
|
|
// approximation by laurent series in 1/x at 0+ order from -1 to 0
|
|
return log(x) + LN2;
|
|
} else {
|
|
// approximation by laurent series in 1/x at 0+ order from -1 to 1
|
|
return log(x * 2 + (1.0 / (x * 2)));
|
|
}
|
|
} else {
|
|
return log(x + sqrt(x * x + 1));
|
|
}
|
|
} else if (x <= -taylor_n_bound) {
|
|
return -custom_asinh(-x);
|
|
} else {
|
|
// approximation by taylor series in x at 0 up to order 2
|
|
KDouble result = x;
|
|
if (fabs(x) >= taylor_2_bound) {
|
|
// approximation by taylor series in x at 0 up to order 4
|
|
result -= (x * x * x) / 6;
|
|
}
|
|
return result;
|
|
}
|
|
}
|
|
|
|
KDouble custom_acosh(KDouble x) {
|
|
if (x < 1) {
|
|
return NAN;
|
|
} else if (x > upper_taylor_2_bound) {
|
|
// approximation by laurent series in 1/x at 0+ order from -1 to 0
|
|
return log(x) + LN2;
|
|
} else if (x - 1 >= taylor_n_bound) {
|
|
return log(x + sqrt(x * x - 1));
|
|
} else {
|
|
KDouble y = sqrt(x - 1);
|
|
// approximation by taylor series in y at 0 up to order 2
|
|
KDouble result = y;
|
|
if (y >= taylor_2_bound) {
|
|
// approximation by taylor series in y at 0 up to order 4
|
|
result -= (y * y * y) / 12;
|
|
}
|
|
return SQRT2 * result;
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
|
|
extern "C" {
|
|
|
|
#ifndef KONAN_NO_MATH // We have a platform math library. Call its math functions.
|
|
|
|
#ifndef KONAN_WASM // Use libm.
|
|
|
|
// region Double math.
|
|
|
|
KDouble Kotlin_math_sin(KDouble x) { return sin(x); }
|
|
KDouble Kotlin_math_cos(KDouble x) { return cos(x); }
|
|
KDouble Kotlin_math_tan(KDouble x) { return tan(x); }
|
|
KDouble Kotlin_math_asin(KDouble x) { return asin(x); }
|
|
KDouble Kotlin_math_acos(KDouble x) { return acos(x); }
|
|
KDouble Kotlin_math_atan(KDouble x) { return atan(x); }
|
|
KDouble Kotlin_math_atan2(KDouble y, KDouble x) { return atan2(y, x); }
|
|
|
|
KDouble Kotlin_math_sinh(KDouble x) { return sinh(x); }
|
|
KDouble Kotlin_math_cosh(KDouble x) { return cosh(x); }
|
|
KDouble Kotlin_math_tanh(KDouble x) { return tanh(x); }
|
|
|
|
KDouble Kotlin_math_asinh(KDouble x) {
|
|
#if (KONAN_NEED_ASINH_ACOSH)
|
|
return custom_asinh(x);
|
|
#else
|
|
return asinh(x);
|
|
#endif
|
|
}
|
|
|
|
KDouble Kotlin_math_acosh(KDouble x) {
|
|
#if (KONAN_NEED_ASINH_ACOSH)
|
|
return custom_acosh(x);
|
|
#else
|
|
return acosh(x);
|
|
#endif
|
|
}
|
|
|
|
KDouble Kotlin_math_atanh(KDouble x) { return atanh(x); }
|
|
|
|
KDouble Kotlin_math_hypot(KDouble x, KDouble y) {
|
|
if (isinf(x) || isinf(y)) return INFINITY;
|
|
if (isnan(x) || isnan(y)) return NAN;
|
|
return hypot(x, y);
|
|
}
|
|
|
|
KDouble Kotlin_math_sqrt(KDouble x) { return sqrt(x); }
|
|
KDouble Kotlin_math_exp(KDouble x) { return exp(x); }
|
|
KDouble Kotlin_math_expm1(KDouble x) { return expm1(x); }
|
|
|
|
KDouble Kotlin_math_ln(KDouble x) { return log(x); }
|
|
KDouble Kotlin_math_log10(KDouble x) { return log10(x); }
|
|
KDouble Kotlin_math_log2(KDouble x) { return log2(x); }
|
|
KDouble Kotlin_math_ln1p(KDouble x) { return log1p(x); }
|
|
|
|
KDouble Kotlin_math_ceil(KDouble x) { return ceil(x); }
|
|
KDouble Kotlin_math_floor(KDouble x) { return floor(x); }
|
|
KDouble Kotlin_math_round(KDouble x) { return rint(x); }
|
|
|
|
KDouble Kotlin_math_abs(KDouble x) { return fabs(x); }
|
|
|
|
// extensions
|
|
|
|
KDouble Kotlin_math_Double_pow(KDouble thiz, KDouble x) {
|
|
// Kotlin corner cases
|
|
if (x == 0.0 || x == -0.0) return 1.0;
|
|
if (isinf(x) && (thiz == 1.0 || thiz == -1.0)) return NAN;
|
|
return pow(thiz, x);
|
|
}
|
|
|
|
KDouble Kotlin_math_Double_IEEErem(KDouble thiz, KDouble divisor) { return remainder(thiz, divisor); }
|
|
KDouble Kotlin_math_Double_withSign(KDouble thiz, KDouble sign) { return copysign(thiz, sign); }
|
|
|
|
KDouble Kotlin_math_Double_nextUp(KDouble thiz) { return nextafter(thiz, HUGE_VAL); }
|
|
KDouble Kotlin_math_Double_nextDown(KDouble thiz) { return nextafter(thiz, -HUGE_VAL); }
|
|
KDouble Kotlin_math_Double_nextTowards(KDouble thiz, KDouble to) {
|
|
return (thiz == to) ? to : nextafter(thiz, to);
|
|
}
|
|
|
|
KBoolean Kotlin_math_Double_signBit(KDouble thiz) { return signbit(thiz) != 0; }
|
|
|
|
// endregion
|
|
|
|
// region Float math.
|
|
|
|
KFloat Kotlin_math_sinf(KFloat x) { return sinf(x); }
|
|
KFloat Kotlin_math_cosf(KFloat x) { return cosf(x); }
|
|
KFloat Kotlin_math_tanf(KFloat x) { return tanf(x); }
|
|
KFloat Kotlin_math_asinf(KFloat x) { return asinf(x); }
|
|
KFloat Kotlin_math_acosf(KFloat x) { return acosf(x); }
|
|
KFloat Kotlin_math_atanf(KFloat x) { return atanf(x); }
|
|
KFloat Kotlin_math_atan2f(KFloat y, KFloat x) { return atan2f(y, x); }
|
|
|
|
KFloat Kotlin_math_sinhf(KFloat x) { return sinhf(x); }
|
|
KFloat Kotlin_math_coshf(KFloat x) { return coshf(x); }
|
|
KFloat Kotlin_math_tanhf(KFloat x) { return tanhf(x); }
|
|
|
|
KFloat Kotlin_math_asinhf(KFloat x) {
|
|
#if (KONAN_NEED_ASINH_ACOSH)
|
|
return (KFloat)custom_asinh((KDouble)x);
|
|
#else
|
|
return asinhf(x);
|
|
#endif
|
|
}
|
|
|
|
KFloat Kotlin_math_acoshf(KFloat x) {
|
|
#if (KONAN_NEED_ASINH_ACOSH)
|
|
return (KFloat)custom_acosh((KDouble)x);
|
|
#else
|
|
return acoshf(x);
|
|
#endif
|
|
}
|
|
|
|
KFloat Kotlin_math_atanhf(KFloat x) { return atanhf(x); }
|
|
|
|
KFloat Kotlin_math_hypotf(KFloat x, KFloat y) {
|
|
if (isinf(x) || isinf(y)) return INFINITY;
|
|
if (isnan(x) || isnan(y)) return NAN;
|
|
return hypotf(x, y);
|
|
}
|
|
|
|
KFloat Kotlin_math_sqrtf(KFloat x) { return sqrtf(x); }
|
|
KFloat Kotlin_math_expf(KFloat x) { return expf(x); }
|
|
KFloat Kotlin_math_expm1f(KFloat x) { return expm1f(x); }
|
|
|
|
KFloat Kotlin_math_lnf(KFloat x) { return logf(x); }
|
|
KFloat Kotlin_math_log10f(KFloat x) { return log10f(x); }
|
|
KFloat Kotlin_math_log2f(KFloat x) { return log2f(x); }
|
|
KFloat Kotlin_math_ln1pf(KFloat x) { return log1pf(x); }
|
|
|
|
KFloat Kotlin_math_ceilf(KFloat x) { return ceilf(x); }
|
|
KFloat Kotlin_math_floorf(KFloat x) { return floorf(x); }
|
|
KFloat Kotlin_math_roundf(KFloat x) { return rintf(x); }
|
|
|
|
KFloat Kotlin_math_absf(KFloat x) { return fabsf(x); }
|
|
|
|
// extensions
|
|
|
|
KFloat Kotlin_math_Float_pow(KFloat thiz, KFloat x) {
|
|
// Kotlin corner cases
|
|
if (x == 0.0 || x == -0.0) return 1.0;
|
|
if (isinf(x) && (thiz == 1.0 || thiz == -1.0)) return NAN;
|
|
return powf(thiz, x);
|
|
}
|
|
|
|
KFloat Kotlin_math_Float_IEEErem(KFloat thiz, KFloat divisor) { return remainderf(thiz, divisor); }
|
|
KFloat Kotlin_math_Float_withSign(KFloat thiz, KFloat sign) { return copysignf(thiz, sign); }
|
|
|
|
KFloat Kotlin_math_Float_nextUp(KFloat thiz) { return nextafterf(thiz, HUGE_VALF); }
|
|
KFloat Kotlin_math_Float_nextDown(KFloat thiz) { return nextafterf(thiz, -HUGE_VALF); }
|
|
KFloat Kotlin_math_Float_nextTowards(KFloat thiz, KFloat to) {
|
|
return (thiz == to) ? to : nextafterf(thiz, to);
|
|
}
|
|
|
|
KBoolean Kotlin_math_Float_signBit(KFloat thiz) { return signbit(thiz) != 0; }
|
|
|
|
// endregion
|
|
|
|
// region Integer math.
|
|
|
|
KInt Kotlin_math_absi(KInt x) { return labs(x); }
|
|
KLong Kotlin_math_absl(KLong x) { return llabs(x); }
|
|
|
|
// endregion
|
|
|
|
#else // KONAN_WASM defined. Use JS math implementation.
|
|
|
|
#define RETURN_RESULT_OF_JS_CALL(call, doubleArg) { \
|
|
call(doubleUpper(doubleArg), doubleLower(doubleArg)); \
|
|
return ReturnSlot_getDouble(); \
|
|
}
|
|
|
|
#define RETURN_RESULT_OF_JS_CALL2(call, doubleArg1, doubleArg2) { \
|
|
call(doubleUpper(doubleArg1), \
|
|
doubleLower(doubleArg1), \
|
|
doubleUpper(doubleArg2), \
|
|
doubleLower(doubleArg2)); \
|
|
return ReturnSlot_getDouble(); \
|
|
}
|
|
|
|
KDouble Kotlin_math_sin(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_sin, x); }
|
|
KDouble Kotlin_math_cos(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_cos, x); }
|
|
KDouble Kotlin_math_tan(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_tan, x); }
|
|
KDouble Kotlin_math_asin(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_asin, x); }
|
|
KDouble Kotlin_math_acos(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_acos, x); }
|
|
KDouble Kotlin_math_atan(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_atan, x); }
|
|
|
|
KDouble Kotlin_math_sinh(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_sinh, x); }
|
|
KDouble Kotlin_math_cosh(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_cosh, x); }
|
|
KDouble Kotlin_math_tanh(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_tanh, x); }
|
|
KDouble Kotlin_math_asinh(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_asinh, x); }
|
|
KDouble Kotlin_math_acosh(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_acosh, x); }
|
|
KDouble Kotlin_math_atanh(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_atanh, x); }
|
|
|
|
KDouble Kotlin_math_sqrt(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_sqrt, x); }
|
|
KDouble Kotlin_math_exp(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_exp, x); }
|
|
KDouble Kotlin_math_expm1(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_expm1, x); }
|
|
|
|
KDouble Kotlin_math_ln(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_log, x); }
|
|
KDouble Kotlin_math_log10(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_log10, x); }
|
|
KDouble Kotlin_math_log2(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_log2, x); }
|
|
KDouble Kotlin_math_ln1p(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_log1p, x); }
|
|
|
|
KDouble Kotlin_math_ceil(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_ceil, x); }
|
|
KDouble Kotlin_math_floor(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_floor, x); }
|
|
|
|
KDouble Kotlin_math_round(KDouble x) {
|
|
if (fmod(x, 0.5) != 0.0) {
|
|
RETURN_RESULT_OF_JS_CALL(knjs__Math_round, x);
|
|
}
|
|
KDouble f = floor(x);
|
|
return (fmod(f, 2) == 0.0) ? f : ceil(x);
|
|
}
|
|
|
|
KDouble Kotlin_math_abs(KDouble x) { RETURN_RESULT_OF_JS_CALL(knjs__Math_abs, x); }
|
|
|
|
KDouble Kotlin_math_atan2(KDouble y, KDouble x) { RETURN_RESULT_OF_JS_CALL2(knjs__Math_atan2, y, x); }
|
|
KDouble Kotlin_math_hypot(KDouble x, KDouble y) { RETURN_RESULT_OF_JS_CALL2(knjs__Math_hypot, x, y); }
|
|
|
|
// extensions
|
|
|
|
KDouble Kotlin_math_Double_pow(KDouble thiz, KDouble x) { RETURN_RESULT_OF_JS_CALL2(knjs__Math_pow, thiz, x); }
|
|
|
|
KDouble Kotlin_math_Double_IEEErem(KDouble thiz, KDouble divisor) {
|
|
if (isnan(thiz) || isnan(divisor) || isinf(thiz) || divisor == 0.0) {
|
|
return NAN;
|
|
}
|
|
if (!isinf(thiz) && isinf(divisor)) {
|
|
return thiz;
|
|
}
|
|
KDouble rounded = Kotlin_math_round(thiz / divisor);
|
|
return thiz - rounded * divisor;
|
|
}
|
|
|
|
KDouble Kotlin_math_Double_nextUp(KDouble thiz) {
|
|
if (isnan(thiz) || thiz == HUGE_VAL) {
|
|
return thiz;
|
|
}
|
|
if (thiz == 0.0) {
|
|
return DBL_TRUE_MIN;
|
|
}
|
|
return bitsToDouble(doubleToBits(thiz) + (thiz > 0 ? 1 : -1));
|
|
}
|
|
|
|
KDouble Kotlin_math_Double_nextDown(KDouble thiz) {
|
|
if (isnan(thiz) || thiz == -HUGE_VAL) {
|
|
return thiz;
|
|
}
|
|
if (thiz == 0.0) {
|
|
return -DBL_TRUE_MIN;
|
|
}
|
|
return bitsToDouble(doubleToBits(thiz) - (thiz > 0 ? 1 : -1));
|
|
}
|
|
|
|
KDouble Kotlin_math_Double_nextTowards(KDouble thiz, KDouble to) {
|
|
if (isnan(thiz) || isnan(to)) {
|
|
return NAN;
|
|
}
|
|
if (to > thiz) {
|
|
return Kotlin_math_Double_nextUp(thiz);
|
|
}
|
|
if (to < thiz) {
|
|
return Kotlin_math_Double_nextDown(thiz);
|
|
}
|
|
// thiz == to
|
|
return to;
|
|
}
|
|
|
|
KBoolean Kotlin_math_Double_signBit(KDouble thiz) {
|
|
return (doubleToBits(thiz) & (KLong) 1 << 63) != 0;
|
|
}
|
|
|
|
KDouble Kotlin_math_Double_withSign(KDouble thiz, KDouble sign) {
|
|
bool oldSign = Kotlin_math_Double_signBit(thiz);
|
|
bool newSign = Kotlin_math_Double_signBit(sign);
|
|
return (oldSign == newSign) ? thiz : -thiz;
|
|
}
|
|
|
|
// endregion
|
|
|
|
// region Float math.
|
|
|
|
KFloat Kotlin_math_sinf(KFloat x) { return (KFloat)Kotlin_math_sin (x); }
|
|
KFloat Kotlin_math_cosf(KFloat x) { return (KFloat)Kotlin_math_cos (x); }
|
|
KFloat Kotlin_math_tanf(KFloat x) { return (KFloat)Kotlin_math_tan (x); }
|
|
KFloat Kotlin_math_asinf(KFloat x) { return (KFloat)Kotlin_math_asin (x); }
|
|
KFloat Kotlin_math_acosf(KFloat x) { return (KFloat)Kotlin_math_acos (x); }
|
|
KFloat Kotlin_math_atanf(KFloat x) { return (KFloat)Kotlin_math_atan (x); }
|
|
|
|
KFloat Kotlin_math_sinhf(KFloat x) { return (KFloat)Kotlin_math_sinh (x); }
|
|
KFloat Kotlin_math_coshf(KFloat x) { return (KFloat)Kotlin_math_cosh (x); }
|
|
KFloat Kotlin_math_tanhf(KFloat x) { return (KFloat)Kotlin_math_tanh (x); }
|
|
KFloat Kotlin_math_asinhf(KFloat x) { return (KFloat)Kotlin_math_asinh (x); }
|
|
KFloat Kotlin_math_acoshf(KFloat x) { return (KFloat)Kotlin_math_acosh (x); }
|
|
KFloat Kotlin_math_atanhf(KFloat x) { return (KFloat)Kotlin_math_atanh (x); }
|
|
|
|
KFloat Kotlin_math_sqrtf(KFloat x) { return (KFloat)Kotlin_math_sqrt (x); }
|
|
KFloat Kotlin_math_expf(KFloat x) { return (KFloat)Kotlin_math_exp (x); }
|
|
KFloat Kotlin_math_expm1f(KFloat x) { return (KFloat)Kotlin_math_expm1 (x); }
|
|
|
|
KFloat Kotlin_math_lnf(KFloat x) { return (KFloat)Kotlin_math_ln (x); }
|
|
KFloat Kotlin_math_log10f(KFloat x) { return (KFloat)Kotlin_math_log10 (x); }
|
|
KFloat Kotlin_math_log2f(KFloat x) { return (KFloat)Kotlin_math_log2 (x); }
|
|
KFloat Kotlin_math_ln1pf(KFloat x) { return (KFloat)Kotlin_math_ln1p (x); }
|
|
|
|
KFloat Kotlin_math_ceilf(KFloat x) { return (KFloat)Kotlin_math_ceil (x); }
|
|
KFloat Kotlin_math_floorf(KFloat x) { return (KFloat)Kotlin_math_floor (x); }
|
|
KFloat Kotlin_math_roundf(KFloat x) { return (KFloat)Kotlin_math_round (x); }
|
|
|
|
KFloat Kotlin_math_absf(KFloat x) { return (KFloat)Kotlin_math_abs (x); }
|
|
|
|
KFloat Kotlin_math_atan2f(KFloat y, KFloat x) { return (KFloat)Kotlin_math_atan2(y, x); }
|
|
KFloat Kotlin_math_hypotf(KFloat x, KFloat y) { return (KFloat)Kotlin_math_hypot(x, y); }
|
|
|
|
// extensions
|
|
|
|
KFloat Kotlin_math_Float_pow(KFloat thiz, KFloat x) { return (KFloat)Kotlin_math_Double_pow(thiz, x); }
|
|
|
|
KFloat Kotlin_math_Float_IEEErem(KFloat thiz, KFloat divisor) {
|
|
return (KFloat)Kotlin_math_Double_IEEErem(thiz, divisor);
|
|
}
|
|
|
|
KFloat Kotlin_math_Float_withSign(KFloat thiz, KFloat sign) {
|
|
return (KFloat)Kotlin_math_Double_withSign(thiz, sign);
|
|
}
|
|
|
|
KFloat Kotlin_math_Float_nextUp(KFloat thiz) {
|
|
if (isnan(thiz) || thiz == HUGE_VALF) {
|
|
return thiz;
|
|
}
|
|
if (thiz == 0.0) {
|
|
return FLT_TRUE_MIN;
|
|
}
|
|
return bitsToFloat(floatToBits(thiz) + (thiz > 0 ? 1 : -1));
|
|
}
|
|
|
|
KFloat Kotlin_math_Float_nextDown(KFloat thiz) {
|
|
if (isnan(thiz) || thiz == -HUGE_VALF) {
|
|
return thiz;
|
|
}
|
|
if (thiz == 0.0) {
|
|
return -FLT_TRUE_MIN;
|
|
}
|
|
return bitsToFloat(floatToBits(thiz) - (thiz > 0 ? 1 : -1));
|
|
}
|
|
|
|
KFloat Kotlin_math_Float_nextTowards(KFloat thiz, KFloat to) {
|
|
if (isnan(thiz) || isnan(to)) {
|
|
return NAN;
|
|
}
|
|
if (to > thiz) {
|
|
return Kotlin_math_Float_nextUp(thiz);
|
|
}
|
|
if (to < thiz) {
|
|
return Kotlin_math_Float_nextDown(thiz);
|
|
}
|
|
// thiz == to
|
|
return to;
|
|
}
|
|
|
|
KBoolean Kotlin_math_Float_signBit(KFloat thiz) { return Kotlin_math_Double_signBit(thiz); }
|
|
|
|
// endregion
|
|
|
|
// region Integer math
|
|
|
|
KInt Kotlin_math_absi(KInt x) { return (x >= 0) ? x : -x; }
|
|
KLong Kotlin_math_absl(KLong x) { return (x >= 0) ? x : -x; }
|
|
|
|
#endif // #ifndef KONAN_WASM
|
|
|
|
#else // KONAN_NO_MATH defined - we have no patform math library. Throw NotImplementedError from math functions.
|
|
|
|
namespace {
|
|
|
|
RUNTIME_NORETURN void NotImplemented() {
|
|
ThrowNotImplementedError();
|
|
}
|
|
|
|
} // namespace
|
|
|
|
KDouble Kotlin_math_sin(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_cos(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_tan(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_asin(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_acos(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_atan(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_atan2(KDouble y, KDouble x) { NotImplemented(); }
|
|
|
|
KDouble Kotlin_math_sinh(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_cosh(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_tanh(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_asinh(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_acosh(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_atanh(KDouble x) { NotImplemented(); }
|
|
|
|
KDouble Kotlin_math_hypot(KDouble x, KDouble y) { NotImplemented(); }
|
|
KDouble Kotlin_math_sqrt(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_exp(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_expm1(KDouble x) { NotImplemented(); }
|
|
|
|
KDouble Kotlin_math_ln(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_log10(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_log2(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_ln1p(KDouble x) { NotImplemented(); }
|
|
|
|
KDouble Kotlin_math_ceil(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_floor(KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_round(KDouble x) { NotImplemented(); }
|
|
|
|
KDouble Kotlin_math_abs(KDouble x) { NotImplemented(); }
|
|
|
|
// extensions
|
|
|
|
KDouble Kotlin_math_Double_pow(KDouble thiz, KDouble x) { NotImplemented(); }
|
|
KDouble Kotlin_math_Double_IEEErem(KDouble thiz, KDouble divisor) { NotImplemented(); }
|
|
KDouble Kotlin_math_Double_withSign(KDouble thiz, KDouble sign) { NotImplemented(); }
|
|
|
|
KDouble Kotlin_math_Double_nextUp(KDouble thiz) { NotImplemented(); }
|
|
KDouble Kotlin_math_Double_nextDown(KDouble thiz) { NotImplemented(); }
|
|
KDouble Kotlin_math_Double_nextTowards(KDouble thiz, KDouble to) { NotImplemented(); }
|
|
|
|
KBoolean Kotlin_math_Double_signBit(KDouble thiz) { NotImplemented(); }
|
|
|
|
// endregion
|
|
|
|
// region Float math.
|
|
|
|
KFloat Kotlin_math_sinf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_cosf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_tanf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_asinf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_acosf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_atanf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_atan2f(KFloat y, KFloat x) { NotImplemented(); }
|
|
|
|
KFloat Kotlin_math_sinhf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_coshf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_tanhf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_asinhf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_acoshf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_atanhf(KFloat x) { NotImplemented(); }
|
|
|
|
KFloat Kotlin_math_hypotf(KFloat x, KFloat y) { NotImplemented(); }
|
|
KFloat Kotlin_math_sqrtf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_expf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_expm1f(KFloat x) { NotImplemented(); }
|
|
|
|
KFloat Kotlin_math_lnf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_log10f(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_log2f(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_ln1pf(KFloat x) { NotImplemented(); }
|
|
|
|
KFloat Kotlin_math_ceilf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_floorf(KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_roundf(KFloat x) { NotImplemented(); }
|
|
|
|
KFloat Kotlin_math_absf(KFloat x) { NotImplemented(); }
|
|
|
|
// extensions
|
|
|
|
KFloat Kotlin_math_Float_pow(KFloat thiz, KFloat x) { NotImplemented(); }
|
|
KFloat Kotlin_math_Float_IEEErem(KFloat thiz, KFloat divisor) { NotImplemented(); }
|
|
KFloat Kotlin_math_Float_withSign(KFloat thiz, KFloat sign) { NotImplemented(); }
|
|
|
|
KFloat Kotlin_math_Float_nextUp(KFloat thiz) { NotImplemented(); }
|
|
KFloat Kotlin_math_Float_nextDown(KFloat thiz) { NotImplemented(); }
|
|
KFloat Kotlin_math_Float_nextTowards(KFloat thiz, KFloat to) { NotImplemented(); }
|
|
|
|
KBoolean Kotlin_math_Float_signBit(KFloat thiz) { NotImplemented(); }
|
|
|
|
// endregion
|
|
|
|
// region Integer math
|
|
|
|
KInt Kotlin_math_absi(KInt x) { NotImplemented(); }
|
|
KInt Kotlin_math_mini(KInt a, KInt b) { NotImplemented(); }
|
|
KInt Kotlin_math_maxi(KInt a, KInt b) { NotImplemented(); }
|
|
|
|
KLong Kotlin_math_absl(KLong x) { NotImplemented(); }
|
|
KLong Kotlin_math_minl(KLong a, KLong b) { NotImplemented(); }
|
|
KLong Kotlin_math_maxl(KLong a, KLong b) { NotImplemented(); }
|
|
|
|
#endif // #ifndef KONAN_NO_MATH
|
|
|
|
} // extern "C"
|