From 21b15a095d986f2d573ccdd3deb3594ec73a0efe Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Tue, 28 Feb 2023 11:22:20 +0100 Subject: [PATCH 01/30] Bind ieee754 compliant bid128_ functions --- ffigen/bid_conf.h | 1 + ffigen/bid_functions.h | 1 + ffigen/config.yaml | 4 + lib/src/native/realm_bindings.dart | 10029 +++++++++++++++++++++++++++ 4 files changed, 10035 insertions(+) create mode 120000 ffigen/bid_conf.h create mode 120000 ffigen/bid_functions.h diff --git a/ffigen/bid_conf.h b/ffigen/bid_conf.h new file mode 120000 index 000000000..b51b75a7c --- /dev/null +++ b/ffigen/bid_conf.h @@ -0,0 +1 @@ +../src/realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_conf.h \ No newline at end of file diff --git a/ffigen/bid_functions.h b/ffigen/bid_functions.h new file mode 120000 index 000000000..f61333500 --- /dev/null +++ b/ffigen/bid_functions.h @@ -0,0 +1 @@ +../src/realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_functions.h \ No newline at end of file diff --git a/ffigen/config.yaml b/ffigen/config.yaml index 591384b1b..3505a7577 100644 --- a/ffigen/config.yaml +++ b/ffigen/config.yaml @@ -8,11 +8,15 @@ headers: - 'realm_dart.h' - 'realm_dart_scheduler.h' - 'realm_dart_sync.h' + - 'bid_conf.h' + - 'bid_functions.h' include-directives: #generate only for these headers - 'realm.h' - 'realm_dart.h' - 'realm_dart_scheduler.h' - 'realm_dart_sync.h' + - 'bid_conf.h' + - 'bid_functions.h' compiler-opts: - '-DRLM_NO_ANON_UNIONS' - '-DFFI_GEN' diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index e9f2f458b..3f3adcffe 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -19,6 +19,9881 @@ class RealmLibrary { lookup) : _lookup = lookup; + BID_UINT128 bid128_abs( + BID_UINT128 x, + ) { + return _bid128_abs( + x, + ); + } + + late final _bid128_absPtr = + _lookup>( + 'bid128_abs'); + late final _bid128_abs = + _bid128_absPtr.asFunction(); + + BID_UINT128 bid128_acos( + BID_UINT128 x, + ) { + return _bid128_acos( + x, + ); + } + + late final _bid128_acosPtr = + _lookup>( + 'bid128_acos'); + late final _bid128_acos = + _bid128_acosPtr.asFunction(); + + BID_UINT128 bid128_acosh( + BID_UINT128 x, + ) { + return _bid128_acosh( + x, + ); + } + + late final _bid128_acoshPtr = + _lookup>( + 'bid128_acosh'); + late final _bid128_acosh = + _bid128_acoshPtr.asFunction(); + + BID_UINT128 bid128_add( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_add( + x, + y, + ); + } + + late final _bid128_addPtr = _lookup< + ffi.NativeFunction>( + 'bid128_add'); + late final _bid128_add = _bid128_addPtr + .asFunction(); + + BID_UINT128 bid128_asin( + BID_UINT128 x, + ) { + return _bid128_asin( + x, + ); + } + + late final _bid128_asinPtr = + _lookup>( + 'bid128_asin'); + late final _bid128_asin = + _bid128_asinPtr.asFunction(); + + BID_UINT128 bid128_asinh( + BID_UINT128 x, + ) { + return _bid128_asinh( + x, + ); + } + + late final _bid128_asinhPtr = + _lookup>( + 'bid128_asinh'); + late final _bid128_asinh = + _bid128_asinhPtr.asFunction(); + + BID_UINT128 bid128_atan( + BID_UINT128 x, + ) { + return _bid128_atan( + x, + ); + } + + late final _bid128_atanPtr = + _lookup>( + 'bid128_atan'); + late final _bid128_atan = + _bid128_atanPtr.asFunction(); + + BID_UINT128 bid128_atan2( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_atan2( + x, + y, + ); + } + + late final _bid128_atan2Ptr = _lookup< + ffi.NativeFunction>( + 'bid128_atan2'); + late final _bid128_atan2 = _bid128_atan2Ptr + .asFunction(); + + BID_UINT128 bid128_atanh( + BID_UINT128 x, + ) { + return _bid128_atanh( + x, + ); + } + + late final _bid128_atanhPtr = + _lookup>( + 'bid128_atanh'); + late final _bid128_atanh = + _bid128_atanhPtr.asFunction(); + + BID_UINT128 bid128_cbrt( + BID_UINT128 x, + ) { + return _bid128_cbrt( + x, + ); + } + + late final _bid128_cbrtPtr = + _lookup>( + 'bid128_cbrt'); + late final _bid128_cbrt = + _bid128_cbrtPtr.asFunction(); + + int bid128_class( + BID_UINT128 x, + ) { + return _bid128_class( + x, + ); + } + + late final _bid128_classPtr = + _lookup>( + 'bid128_class'); + late final _bid128_class = + _bid128_classPtr.asFunction(); + + BID_UINT128 bid128_copy( + BID_UINT128 x, + ) { + return _bid128_copy( + x, + ); + } + + late final _bid128_copyPtr = + _lookup>( + 'bid128_copy'); + late final _bid128_copy = + _bid128_copyPtr.asFunction(); + + BID_UINT128 bid128_copySign( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_copySign( + x, + y, + ); + } + + late final _bid128_copySignPtr = _lookup< + ffi.NativeFunction>( + 'bid128_copySign'); + late final _bid128_copySign = _bid128_copySignPtr + .asFunction(); + + BID_UINT128 bid128_cos( + BID_UINT128 x, + ) { + return _bid128_cos( + x, + ); + } + + late final _bid128_cosPtr = + _lookup>( + 'bid128_cos'); + late final _bid128_cos = + _bid128_cosPtr.asFunction(); + + BID_UINT128 bid128_cosh( + BID_UINT128 x, + ) { + return _bid128_cosh( + x, + ); + } + + late final _bid128_coshPtr = + _lookup>( + 'bid128_cosh'); + late final _bid128_cosh = + _bid128_coshPtr.asFunction(); + + BID_UINT128 bid128_div( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_div( + x, + y, + ); + } + + late final _bid128_divPtr = _lookup< + ffi.NativeFunction>( + 'bid128_div'); + late final _bid128_div = _bid128_divPtr + .asFunction(); + + BID_UINT128 bid128_erf( + BID_UINT128 x, + ) { + return _bid128_erf( + x, + ); + } + + late final _bid128_erfPtr = + _lookup>( + 'bid128_erf'); + late final _bid128_erf = + _bid128_erfPtr.asFunction(); + + BID_UINT128 bid128_erfc( + BID_UINT128 x, + ) { + return _bid128_erfc( + x, + ); + } + + late final _bid128_erfcPtr = + _lookup>( + 'bid128_erfc'); + late final _bid128_erfc = + _bid128_erfcPtr.asFunction(); + + BID_UINT128 bid128_exp( + BID_UINT128 x, + ) { + return _bid128_exp( + x, + ); + } + + late final _bid128_expPtr = + _lookup>( + 'bid128_exp'); + late final _bid128_exp = + _bid128_expPtr.asFunction(); + + BID_UINT128 bid128_exp10( + BID_UINT128 x, + ) { + return _bid128_exp10( + x, + ); + } + + late final _bid128_exp10Ptr = + _lookup>( + 'bid128_exp10'); + late final _bid128_exp10 = + _bid128_exp10Ptr.asFunction(); + + BID_UINT128 bid128_exp2( + BID_UINT128 x, + ) { + return _bid128_exp2( + x, + ); + } + + late final _bid128_exp2Ptr = + _lookup>( + 'bid128_exp2'); + late final _bid128_exp2 = + _bid128_exp2Ptr.asFunction(); + + BID_UINT128 bid128_expm1( + BID_UINT128 x, + ) { + return _bid128_expm1( + x, + ); + } + + late final _bid128_expm1Ptr = + _lookup>( + 'bid128_expm1'); + late final _bid128_expm1 = + _bid128_expm1Ptr.asFunction(); + + BID_UINT128 bid128_fdim( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_fdim( + x, + y, + ); + } + + late final _bid128_fdimPtr = _lookup< + ffi.NativeFunction>( + 'bid128_fdim'); + late final _bid128_fdim = _bid128_fdimPtr + .asFunction(); + + BID_UINT128 bid128_fma( + BID_UINT128 x, + BID_UINT128 y, + BID_UINT128 z, + ) { + return _bid128_fma( + x, + y, + z, + ); + } + + late final _bid128_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT128, BID_UINT128, BID_UINT128)>>('bid128_fma'); + late final _bid128_fma = _bid128_fmaPtr.asFunction< + BID_UINT128 Function(BID_UINT128, BID_UINT128, BID_UINT128)>(); + + BID_UINT128 bid128_fmod( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_fmod( + x, + y, + ); + } + + late final _bid128_fmodPtr = _lookup< + ffi.NativeFunction>( + 'bid128_fmod'); + late final _bid128_fmod = _bid128_fmodPtr + .asFunction(); + + BID_UINT128 bid128_frexp( + BID_UINT128 x, + ffi.Pointer exp, + ) { + return _bid128_frexp( + x, + exp, + ); + } + + late final _bid128_frexpPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT128, ffi.Pointer)>>('bid128_frexp'); + late final _bid128_frexp = _bid128_frexpPtr + .asFunction)>(); + + BID_UINT128 bid128_from_int32( + int x, + ) { + return _bid128_from_int32( + x, + ); + } + + late final _bid128_from_int32Ptr = + _lookup>( + 'bid128_from_int32'); + late final _bid128_from_int32 = + _bid128_from_int32Ptr.asFunction(); + + BID_UINT128 bid128_from_int64( + int x, + ) { + return _bid128_from_int64( + x, + ); + } + + late final _bid128_from_int64Ptr = + _lookup>( + 'bid128_from_int64'); + late final _bid128_from_int64 = + _bid128_from_int64Ptr.asFunction(); + + BID_UINT128 bid128_from_string( + ffi.Pointer ps, + ) { + return _bid128_from_string( + ps, + ); + } + + late final _bid128_from_stringPtr = + _lookup)>>( + 'bid128_from_string'); + late final _bid128_from_string = _bid128_from_stringPtr + .asFunction)>(); + + BID_UINT128 bid128_from_uint32( + int x, + ) { + return _bid128_from_uint32( + x, + ); + } + + late final _bid128_from_uint32Ptr = + _lookup>( + 'bid128_from_uint32'); + late final _bid128_from_uint32 = + _bid128_from_uint32Ptr.asFunction(); + + BID_UINT128 bid128_from_uint64( + int x, + ) { + return _bid128_from_uint64( + x, + ); + } + + late final _bid128_from_uint64Ptr = + _lookup>( + 'bid128_from_uint64'); + late final _bid128_from_uint64 = + _bid128_from_uint64Ptr.asFunction(); + + BID_UINT128 bid128_hypot( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_hypot( + x, + y, + ); + } + + late final _bid128_hypotPtr = _lookup< + ffi.NativeFunction>( + 'bid128_hypot'); + late final _bid128_hypot = _bid128_hypotPtr + .asFunction(); + + int bid128_ilogb( + BID_UINT128 x, + ) { + return _bid128_ilogb( + x, + ); + } + + late final _bid128_ilogbPtr = + _lookup>( + 'bid128_ilogb'); + late final _bid128_ilogb = + _bid128_ilogbPtr.asFunction(); + + BID_UINT128 bid128_inf() { + return _bid128_inf(); + } + + late final _bid128_infPtr = + _lookup>('bid128_inf'); + late final _bid128_inf = _bid128_infPtr.asFunction(); + + int bid128_isCanonical( + BID_UINT128 x, + ) { + return _bid128_isCanonical( + x, + ); + } + + late final _bid128_isCanonicalPtr = + _lookup>( + 'bid128_isCanonical'); + late final _bid128_isCanonical = + _bid128_isCanonicalPtr.asFunction(); + + int bid128_isFinite( + BID_UINT128 x, + ) { + return _bid128_isFinite( + x, + ); + } + + late final _bid128_isFinitePtr = + _lookup>( + 'bid128_isFinite'); + late final _bid128_isFinite = + _bid128_isFinitePtr.asFunction(); + + int bid128_isInf( + BID_UINT128 x, + ) { + return _bid128_isInf( + x, + ); + } + + late final _bid128_isInfPtr = + _lookup>( + 'bid128_isInf'); + late final _bid128_isInf = + _bid128_isInfPtr.asFunction(); + + int bid128_isNaN( + BID_UINT128 x, + ) { + return _bid128_isNaN( + x, + ); + } + + late final _bid128_isNaNPtr = + _lookup>( + 'bid128_isNaN'); + late final _bid128_isNaN = + _bid128_isNaNPtr.asFunction(); + + int bid128_isNormal( + BID_UINT128 x, + ) { + return _bid128_isNormal( + x, + ); + } + + late final _bid128_isNormalPtr = + _lookup>( + 'bid128_isNormal'); + late final _bid128_isNormal = + _bid128_isNormalPtr.asFunction(); + + int bid128_isSignaling( + BID_UINT128 x, + ) { + return _bid128_isSignaling( + x, + ); + } + + late final _bid128_isSignalingPtr = + _lookup>( + 'bid128_isSignaling'); + late final _bid128_isSignaling = + _bid128_isSignalingPtr.asFunction(); + + int bid128_isSigned( + BID_UINT128 x, + ) { + return _bid128_isSigned( + x, + ); + } + + late final _bid128_isSignedPtr = + _lookup>( + 'bid128_isSigned'); + late final _bid128_isSigned = + _bid128_isSignedPtr.asFunction(); + + int bid128_isSubnormal( + BID_UINT128 x, + ) { + return _bid128_isSubnormal( + x, + ); + } + + late final _bid128_isSubnormalPtr = + _lookup>( + 'bid128_isSubnormal'); + late final _bid128_isSubnormal = + _bid128_isSubnormalPtr.asFunction(); + + int bid128_isZero( + BID_UINT128 x, + ) { + return _bid128_isZero( + x, + ); + } + + late final _bid128_isZeroPtr = + _lookup>( + 'bid128_isZero'); + late final _bid128_isZero = + _bid128_isZeroPtr.asFunction(); + + BID_UINT128 bid128_ldexp( + BID_UINT128 x, + int n, + ) { + return _bid128_ldexp( + x, + n, + ); + } + + late final _bid128_ldexpPtr = + _lookup>( + 'bid128_ldexp'); + late final _bid128_ldexp = + _bid128_ldexpPtr.asFunction(); + + BID_UINT128 bid128_lgamma( + BID_UINT128 x, + ) { + return _bid128_lgamma( + x, + ); + } + + late final _bid128_lgammaPtr = + _lookup>( + 'bid128_lgamma'); + late final _bid128_lgamma = + _bid128_lgammaPtr.asFunction(); + + int bid128_llquantexp( + BID_UINT128 x, + ) { + return _bid128_llquantexp( + x, + ); + } + + late final _bid128_llquantexpPtr = + _lookup>( + 'bid128_llquantexp'); + late final _bid128_llquantexp = + _bid128_llquantexpPtr.asFunction(); + + int bid128_llrint( + BID_UINT128 x, + ) { + return _bid128_llrint( + x, + ); + } + + late final _bid128_llrintPtr = + _lookup>( + 'bid128_llrint'); + late final _bid128_llrint = + _bid128_llrintPtr.asFunction(); + + int bid128_llround( + BID_UINT128 x, + ) { + return _bid128_llround( + x, + ); + } + + late final _bid128_llroundPtr = + _lookup>( + 'bid128_llround'); + late final _bid128_llround = + _bid128_llroundPtr.asFunction(); + + BID_UINT128 bid128_log( + BID_UINT128 x, + ) { + return _bid128_log( + x, + ); + } + + late final _bid128_logPtr = + _lookup>( + 'bid128_log'); + late final _bid128_log = + _bid128_logPtr.asFunction(); + + BID_UINT128 bid128_log10( + BID_UINT128 x, + ) { + return _bid128_log10( + x, + ); + } + + late final _bid128_log10Ptr = + _lookup>( + 'bid128_log10'); + late final _bid128_log10 = + _bid128_log10Ptr.asFunction(); + + BID_UINT128 bid128_log1p( + BID_UINT128 x, + ) { + return _bid128_log1p( + x, + ); + } + + late final _bid128_log1pPtr = + _lookup>( + 'bid128_log1p'); + late final _bid128_log1p = + _bid128_log1pPtr.asFunction(); + + BID_UINT128 bid128_log2( + BID_UINT128 x, + ) { + return _bid128_log2( + x, + ); + } + + late final _bid128_log2Ptr = + _lookup>( + 'bid128_log2'); + late final _bid128_log2 = + _bid128_log2Ptr.asFunction(); + + BID_UINT128 bid128_logb( + BID_UINT128 x, + ) { + return _bid128_logb( + x, + ); + } + + late final _bid128_logbPtr = + _lookup>( + 'bid128_logb'); + late final _bid128_logb = + _bid128_logbPtr.asFunction(); + + int bid128_lrint( + BID_UINT128 x, + ) { + return _bid128_lrint( + x, + ); + } + + late final _bid128_lrintPtr = + _lookup>( + 'bid128_lrint'); + late final _bid128_lrint = + _bid128_lrintPtr.asFunction(); + + int bid128_lround( + BID_UINT128 x, + ) { + return _bid128_lround( + x, + ); + } + + late final _bid128_lroundPtr = + _lookup>( + 'bid128_lround'); + late final _bid128_lround = + _bid128_lroundPtr.asFunction(); + + BID_UINT128 bid128_maxnum( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_maxnum( + x, + y, + ); + } + + late final _bid128_maxnumPtr = _lookup< + ffi.NativeFunction>( + 'bid128_maxnum'); + late final _bid128_maxnum = _bid128_maxnumPtr + .asFunction(); + + BID_UINT128 bid128_maxnum_mag( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_maxnum_mag( + x, + y, + ); + } + + late final _bid128_maxnum_magPtr = _lookup< + ffi.NativeFunction>( + 'bid128_maxnum_mag'); + late final _bid128_maxnum_mag = _bid128_maxnum_magPtr + .asFunction(); + + BID_UINT128 bid128_minnum( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_minnum( + x, + y, + ); + } + + late final _bid128_minnumPtr = _lookup< + ffi.NativeFunction>( + 'bid128_minnum'); + late final _bid128_minnum = _bid128_minnumPtr + .asFunction(); + + BID_UINT128 bid128_minnum_mag( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_minnum_mag( + x, + y, + ); + } + + late final _bid128_minnum_magPtr = _lookup< + ffi.NativeFunction>( + 'bid128_minnum_mag'); + late final _bid128_minnum_mag = _bid128_minnum_magPtr + .asFunction(); + + BID_UINT128 bid128_modf( + BID_UINT128 x, + ffi.Pointer y, + ) { + return _bid128_modf( + x, + y, + ); + } + + late final _bid128_modfPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT128, ffi.Pointer)>>('bid128_modf'); + late final _bid128_modf = _bid128_modfPtr.asFunction< + BID_UINT128 Function(BID_UINT128, ffi.Pointer)>(); + + BID_UINT128 bid128_mul( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_mul( + x, + y, + ); + } + + late final _bid128_mulPtr = _lookup< + ffi.NativeFunction>( + 'bid128_mul'); + late final _bid128_mul = _bid128_mulPtr + .asFunction(); + + BID_UINT128 bid128_nan( + ffi.Pointer tagp, + ) { + return _bid128_nan( + tagp, + ); + } + + late final _bid128_nanPtr = + _lookup)>>( + 'bid128_nan'); + late final _bid128_nan = + _bid128_nanPtr.asFunction)>(); + + BID_UINT128 bid128_nearbyint( + BID_UINT128 x, + ) { + return _bid128_nearbyint( + x, + ); + } + + late final _bid128_nearbyintPtr = + _lookup>( + 'bid128_nearbyint'); + late final _bid128_nearbyint = + _bid128_nearbyintPtr.asFunction(); + + BID_UINT128 bid128_negate( + BID_UINT128 x, + ) { + return _bid128_negate( + x, + ); + } + + late final _bid128_negatePtr = + _lookup>( + 'bid128_negate'); + late final _bid128_negate = + _bid128_negatePtr.asFunction(); + + BID_UINT128 bid128_nextafter( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_nextafter( + x, + y, + ); + } + + late final _bid128_nextafterPtr = _lookup< + ffi.NativeFunction>( + 'bid128_nextafter'); + late final _bid128_nextafter = _bid128_nextafterPtr + .asFunction(); + + BID_UINT128 bid128_nextdown( + BID_UINT128 x, + ) { + return _bid128_nextdown( + x, + ); + } + + late final _bid128_nextdownPtr = + _lookup>( + 'bid128_nextdown'); + late final _bid128_nextdown = + _bid128_nextdownPtr.asFunction(); + + BID_UINT128 bid128_nexttoward( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_nexttoward( + x, + y, + ); + } + + late final _bid128_nexttowardPtr = _lookup< + ffi.NativeFunction>( + 'bid128_nexttoward'); + late final _bid128_nexttoward = _bid128_nexttowardPtr + .asFunction(); + + BID_UINT128 bid128_nextup( + BID_UINT128 x, + ) { + return _bid128_nextup( + x, + ); + } + + late final _bid128_nextupPtr = + _lookup>( + 'bid128_nextup'); + late final _bid128_nextup = + _bid128_nextupPtr.asFunction(); + + BID_UINT128 bid128_pow( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_pow( + x, + y, + ); + } + + late final _bid128_powPtr = _lookup< + ffi.NativeFunction>( + 'bid128_pow'); + late final _bid128_pow = _bid128_powPtr + .asFunction(); + + int bid128_quantexp( + BID_UINT128 x, + ) { + return _bid128_quantexp( + x, + ); + } + + late final _bid128_quantexpPtr = + _lookup>( + 'bid128_quantexp'); + late final _bid128_quantexp = + _bid128_quantexpPtr.asFunction(); + + BID_UINT128 bid128_quantize( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quantize( + x, + y, + ); + } + + late final _bid128_quantizePtr = _lookup< + ffi.NativeFunction>( + 'bid128_quantize'); + late final _bid128_quantize = _bid128_quantizePtr + .asFunction(); + + BID_UINT128 bid128_quantum( + BID_UINT128 x, + ) { + return _bid128_quantum( + x, + ); + } + + late final _bid128_quantumPtr = + _lookup>( + 'bid128_quantum'); + late final _bid128_quantum = + _bid128_quantumPtr.asFunction(); + + int bid128_quiet_equal( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_equal( + x, + y, + ); + } + + late final _bid128_quiet_equalPtr = + _lookup>( + 'bid128_quiet_equal'); + late final _bid128_quiet_equal = _bid128_quiet_equalPtr + .asFunction(); + + int bid128_quiet_greater( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_greater( + x, + y, + ); + } + + late final _bid128_quiet_greaterPtr = + _lookup>( + 'bid128_quiet_greater'); + late final _bid128_quiet_greater = _bid128_quiet_greaterPtr + .asFunction(); + + int bid128_quiet_greater_equal( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_greater_equal( + x, + y, + ); + } + + late final _bid128_quiet_greater_equalPtr = + _lookup>( + 'bid128_quiet_greater_equal'); + late final _bid128_quiet_greater_equal = _bid128_quiet_greater_equalPtr + .asFunction(); + + int bid128_quiet_greater_unordered( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_greater_unordered( + x, + y, + ); + } + + late final _bid128_quiet_greater_unorderedPtr = + _lookup>( + 'bid128_quiet_greater_unordered'); + late final _bid128_quiet_greater_unordered = + _bid128_quiet_greater_unorderedPtr + .asFunction(); + + int bid128_quiet_less( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_less( + x, + y, + ); + } + + late final _bid128_quiet_lessPtr = + _lookup>( + 'bid128_quiet_less'); + late final _bid128_quiet_less = _bid128_quiet_lessPtr + .asFunction(); + + int bid128_quiet_less_equal( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_less_equal( + x, + y, + ); + } + + late final _bid128_quiet_less_equalPtr = + _lookup>( + 'bid128_quiet_less_equal'); + late final _bid128_quiet_less_equal = _bid128_quiet_less_equalPtr + .asFunction(); + + int bid128_quiet_less_unordered( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_less_unordered( + x, + y, + ); + } + + late final _bid128_quiet_less_unorderedPtr = + _lookup>( + 'bid128_quiet_less_unordered'); + late final _bid128_quiet_less_unordered = _bid128_quiet_less_unorderedPtr + .asFunction(); + + int bid128_quiet_not_equal( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_not_equal( + x, + y, + ); + } + + late final _bid128_quiet_not_equalPtr = + _lookup>( + 'bid128_quiet_not_equal'); + late final _bid128_quiet_not_equal = _bid128_quiet_not_equalPtr + .asFunction(); + + int bid128_quiet_not_greater( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_not_greater( + x, + y, + ); + } + + late final _bid128_quiet_not_greaterPtr = + _lookup>( + 'bid128_quiet_not_greater'); + late final _bid128_quiet_not_greater = _bid128_quiet_not_greaterPtr + .asFunction(); + + int bid128_quiet_not_less( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_not_less( + x, + y, + ); + } + + late final _bid128_quiet_not_lessPtr = + _lookup>( + 'bid128_quiet_not_less'); + late final _bid128_quiet_not_less = _bid128_quiet_not_lessPtr + .asFunction(); + + int bid128_quiet_ordered( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_ordered( + x, + y, + ); + } + + late final _bid128_quiet_orderedPtr = + _lookup>( + 'bid128_quiet_ordered'); + late final _bid128_quiet_ordered = _bid128_quiet_orderedPtr + .asFunction(); + + int bid128_quiet_unordered( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_quiet_unordered( + x, + y, + ); + } + + late final _bid128_quiet_unorderedPtr = + _lookup>( + 'bid128_quiet_unordered'); + late final _bid128_quiet_unordered = _bid128_quiet_unorderedPtr + .asFunction(); + + int bid128_radix( + BID_UINT128 x, + ) { + return _bid128_radix( + x, + ); + } + + late final _bid128_radixPtr = + _lookup>( + 'bid128_radix'); + late final _bid128_radix = + _bid128_radixPtr.asFunction(); + + BID_UINT128 bid128_rem( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_rem( + x, + y, + ); + } + + late final _bid128_remPtr = _lookup< + ffi.NativeFunction>( + 'bid128_rem'); + late final _bid128_rem = _bid128_remPtr + .asFunction(); + + BID_UINT128 bid128_round_integral_exact( + BID_UINT128 x, + ) { + return _bid128_round_integral_exact( + x, + ); + } + + late final _bid128_round_integral_exactPtr = + _lookup>( + 'bid128_round_integral_exact'); + late final _bid128_round_integral_exact = _bid128_round_integral_exactPtr + .asFunction(); + + BID_UINT128 bid128_round_integral_nearest_away( + BID_UINT128 x, + ) { + return _bid128_round_integral_nearest_away( + x, + ); + } + + late final _bid128_round_integral_nearest_awayPtr = + _lookup>( + 'bid128_round_integral_nearest_away'); + late final _bid128_round_integral_nearest_away = + _bid128_round_integral_nearest_awayPtr + .asFunction(); + + BID_UINT128 bid128_round_integral_nearest_even( + BID_UINT128 x, + ) { + return _bid128_round_integral_nearest_even( + x, + ); + } + + late final _bid128_round_integral_nearest_evenPtr = + _lookup>( + 'bid128_round_integral_nearest_even'); + late final _bid128_round_integral_nearest_even = + _bid128_round_integral_nearest_evenPtr + .asFunction(); + + BID_UINT128 bid128_round_integral_negative( + BID_UINT128 x, + ) { + return _bid128_round_integral_negative( + x, + ); + } + + late final _bid128_round_integral_negativePtr = + _lookup>( + 'bid128_round_integral_negative'); + late final _bid128_round_integral_negative = + _bid128_round_integral_negativePtr + .asFunction(); + + BID_UINT128 bid128_round_integral_positive( + BID_UINT128 x, + ) { + return _bid128_round_integral_positive( + x, + ); + } + + late final _bid128_round_integral_positivePtr = + _lookup>( + 'bid128_round_integral_positive'); + late final _bid128_round_integral_positive = + _bid128_round_integral_positivePtr + .asFunction(); + + BID_UINT128 bid128_round_integral_zero( + BID_UINT128 x, + ) { + return _bid128_round_integral_zero( + x, + ); + } + + late final _bid128_round_integral_zeroPtr = + _lookup>( + 'bid128_round_integral_zero'); + late final _bid128_round_integral_zero = _bid128_round_integral_zeroPtr + .asFunction(); + + int bid128_sameQuantum( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_sameQuantum( + x, + y, + ); + } + + late final _bid128_sameQuantumPtr = + _lookup>( + 'bid128_sameQuantum'); + late final _bid128_sameQuantum = _bid128_sameQuantumPtr + .asFunction(); + + BID_UINT128 bid128_scalbln( + BID_UINT128 x, + int n, + ) { + return _bid128_scalbln( + x, + n, + ); + } + + late final _bid128_scalblnPtr = + _lookup>( + 'bid128_scalbln'); + late final _bid128_scalbln = + _bid128_scalblnPtr.asFunction(); + + BID_UINT128 bid128_scalbn( + BID_UINT128 x, + int n, + ) { + return _bid128_scalbn( + x, + n, + ); + } + + late final _bid128_scalbnPtr = + _lookup>( + 'bid128_scalbn'); + late final _bid128_scalbn = + _bid128_scalbnPtr.asFunction(); + + int bid128_signaling_greater( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_signaling_greater( + x, + y, + ); + } + + late final _bid128_signaling_greaterPtr = + _lookup>( + 'bid128_signaling_greater'); + late final _bid128_signaling_greater = _bid128_signaling_greaterPtr + .asFunction(); + + int bid128_signaling_greater_equal( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_signaling_greater_equal( + x, + y, + ); + } + + late final _bid128_signaling_greater_equalPtr = + _lookup>( + 'bid128_signaling_greater_equal'); + late final _bid128_signaling_greater_equal = + _bid128_signaling_greater_equalPtr + .asFunction(); + + int bid128_signaling_greater_unordered( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_signaling_greater_unordered( + x, + y, + ); + } + + late final _bid128_signaling_greater_unorderedPtr = + _lookup>( + 'bid128_signaling_greater_unordered'); + late final _bid128_signaling_greater_unordered = + _bid128_signaling_greater_unorderedPtr + .asFunction(); + + int bid128_signaling_less( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_signaling_less( + x, + y, + ); + } + + late final _bid128_signaling_lessPtr = + _lookup>( + 'bid128_signaling_less'); + late final _bid128_signaling_less = _bid128_signaling_lessPtr + .asFunction(); + + int bid128_signaling_less_equal( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_signaling_less_equal( + x, + y, + ); + } + + late final _bid128_signaling_less_equalPtr = + _lookup>( + 'bid128_signaling_less_equal'); + late final _bid128_signaling_less_equal = _bid128_signaling_less_equalPtr + .asFunction(); + + int bid128_signaling_less_unordered( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_signaling_less_unordered( + x, + y, + ); + } + + late final _bid128_signaling_less_unorderedPtr = + _lookup>( + 'bid128_signaling_less_unordered'); + late final _bid128_signaling_less_unordered = + _bid128_signaling_less_unorderedPtr + .asFunction(); + + int bid128_signaling_not_greater( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_signaling_not_greater( + x, + y, + ); + } + + late final _bid128_signaling_not_greaterPtr = + _lookup>( + 'bid128_signaling_not_greater'); + late final _bid128_signaling_not_greater = _bid128_signaling_not_greaterPtr + .asFunction(); + + int bid128_signaling_not_less( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_signaling_not_less( + x, + y, + ); + } + + late final _bid128_signaling_not_lessPtr = + _lookup>( + 'bid128_signaling_not_less'); + late final _bid128_signaling_not_less = _bid128_signaling_not_lessPtr + .asFunction(); + + BID_UINT128 bid128_sin( + BID_UINT128 x, + ) { + return _bid128_sin( + x, + ); + } + + late final _bid128_sinPtr = + _lookup>( + 'bid128_sin'); + late final _bid128_sin = + _bid128_sinPtr.asFunction(); + + BID_UINT128 bid128_sinh( + BID_UINT128 x, + ) { + return _bid128_sinh( + x, + ); + } + + late final _bid128_sinhPtr = + _lookup>( + 'bid128_sinh'); + late final _bid128_sinh = + _bid128_sinhPtr.asFunction(); + + BID_UINT128 bid128_sqrt( + BID_UINT128 x, + ) { + return _bid128_sqrt( + x, + ); + } + + late final _bid128_sqrtPtr = + _lookup>( + 'bid128_sqrt'); + late final _bid128_sqrt = + _bid128_sqrtPtr.asFunction(); + + BID_UINT128 bid128_sub( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_sub( + x, + y, + ); + } + + late final _bid128_subPtr = _lookup< + ffi.NativeFunction>( + 'bid128_sub'); + late final _bid128_sub = _bid128_subPtr + .asFunction(); + + BID_UINT128 bid128_tan( + BID_UINT128 x, + ) { + return _bid128_tan( + x, + ); + } + + late final _bid128_tanPtr = + _lookup>( + 'bid128_tan'); + late final _bid128_tan = + _bid128_tanPtr.asFunction(); + + BID_UINT128 bid128_tanh( + BID_UINT128 x, + ) { + return _bid128_tanh( + x, + ); + } + + late final _bid128_tanhPtr = + _lookup>( + 'bid128_tanh'); + late final _bid128_tanh = + _bid128_tanhPtr.asFunction(); + + BID_UINT128 bid128_tgamma( + BID_UINT128 x, + ) { + return _bid128_tgamma( + x, + ); + } + + late final _bid128_tgammaPtr = + _lookup>( + 'bid128_tgamma'); + late final _bid128_tgamma = + _bid128_tgammaPtr.asFunction(); + + int bid128_to_bid32( + BID_UINT128 x, + ) { + return _bid128_to_bid32( + x, + ); + } + + late final _bid128_to_bid32Ptr = + _lookup>( + 'bid128_to_bid32'); + late final _bid128_to_bid32 = + _bid128_to_bid32Ptr.asFunction(); + + int bid128_to_bid64( + BID_UINT128 x, + ) { + return _bid128_to_bid64( + x, + ); + } + + late final _bid128_to_bid64Ptr = + _lookup>( + 'bid128_to_bid64'); + late final _bid128_to_bid64 = + _bid128_to_bid64Ptr.asFunction(); + + BID_UINT128 bid128_to_binary128( + BID_UINT128 x, + ) { + return _bid128_to_binary128( + x, + ); + } + + late final _bid128_to_binary128Ptr = + _lookup>( + 'bid128_to_binary128'); + late final _bid128_to_binary128 = + _bid128_to_binary128Ptr.asFunction(); + + double bid128_to_binary32( + BID_UINT128 x, + ) { + return _bid128_to_binary32( + x, + ); + } + + late final _bid128_to_binary32Ptr = + _lookup>( + 'bid128_to_binary32'); + late final _bid128_to_binary32 = + _bid128_to_binary32Ptr.asFunction(); + + double bid128_to_binary64( + BID_UINT128 x, + ) { + return _bid128_to_binary64( + x, + ); + } + + late final _bid128_to_binary64Ptr = + _lookup>( + 'bid128_to_binary64'); + late final _bid128_to_binary64 = + _bid128_to_binary64Ptr.asFunction(); + + int bid128_to_int16_ceil( + BID_UINT128 x, + ) { + return _bid128_to_int16_ceil( + x, + ); + } + + late final _bid128_to_int16_ceilPtr = + _lookup>( + 'bid128_to_int16_ceil'); + late final _bid128_to_int16_ceil = + _bid128_to_int16_ceilPtr.asFunction(); + + int bid128_to_int16_floor( + BID_UINT128 x, + ) { + return _bid128_to_int16_floor( + x, + ); + } + + late final _bid128_to_int16_floorPtr = + _lookup>( + 'bid128_to_int16_floor'); + late final _bid128_to_int16_floor = + _bid128_to_int16_floorPtr.asFunction(); + + int bid128_to_int16_int( + BID_UINT128 x, + ) { + return _bid128_to_int16_int( + x, + ); + } + + late final _bid128_to_int16_intPtr = + _lookup>( + 'bid128_to_int16_int'); + late final _bid128_to_int16_int = + _bid128_to_int16_intPtr.asFunction(); + + int bid128_to_int16_rnint( + BID_UINT128 x, + ) { + return _bid128_to_int16_rnint( + x, + ); + } + + late final _bid128_to_int16_rnintPtr = + _lookup>( + 'bid128_to_int16_rnint'); + late final _bid128_to_int16_rnint = + _bid128_to_int16_rnintPtr.asFunction(); + + int bid128_to_int16_rninta( + BID_UINT128 x, + ) { + return _bid128_to_int16_rninta( + x, + ); + } + + late final _bid128_to_int16_rnintaPtr = + _lookup>( + 'bid128_to_int16_rninta'); + late final _bid128_to_int16_rninta = + _bid128_to_int16_rnintaPtr.asFunction(); + + int bid128_to_int16_xceil( + BID_UINT128 x, + ) { + return _bid128_to_int16_xceil( + x, + ); + } + + late final _bid128_to_int16_xceilPtr = + _lookup>( + 'bid128_to_int16_xceil'); + late final _bid128_to_int16_xceil = + _bid128_to_int16_xceilPtr.asFunction(); + + int bid128_to_int16_xfloor( + BID_UINT128 x, + ) { + return _bid128_to_int16_xfloor( + x, + ); + } + + late final _bid128_to_int16_xfloorPtr = + _lookup>( + 'bid128_to_int16_xfloor'); + late final _bid128_to_int16_xfloor = + _bid128_to_int16_xfloorPtr.asFunction(); + + int bid128_to_int16_xint( + BID_UINT128 x, + ) { + return _bid128_to_int16_xint( + x, + ); + } + + late final _bid128_to_int16_xintPtr = + _lookup>( + 'bid128_to_int16_xint'); + late final _bid128_to_int16_xint = + _bid128_to_int16_xintPtr.asFunction(); + + int bid128_to_int16_xrnint( + BID_UINT128 x, + ) { + return _bid128_to_int16_xrnint( + x, + ); + } + + late final _bid128_to_int16_xrnintPtr = + _lookup>( + 'bid128_to_int16_xrnint'); + late final _bid128_to_int16_xrnint = + _bid128_to_int16_xrnintPtr.asFunction(); + + int bid128_to_int16_xrninta( + BID_UINT128 x, + ) { + return _bid128_to_int16_xrninta( + x, + ); + } + + late final _bid128_to_int16_xrnintaPtr = + _lookup>( + 'bid128_to_int16_xrninta'); + late final _bid128_to_int16_xrninta = + _bid128_to_int16_xrnintaPtr.asFunction(); + + int bid128_to_int32_ceil( + BID_UINT128 x, + ) { + return _bid128_to_int32_ceil( + x, + ); + } + + late final _bid128_to_int32_ceilPtr = + _lookup>( + 'bid128_to_int32_ceil'); + late final _bid128_to_int32_ceil = + _bid128_to_int32_ceilPtr.asFunction(); + + int bid128_to_int32_floor( + BID_UINT128 x, + ) { + return _bid128_to_int32_floor( + x, + ); + } + + late final _bid128_to_int32_floorPtr = + _lookup>( + 'bid128_to_int32_floor'); + late final _bid128_to_int32_floor = + _bid128_to_int32_floorPtr.asFunction(); + + int bid128_to_int32_int( + BID_UINT128 x, + ) { + return _bid128_to_int32_int( + x, + ); + } + + late final _bid128_to_int32_intPtr = + _lookup>( + 'bid128_to_int32_int'); + late final _bid128_to_int32_int = + _bid128_to_int32_intPtr.asFunction(); + + int bid128_to_int32_rnint( + BID_UINT128 x, + ) { + return _bid128_to_int32_rnint( + x, + ); + } + + late final _bid128_to_int32_rnintPtr = + _lookup>( + 'bid128_to_int32_rnint'); + late final _bid128_to_int32_rnint = + _bid128_to_int32_rnintPtr.asFunction(); + + int bid128_to_int32_rninta( + BID_UINT128 x, + ) { + return _bid128_to_int32_rninta( + x, + ); + } + + late final _bid128_to_int32_rnintaPtr = + _lookup>( + 'bid128_to_int32_rninta'); + late final _bid128_to_int32_rninta = + _bid128_to_int32_rnintaPtr.asFunction(); + + int bid128_to_int32_xceil( + BID_UINT128 x, + ) { + return _bid128_to_int32_xceil( + x, + ); + } + + late final _bid128_to_int32_xceilPtr = + _lookup>( + 'bid128_to_int32_xceil'); + late final _bid128_to_int32_xceil = + _bid128_to_int32_xceilPtr.asFunction(); + + int bid128_to_int32_xfloor( + BID_UINT128 x, + ) { + return _bid128_to_int32_xfloor( + x, + ); + } + + late final _bid128_to_int32_xfloorPtr = + _lookup>( + 'bid128_to_int32_xfloor'); + late final _bid128_to_int32_xfloor = + _bid128_to_int32_xfloorPtr.asFunction(); + + int bid128_to_int32_xint( + BID_UINT128 x, + ) { + return _bid128_to_int32_xint( + x, + ); + } + + late final _bid128_to_int32_xintPtr = + _lookup>( + 'bid128_to_int32_xint'); + late final _bid128_to_int32_xint = + _bid128_to_int32_xintPtr.asFunction(); + + int bid128_to_int32_xrnint( + BID_UINT128 x, + ) { + return _bid128_to_int32_xrnint( + x, + ); + } + + late final _bid128_to_int32_xrnintPtr = + _lookup>( + 'bid128_to_int32_xrnint'); + late final _bid128_to_int32_xrnint = + _bid128_to_int32_xrnintPtr.asFunction(); + + int bid128_to_int32_xrninta( + BID_UINT128 x, + ) { + return _bid128_to_int32_xrninta( + x, + ); + } + + late final _bid128_to_int32_xrnintaPtr = + _lookup>( + 'bid128_to_int32_xrninta'); + late final _bid128_to_int32_xrninta = + _bid128_to_int32_xrnintaPtr.asFunction(); + + int bid128_to_int64_ceil( + BID_UINT128 x, + ) { + return _bid128_to_int64_ceil( + x, + ); + } + + late final _bid128_to_int64_ceilPtr = + _lookup>( + 'bid128_to_int64_ceil'); + late final _bid128_to_int64_ceil = + _bid128_to_int64_ceilPtr.asFunction(); + + int bid128_to_int64_floor( + BID_UINT128 x, + ) { + return _bid128_to_int64_floor( + x, + ); + } + + late final _bid128_to_int64_floorPtr = + _lookup>( + 'bid128_to_int64_floor'); + late final _bid128_to_int64_floor = + _bid128_to_int64_floorPtr.asFunction(); + + int bid128_to_int64_int( + BID_UINT128 x, + ) { + return _bid128_to_int64_int( + x, + ); + } + + late final _bid128_to_int64_intPtr = + _lookup>( + 'bid128_to_int64_int'); + late final _bid128_to_int64_int = + _bid128_to_int64_intPtr.asFunction(); + + int bid128_to_int64_rnint( + BID_UINT128 x, + ) { + return _bid128_to_int64_rnint( + x, + ); + } + + late final _bid128_to_int64_rnintPtr = + _lookup>( + 'bid128_to_int64_rnint'); + late final _bid128_to_int64_rnint = + _bid128_to_int64_rnintPtr.asFunction(); + + int bid128_to_int64_rninta( + BID_UINT128 x, + ) { + return _bid128_to_int64_rninta( + x, + ); + } + + late final _bid128_to_int64_rnintaPtr = + _lookup>( + 'bid128_to_int64_rninta'); + late final _bid128_to_int64_rninta = + _bid128_to_int64_rnintaPtr.asFunction(); + + int bid128_to_int64_xceil( + BID_UINT128 x, + ) { + return _bid128_to_int64_xceil( + x, + ); + } + + late final _bid128_to_int64_xceilPtr = + _lookup>( + 'bid128_to_int64_xceil'); + late final _bid128_to_int64_xceil = + _bid128_to_int64_xceilPtr.asFunction(); + + int bid128_to_int64_xfloor( + BID_UINT128 x, + ) { + return _bid128_to_int64_xfloor( + x, + ); + } + + late final _bid128_to_int64_xfloorPtr = + _lookup>( + 'bid128_to_int64_xfloor'); + late final _bid128_to_int64_xfloor = + _bid128_to_int64_xfloorPtr.asFunction(); + + int bid128_to_int64_xint( + BID_UINT128 x, + ) { + return _bid128_to_int64_xint( + x, + ); + } + + late final _bid128_to_int64_xintPtr = + _lookup>( + 'bid128_to_int64_xint'); + late final _bid128_to_int64_xint = + _bid128_to_int64_xintPtr.asFunction(); + + int bid128_to_int64_xrnint( + BID_UINT128 x, + ) { + return _bid128_to_int64_xrnint( + x, + ); + } + + late final _bid128_to_int64_xrnintPtr = + _lookup>( + 'bid128_to_int64_xrnint'); + late final _bid128_to_int64_xrnint = + _bid128_to_int64_xrnintPtr.asFunction(); + + int bid128_to_int64_xrninta( + BID_UINT128 x, + ) { + return _bid128_to_int64_xrninta( + x, + ); + } + + late final _bid128_to_int64_xrnintaPtr = + _lookup>( + 'bid128_to_int64_xrninta'); + late final _bid128_to_int64_xrninta = + _bid128_to_int64_xrnintaPtr.asFunction(); + + int bid128_to_int8_ceil( + BID_UINT128 x, + ) { + return _bid128_to_int8_ceil( + x, + ); + } + + late final _bid128_to_int8_ceilPtr = + _lookup>( + 'bid128_to_int8_ceil'); + late final _bid128_to_int8_ceil = + _bid128_to_int8_ceilPtr.asFunction(); + + int bid128_to_int8_floor( + BID_UINT128 x, + ) { + return _bid128_to_int8_floor( + x, + ); + } + + late final _bid128_to_int8_floorPtr = + _lookup>( + 'bid128_to_int8_floor'); + late final _bid128_to_int8_floor = + _bid128_to_int8_floorPtr.asFunction(); + + int bid128_to_int8_int( + BID_UINT128 x, + ) { + return _bid128_to_int8_int( + x, + ); + } + + late final _bid128_to_int8_intPtr = + _lookup>( + 'bid128_to_int8_int'); + late final _bid128_to_int8_int = + _bid128_to_int8_intPtr.asFunction(); + + int bid128_to_int8_rnint( + BID_UINT128 x, + ) { + return _bid128_to_int8_rnint( + x, + ); + } + + late final _bid128_to_int8_rnintPtr = + _lookup>( + 'bid128_to_int8_rnint'); + late final _bid128_to_int8_rnint = + _bid128_to_int8_rnintPtr.asFunction(); + + int bid128_to_int8_rninta( + BID_UINT128 x, + ) { + return _bid128_to_int8_rninta( + x, + ); + } + + late final _bid128_to_int8_rnintaPtr = + _lookup>( + 'bid128_to_int8_rninta'); + late final _bid128_to_int8_rninta = + _bid128_to_int8_rnintaPtr.asFunction(); + + int bid128_to_int8_xceil( + BID_UINT128 x, + ) { + return _bid128_to_int8_xceil( + x, + ); + } + + late final _bid128_to_int8_xceilPtr = + _lookup>( + 'bid128_to_int8_xceil'); + late final _bid128_to_int8_xceil = + _bid128_to_int8_xceilPtr.asFunction(); + + int bid128_to_int8_xfloor( + BID_UINT128 x, + ) { + return _bid128_to_int8_xfloor( + x, + ); + } + + late final _bid128_to_int8_xfloorPtr = + _lookup>( + 'bid128_to_int8_xfloor'); + late final _bid128_to_int8_xfloor = + _bid128_to_int8_xfloorPtr.asFunction(); + + int bid128_to_int8_xint( + BID_UINT128 x, + ) { + return _bid128_to_int8_xint( + x, + ); + } + + late final _bid128_to_int8_xintPtr = + _lookup>( + 'bid128_to_int8_xint'); + late final _bid128_to_int8_xint = + _bid128_to_int8_xintPtr.asFunction(); + + int bid128_to_int8_xrnint( + BID_UINT128 x, + ) { + return _bid128_to_int8_xrnint( + x, + ); + } + + late final _bid128_to_int8_xrnintPtr = + _lookup>( + 'bid128_to_int8_xrnint'); + late final _bid128_to_int8_xrnint = + _bid128_to_int8_xrnintPtr.asFunction(); + + int bid128_to_int8_xrninta( + BID_UINT128 x, + ) { + return _bid128_to_int8_xrninta( + x, + ); + } + + late final _bid128_to_int8_xrnintaPtr = + _lookup>( + 'bid128_to_int8_xrninta'); + late final _bid128_to_int8_xrninta = + _bid128_to_int8_xrnintaPtr.asFunction(); + + void bid128_to_string( + ffi.Pointer str, + BID_UINT128 x, + ) { + return _bid128_to_string( + str, + x, + ); + } + + late final _bid128_to_stringPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, BID_UINT128)>>('bid128_to_string'); + late final _bid128_to_string = _bid128_to_stringPtr + .asFunction, BID_UINT128)>(); + + int bid128_to_uint16_ceil( + BID_UINT128 x, + ) { + return _bid128_to_uint16_ceil( + x, + ); + } + + late final _bid128_to_uint16_ceilPtr = + _lookup>( + 'bid128_to_uint16_ceil'); + late final _bid128_to_uint16_ceil = + _bid128_to_uint16_ceilPtr.asFunction(); + + int bid128_to_uint16_floor( + BID_UINT128 x, + ) { + return _bid128_to_uint16_floor( + x, + ); + } + + late final _bid128_to_uint16_floorPtr = + _lookup>( + 'bid128_to_uint16_floor'); + late final _bid128_to_uint16_floor = + _bid128_to_uint16_floorPtr.asFunction(); + + int bid128_to_uint16_int( + BID_UINT128 x, + ) { + return _bid128_to_uint16_int( + x, + ); + } + + late final _bid128_to_uint16_intPtr = + _lookup>( + 'bid128_to_uint16_int'); + late final _bid128_to_uint16_int = + _bid128_to_uint16_intPtr.asFunction(); + + int bid128_to_uint16_rnint( + BID_UINT128 x, + ) { + return _bid128_to_uint16_rnint( + x, + ); + } + + late final _bid128_to_uint16_rnintPtr = + _lookup>( + 'bid128_to_uint16_rnint'); + late final _bid128_to_uint16_rnint = + _bid128_to_uint16_rnintPtr.asFunction(); + + int bid128_to_uint16_rninta( + BID_UINT128 x, + ) { + return _bid128_to_uint16_rninta( + x, + ); + } + + late final _bid128_to_uint16_rnintaPtr = + _lookup>( + 'bid128_to_uint16_rninta'); + late final _bid128_to_uint16_rninta = + _bid128_to_uint16_rnintaPtr.asFunction(); + + int bid128_to_uint16_xceil( + BID_UINT128 x, + ) { + return _bid128_to_uint16_xceil( + x, + ); + } + + late final _bid128_to_uint16_xceilPtr = + _lookup>( + 'bid128_to_uint16_xceil'); + late final _bid128_to_uint16_xceil = + _bid128_to_uint16_xceilPtr.asFunction(); + + int bid128_to_uint16_xfloor( + BID_UINT128 x, + ) { + return _bid128_to_uint16_xfloor( + x, + ); + } + + late final _bid128_to_uint16_xfloorPtr = + _lookup>( + 'bid128_to_uint16_xfloor'); + late final _bid128_to_uint16_xfloor = + _bid128_to_uint16_xfloorPtr.asFunction(); + + int bid128_to_uint16_xint( + BID_UINT128 x, + ) { + return _bid128_to_uint16_xint( + x, + ); + } + + late final _bid128_to_uint16_xintPtr = + _lookup>( + 'bid128_to_uint16_xint'); + late final _bid128_to_uint16_xint = + _bid128_to_uint16_xintPtr.asFunction(); + + int bid128_to_uint16_xrnint( + BID_UINT128 x, + ) { + return _bid128_to_uint16_xrnint( + x, + ); + } + + late final _bid128_to_uint16_xrnintPtr = + _lookup>( + 'bid128_to_uint16_xrnint'); + late final _bid128_to_uint16_xrnint = + _bid128_to_uint16_xrnintPtr.asFunction(); + + int bid128_to_uint16_xrninta( + BID_UINT128 x, + ) { + return _bid128_to_uint16_xrninta( + x, + ); + } + + late final _bid128_to_uint16_xrnintaPtr = + _lookup>( + 'bid128_to_uint16_xrninta'); + late final _bid128_to_uint16_xrninta = + _bid128_to_uint16_xrnintaPtr.asFunction(); + + int bid128_to_uint32_ceil( + BID_UINT128 x, + ) { + return _bid128_to_uint32_ceil( + x, + ); + } + + late final _bid128_to_uint32_ceilPtr = + _lookup>( + 'bid128_to_uint32_ceil'); + late final _bid128_to_uint32_ceil = + _bid128_to_uint32_ceilPtr.asFunction(); + + int bid128_to_uint32_floor( + BID_UINT128 x, + ) { + return _bid128_to_uint32_floor( + x, + ); + } + + late final _bid128_to_uint32_floorPtr = + _lookup>( + 'bid128_to_uint32_floor'); + late final _bid128_to_uint32_floor = + _bid128_to_uint32_floorPtr.asFunction(); + + int bid128_to_uint32_int( + BID_UINT128 x, + ) { + return _bid128_to_uint32_int( + x, + ); + } + + late final _bid128_to_uint32_intPtr = + _lookup>( + 'bid128_to_uint32_int'); + late final _bid128_to_uint32_int = + _bid128_to_uint32_intPtr.asFunction(); + + int bid128_to_uint32_rnint( + BID_UINT128 x, + ) { + return _bid128_to_uint32_rnint( + x, + ); + } + + late final _bid128_to_uint32_rnintPtr = + _lookup>( + 'bid128_to_uint32_rnint'); + late final _bid128_to_uint32_rnint = + _bid128_to_uint32_rnintPtr.asFunction(); + + int bid128_to_uint32_rninta( + BID_UINT128 x, + ) { + return _bid128_to_uint32_rninta( + x, + ); + } + + late final _bid128_to_uint32_rnintaPtr = + _lookup>( + 'bid128_to_uint32_rninta'); + late final _bid128_to_uint32_rninta = + _bid128_to_uint32_rnintaPtr.asFunction(); + + int bid128_to_uint32_xceil( + BID_UINT128 x, + ) { + return _bid128_to_uint32_xceil( + x, + ); + } + + late final _bid128_to_uint32_xceilPtr = + _lookup>( + 'bid128_to_uint32_xceil'); + late final _bid128_to_uint32_xceil = + _bid128_to_uint32_xceilPtr.asFunction(); + + int bid128_to_uint32_xfloor( + BID_UINT128 x, + ) { + return _bid128_to_uint32_xfloor( + x, + ); + } + + late final _bid128_to_uint32_xfloorPtr = + _lookup>( + 'bid128_to_uint32_xfloor'); + late final _bid128_to_uint32_xfloor = + _bid128_to_uint32_xfloorPtr.asFunction(); + + int bid128_to_uint32_xint( + BID_UINT128 x, + ) { + return _bid128_to_uint32_xint( + x, + ); + } + + late final _bid128_to_uint32_xintPtr = + _lookup>( + 'bid128_to_uint32_xint'); + late final _bid128_to_uint32_xint = + _bid128_to_uint32_xintPtr.asFunction(); + + int bid128_to_uint32_xrnint( + BID_UINT128 x, + ) { + return _bid128_to_uint32_xrnint( + x, + ); + } + + late final _bid128_to_uint32_xrnintPtr = + _lookup>( + 'bid128_to_uint32_xrnint'); + late final _bid128_to_uint32_xrnint = + _bid128_to_uint32_xrnintPtr.asFunction(); + + int bid128_to_uint32_xrninta( + BID_UINT128 x, + ) { + return _bid128_to_uint32_xrninta( + x, + ); + } + + late final _bid128_to_uint32_xrnintaPtr = + _lookup>( + 'bid128_to_uint32_xrninta'); + late final _bid128_to_uint32_xrninta = + _bid128_to_uint32_xrnintaPtr.asFunction(); + + int bid128_to_uint64_ceil( + BID_UINT128 x, + ) { + return _bid128_to_uint64_ceil( + x, + ); + } + + late final _bid128_to_uint64_ceilPtr = + _lookup>( + 'bid128_to_uint64_ceil'); + late final _bid128_to_uint64_ceil = + _bid128_to_uint64_ceilPtr.asFunction(); + + int bid128_to_uint64_floor( + BID_UINT128 x, + ) { + return _bid128_to_uint64_floor( + x, + ); + } + + late final _bid128_to_uint64_floorPtr = + _lookup>( + 'bid128_to_uint64_floor'); + late final _bid128_to_uint64_floor = + _bid128_to_uint64_floorPtr.asFunction(); + + int bid128_to_uint64_int( + BID_UINT128 x, + ) { + return _bid128_to_uint64_int( + x, + ); + } + + late final _bid128_to_uint64_intPtr = + _lookup>( + 'bid128_to_uint64_int'); + late final _bid128_to_uint64_int = + _bid128_to_uint64_intPtr.asFunction(); + + int bid128_to_uint64_rnint( + BID_UINT128 x, + ) { + return _bid128_to_uint64_rnint( + x, + ); + } + + late final _bid128_to_uint64_rnintPtr = + _lookup>( + 'bid128_to_uint64_rnint'); + late final _bid128_to_uint64_rnint = + _bid128_to_uint64_rnintPtr.asFunction(); + + int bid128_to_uint64_rninta( + BID_UINT128 x, + ) { + return _bid128_to_uint64_rninta( + x, + ); + } + + late final _bid128_to_uint64_rnintaPtr = + _lookup>( + 'bid128_to_uint64_rninta'); + late final _bid128_to_uint64_rninta = + _bid128_to_uint64_rnintaPtr.asFunction(); + + int bid128_to_uint64_xceil( + BID_UINT128 x, + ) { + return _bid128_to_uint64_xceil( + x, + ); + } + + late final _bid128_to_uint64_xceilPtr = + _lookup>( + 'bid128_to_uint64_xceil'); + late final _bid128_to_uint64_xceil = + _bid128_to_uint64_xceilPtr.asFunction(); + + int bid128_to_uint64_xfloor( + BID_UINT128 x, + ) { + return _bid128_to_uint64_xfloor( + x, + ); + } + + late final _bid128_to_uint64_xfloorPtr = + _lookup>( + 'bid128_to_uint64_xfloor'); + late final _bid128_to_uint64_xfloor = + _bid128_to_uint64_xfloorPtr.asFunction(); + + int bid128_to_uint64_xint( + BID_UINT128 x, + ) { + return _bid128_to_uint64_xint( + x, + ); + } + + late final _bid128_to_uint64_xintPtr = + _lookup>( + 'bid128_to_uint64_xint'); + late final _bid128_to_uint64_xint = + _bid128_to_uint64_xintPtr.asFunction(); + + int bid128_to_uint64_xrnint( + BID_UINT128 x, + ) { + return _bid128_to_uint64_xrnint( + x, + ); + } + + late final _bid128_to_uint64_xrnintPtr = + _lookup>( + 'bid128_to_uint64_xrnint'); + late final _bid128_to_uint64_xrnint = + _bid128_to_uint64_xrnintPtr.asFunction(); + + int bid128_to_uint64_xrninta( + BID_UINT128 x, + ) { + return _bid128_to_uint64_xrninta( + x, + ); + } + + late final _bid128_to_uint64_xrnintaPtr = + _lookup>( + 'bid128_to_uint64_xrninta'); + late final _bid128_to_uint64_xrninta = + _bid128_to_uint64_xrnintaPtr.asFunction(); + + int bid128_to_uint8_ceil( + BID_UINT128 x, + ) { + return _bid128_to_uint8_ceil( + x, + ); + } + + late final _bid128_to_uint8_ceilPtr = + _lookup>( + 'bid128_to_uint8_ceil'); + late final _bid128_to_uint8_ceil = + _bid128_to_uint8_ceilPtr.asFunction(); + + int bid128_to_uint8_floor( + BID_UINT128 x, + ) { + return _bid128_to_uint8_floor( + x, + ); + } + + late final _bid128_to_uint8_floorPtr = + _lookup>( + 'bid128_to_uint8_floor'); + late final _bid128_to_uint8_floor = + _bid128_to_uint8_floorPtr.asFunction(); + + int bid128_to_uint8_int( + BID_UINT128 x, + ) { + return _bid128_to_uint8_int( + x, + ); + } + + late final _bid128_to_uint8_intPtr = + _lookup>( + 'bid128_to_uint8_int'); + late final _bid128_to_uint8_int = + _bid128_to_uint8_intPtr.asFunction(); + + int bid128_to_uint8_rnint( + BID_UINT128 x, + ) { + return _bid128_to_uint8_rnint( + x, + ); + } + + late final _bid128_to_uint8_rnintPtr = + _lookup>( + 'bid128_to_uint8_rnint'); + late final _bid128_to_uint8_rnint = + _bid128_to_uint8_rnintPtr.asFunction(); + + int bid128_to_uint8_rninta( + BID_UINT128 x, + ) { + return _bid128_to_uint8_rninta( + x, + ); + } + + late final _bid128_to_uint8_rnintaPtr = + _lookup>( + 'bid128_to_uint8_rninta'); + late final _bid128_to_uint8_rninta = + _bid128_to_uint8_rnintaPtr.asFunction(); + + int bid128_to_uint8_xceil( + BID_UINT128 x, + ) { + return _bid128_to_uint8_xceil( + x, + ); + } + + late final _bid128_to_uint8_xceilPtr = + _lookup>( + 'bid128_to_uint8_xceil'); + late final _bid128_to_uint8_xceil = + _bid128_to_uint8_xceilPtr.asFunction(); + + int bid128_to_uint8_xfloor( + BID_UINT128 x, + ) { + return _bid128_to_uint8_xfloor( + x, + ); + } + + late final _bid128_to_uint8_xfloorPtr = + _lookup>( + 'bid128_to_uint8_xfloor'); + late final _bid128_to_uint8_xfloor = + _bid128_to_uint8_xfloorPtr.asFunction(); + + int bid128_to_uint8_xint( + BID_UINT128 x, + ) { + return _bid128_to_uint8_xint( + x, + ); + } + + late final _bid128_to_uint8_xintPtr = + _lookup>( + 'bid128_to_uint8_xint'); + late final _bid128_to_uint8_xint = + _bid128_to_uint8_xintPtr.asFunction(); + + int bid128_to_uint8_xrnint( + BID_UINT128 x, + ) { + return _bid128_to_uint8_xrnint( + x, + ); + } + + late final _bid128_to_uint8_xrnintPtr = + _lookup>( + 'bid128_to_uint8_xrnint'); + late final _bid128_to_uint8_xrnint = + _bid128_to_uint8_xrnintPtr.asFunction(); + + int bid128_to_uint8_xrninta( + BID_UINT128 x, + ) { + return _bid128_to_uint8_xrninta( + x, + ); + } + + late final _bid128_to_uint8_xrnintaPtr = + _lookup>( + 'bid128_to_uint8_xrninta'); + late final _bid128_to_uint8_xrninta = + _bid128_to_uint8_xrnintaPtr.asFunction(); + + int bid128_totalOrder( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_totalOrder( + x, + y, + ); + } + + late final _bid128_totalOrderPtr = + _lookup>( + 'bid128_totalOrder'); + late final _bid128_totalOrder = _bid128_totalOrderPtr + .asFunction(); + + int bid128_totalOrderMag( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid128_totalOrderMag( + x, + y, + ); + } + + late final _bid128_totalOrderMagPtr = + _lookup>( + 'bid128_totalOrderMag'); + late final _bid128_totalOrderMag = _bid128_totalOrderMagPtr + .asFunction(); + + BID_UINT128 bid128d_sqrt( + int x, + ) { + return _bid128d_sqrt( + x, + ); + } + + late final _bid128d_sqrtPtr = + _lookup>( + 'bid128d_sqrt'); + late final _bid128d_sqrt = + _bid128d_sqrtPtr.asFunction(); + + BID_UINT128 bid128dd_add( + int x, + int y, + ) { + return _bid128dd_add( + x, + y, + ); + } + + late final _bid128dd_addPtr = + _lookup>( + 'bid128dd_add'); + late final _bid128dd_add = + _bid128dd_addPtr.asFunction(); + + BID_UINT128 bid128dd_div( + int x, + int y, + ) { + return _bid128dd_div( + x, + y, + ); + } + + late final _bid128dd_divPtr = + _lookup>( + 'bid128dd_div'); + late final _bid128dd_div = + _bid128dd_divPtr.asFunction(); + + BID_UINT128 bid128dd_mul( + int x, + int y, + ) { + return _bid128dd_mul( + x, + y, + ); + } + + late final _bid128dd_mulPtr = + _lookup>( + 'bid128dd_mul'); + late final _bid128dd_mul = + _bid128dd_mulPtr.asFunction(); + + BID_UINT128 bid128dd_sub( + int x, + int y, + ) { + return _bid128dd_sub( + x, + y, + ); + } + + late final _bid128dd_subPtr = + _lookup>( + 'bid128dd_sub'); + late final _bid128dd_sub = + _bid128dd_subPtr.asFunction(); + + BID_UINT128 bid128ddd_fma( + int x, + int y, + int z, + ) { + return _bid128ddd_fma( + x, + y, + z, + ); + } + + late final _bid128ddd_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT64, BID_UINT64, BID_UINT64)>>('bid128ddd_fma'); + late final _bid128ddd_fma = + _bid128ddd_fmaPtr.asFunction(); + + BID_UINT128 bid128ddq_fma( + int x, + int y, + BID_UINT128 z, + ) { + return _bid128ddq_fma( + x, + y, + z, + ); + } + + late final _bid128ddq_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT64, BID_UINT64, BID_UINT128)>>('bid128ddq_fma'); + late final _bid128ddq_fma = _bid128ddq_fmaPtr + .asFunction(); + + BID_UINT128 bid128dq_add( + int x, + BID_UINT128 y, + ) { + return _bid128dq_add( + x, + y, + ); + } + + late final _bid128dq_addPtr = _lookup< + ffi.NativeFunction>( + 'bid128dq_add'); + late final _bid128dq_add = + _bid128dq_addPtr.asFunction(); + + BID_UINT128 bid128dq_div( + int x, + BID_UINT128 y, + ) { + return _bid128dq_div( + x, + y, + ); + } + + late final _bid128dq_divPtr = _lookup< + ffi.NativeFunction>( + 'bid128dq_div'); + late final _bid128dq_div = + _bid128dq_divPtr.asFunction(); + + BID_UINT128 bid128dq_mul( + int x, + BID_UINT128 y, + ) { + return _bid128dq_mul( + x, + y, + ); + } + + late final _bid128dq_mulPtr = _lookup< + ffi.NativeFunction>( + 'bid128dq_mul'); + late final _bid128dq_mul = + _bid128dq_mulPtr.asFunction(); + + BID_UINT128 bid128dq_sub( + int x, + BID_UINT128 y, + ) { + return _bid128dq_sub( + x, + y, + ); + } + + late final _bid128dq_subPtr = _lookup< + ffi.NativeFunction>( + 'bid128dq_sub'); + late final _bid128dq_sub = + _bid128dq_subPtr.asFunction(); + + BID_UINT128 bid128dqd_fma( + int x, + BID_UINT128 y, + int z, + ) { + return _bid128dqd_fma( + x, + y, + z, + ); + } + + late final _bid128dqd_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT64, BID_UINT128, BID_UINT64)>>('bid128dqd_fma'); + late final _bid128dqd_fma = _bid128dqd_fmaPtr + .asFunction(); + + BID_UINT128 bid128dqq_fma( + int x, + BID_UINT128 y, + BID_UINT128 z, + ) { + return _bid128dqq_fma( + x, + y, + z, + ); + } + + late final _bid128dqq_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT64, BID_UINT128, BID_UINT128)>>('bid128dqq_fma'); + late final _bid128dqq_fma = _bid128dqq_fmaPtr + .asFunction(); + + BID_UINT128 bid128qd_add( + BID_UINT128 x, + int y, + ) { + return _bid128qd_add( + x, + y, + ); + } + + late final _bid128qd_addPtr = _lookup< + ffi.NativeFunction>( + 'bid128qd_add'); + late final _bid128qd_add = + _bid128qd_addPtr.asFunction(); + + BID_UINT128 bid128qd_div( + BID_UINT128 x, + int y, + ) { + return _bid128qd_div( + x, + y, + ); + } + + late final _bid128qd_divPtr = _lookup< + ffi.NativeFunction>( + 'bid128qd_div'); + late final _bid128qd_div = + _bid128qd_divPtr.asFunction(); + + BID_UINT128 bid128qd_mul( + BID_UINT128 x, + int y, + ) { + return _bid128qd_mul( + x, + y, + ); + } + + late final _bid128qd_mulPtr = _lookup< + ffi.NativeFunction>( + 'bid128qd_mul'); + late final _bid128qd_mul = + _bid128qd_mulPtr.asFunction(); + + BID_UINT128 bid128qd_sub( + BID_UINT128 x, + int y, + ) { + return _bid128qd_sub( + x, + y, + ); + } + + late final _bid128qd_subPtr = _lookup< + ffi.NativeFunction>( + 'bid128qd_sub'); + late final _bid128qd_sub = + _bid128qd_subPtr.asFunction(); + + BID_UINT128 bid128qdd_fma( + BID_UINT128 x, + int y, + int z, + ) { + return _bid128qdd_fma( + x, + y, + z, + ); + } + + late final _bid128qdd_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT128, BID_UINT64, BID_UINT64)>>('bid128qdd_fma'); + late final _bid128qdd_fma = _bid128qdd_fmaPtr + .asFunction(); + + BID_UINT128 bid128qdq_fma( + BID_UINT128 x, + int y, + BID_UINT128 z, + ) { + return _bid128qdq_fma( + x, + y, + z, + ); + } + + late final _bid128qdq_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT128, BID_UINT64, BID_UINT128)>>('bid128qdq_fma'); + late final _bid128qdq_fma = _bid128qdq_fmaPtr + .asFunction(); + + BID_UINT128 bid128qqd_fma( + BID_UINT128 x, + BID_UINT128 y, + int z, + ) { + return _bid128qqd_fma( + x, + y, + z, + ); + } + + late final _bid128qqd_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function( + BID_UINT128, BID_UINT128, BID_UINT64)>>('bid128qqd_fma'); + late final _bid128qqd_fma = _bid128qqd_fmaPtr + .asFunction(); + + int bid32_abs( + int x, + ) { + return _bid32_abs( + x, + ); + } + + late final _bid32_absPtr = + _lookup>('bid32_abs'); + late final _bid32_abs = _bid32_absPtr.asFunction(); + + int bid32_acos( + int x, + ) { + return _bid32_acos( + x, + ); + } + + late final _bid32_acosPtr = + _lookup>( + 'bid32_acos'); + late final _bid32_acos = _bid32_acosPtr.asFunction(); + + int bid32_acosh( + int x, + ) { + return _bid32_acosh( + x, + ); + } + + late final _bid32_acoshPtr = + _lookup>( + 'bid32_acosh'); + late final _bid32_acosh = _bid32_acoshPtr.asFunction(); + + int bid32_add( + int x, + int y, + ) { + return _bid32_add( + x, + y, + ); + } + + late final _bid32_addPtr = + _lookup>( + 'bid32_add'); + late final _bid32_add = _bid32_addPtr.asFunction(); + + int bid32_asin( + int x, + ) { + return _bid32_asin( + x, + ); + } + + late final _bid32_asinPtr = + _lookup>( + 'bid32_asin'); + late final _bid32_asin = _bid32_asinPtr.asFunction(); + + int bid32_asinh( + int x, + ) { + return _bid32_asinh( + x, + ); + } + + late final _bid32_asinhPtr = + _lookup>( + 'bid32_asinh'); + late final _bid32_asinh = _bid32_asinhPtr.asFunction(); + + int bid32_atan( + int x, + ) { + return _bid32_atan( + x, + ); + } + + late final _bid32_atanPtr = + _lookup>( + 'bid32_atan'); + late final _bid32_atan = _bid32_atanPtr.asFunction(); + + int bid32_atan2( + int x, + int y, + ) { + return _bid32_atan2( + x, + y, + ); + } + + late final _bid32_atan2Ptr = + _lookup>( + 'bid32_atan2'); + late final _bid32_atan2 = + _bid32_atan2Ptr.asFunction(); + + int bid32_atanh( + int x, + ) { + return _bid32_atanh( + x, + ); + } + + late final _bid32_atanhPtr = + _lookup>( + 'bid32_atanh'); + late final _bid32_atanh = _bid32_atanhPtr.asFunction(); + + int bid32_cbrt( + int x, + ) { + return _bid32_cbrt( + x, + ); + } + + late final _bid32_cbrtPtr = + _lookup>( + 'bid32_cbrt'); + late final _bid32_cbrt = _bid32_cbrtPtr.asFunction(); + + int bid32_class( + int x, + ) { + return _bid32_class( + x, + ); + } + + late final _bid32_classPtr = + _lookup>('bid32_class'); + late final _bid32_class = _bid32_classPtr.asFunction(); + + int bid32_copy( + int x, + ) { + return _bid32_copy( + x, + ); + } + + late final _bid32_copyPtr = + _lookup>( + 'bid32_copy'); + late final _bid32_copy = _bid32_copyPtr.asFunction(); + + int bid32_copySign( + int x, + int y, + ) { + return _bid32_copySign( + x, + y, + ); + } + + late final _bid32_copySignPtr = + _lookup>( + 'bid32_copySign'); + late final _bid32_copySign = + _bid32_copySignPtr.asFunction(); + + int bid32_cos( + int x, + ) { + return _bid32_cos( + x, + ); + } + + late final _bid32_cosPtr = + _lookup>('bid32_cos'); + late final _bid32_cos = _bid32_cosPtr.asFunction(); + + int bid32_cosh( + int x, + ) { + return _bid32_cosh( + x, + ); + } + + late final _bid32_coshPtr = + _lookup>( + 'bid32_cosh'); + late final _bid32_cosh = _bid32_coshPtr.asFunction(); + + int bid32_div( + int x, + int y, + ) { + return _bid32_div( + x, + y, + ); + } + + late final _bid32_divPtr = + _lookup>( + 'bid32_div'); + late final _bid32_div = _bid32_divPtr.asFunction(); + + int bid32_erf( + int x, + ) { + return _bid32_erf( + x, + ); + } + + late final _bid32_erfPtr = + _lookup>('bid32_erf'); + late final _bid32_erf = _bid32_erfPtr.asFunction(); + + int bid32_erfc( + int x, + ) { + return _bid32_erfc( + x, + ); + } + + late final _bid32_erfcPtr = + _lookup>( + 'bid32_erfc'); + late final _bid32_erfc = _bid32_erfcPtr.asFunction(); + + int bid32_exp( + int x, + ) { + return _bid32_exp( + x, + ); + } + + late final _bid32_expPtr = + _lookup>('bid32_exp'); + late final _bid32_exp = _bid32_expPtr.asFunction(); + + int bid32_exp10( + int x, + ) { + return _bid32_exp10( + x, + ); + } + + late final _bid32_exp10Ptr = + _lookup>( + 'bid32_exp10'); + late final _bid32_exp10 = _bid32_exp10Ptr.asFunction(); + + int bid32_exp2( + int x, + ) { + return _bid32_exp2( + x, + ); + } + + late final _bid32_exp2Ptr = + _lookup>( + 'bid32_exp2'); + late final _bid32_exp2 = _bid32_exp2Ptr.asFunction(); + + int bid32_expm1( + int x, + ) { + return _bid32_expm1( + x, + ); + } + + late final _bid32_expm1Ptr = + _lookup>( + 'bid32_expm1'); + late final _bid32_expm1 = _bid32_expm1Ptr.asFunction(); + + int bid32_fdim( + int x, + int y, + ) { + return _bid32_fdim( + x, + y, + ); + } + + late final _bid32_fdimPtr = + _lookup>( + 'bid32_fdim'); + late final _bid32_fdim = _bid32_fdimPtr.asFunction(); + + int bid32_fma( + int x, + int y, + int z, + ) { + return _bid32_fma( + x, + y, + z, + ); + } + + late final _bid32_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT32 Function( + BID_UINT32, BID_UINT32, BID_UINT32)>>('bid32_fma'); + late final _bid32_fma = + _bid32_fmaPtr.asFunction(); + + int bid32_fmod( + int x, + int y, + ) { + return _bid32_fmod( + x, + y, + ); + } + + late final _bid32_fmodPtr = + _lookup>( + 'bid32_fmod'); + late final _bid32_fmod = _bid32_fmodPtr.asFunction(); + + int bid32_frexp( + int x, + ffi.Pointer exp, + ) { + return _bid32_frexp( + x, + exp, + ); + } + + late final _bid32_frexpPtr = _lookup< + ffi.NativeFunction< + BID_UINT32 Function( + BID_UINT32, ffi.Pointer)>>('bid32_frexp'); + late final _bid32_frexp = + _bid32_frexpPtr.asFunction)>(); + + int bid32_from_int32( + int x, + ) { + return _bid32_from_int32( + x, + ); + } + + late final _bid32_from_int32Ptr = + _lookup>( + 'bid32_from_int32'); + late final _bid32_from_int32 = + _bid32_from_int32Ptr.asFunction(); + + int bid32_from_int64( + int x, + ) { + return _bid32_from_int64( + x, + ); + } + + late final _bid32_from_int64Ptr = + _lookup>( + 'bid32_from_int64'); + late final _bid32_from_int64 = + _bid32_from_int64Ptr.asFunction(); + + int bid32_from_string( + ffi.Pointer ps, + ) { + return _bid32_from_string( + ps, + ); + } + + late final _bid32_from_stringPtr = + _lookup)>>( + 'bid32_from_string'); + late final _bid32_from_string = + _bid32_from_stringPtr.asFunction)>(); + + int bid32_from_uint32( + int x, + ) { + return _bid32_from_uint32( + x, + ); + } + + late final _bid32_from_uint32Ptr = + _lookup>( + 'bid32_from_uint32'); + late final _bid32_from_uint32 = + _bid32_from_uint32Ptr.asFunction(); + + int bid32_from_uint64( + int _RND_MODE_PARAM, + ) { + return _bid32_from_uint64( + _RND_MODE_PARAM, + ); + } + + late final _bid32_from_uint64Ptr = + _lookup>( + 'bid32_from_uint64'); + late final _bid32_from_uint64 = + _bid32_from_uint64Ptr.asFunction(); + + int bid32_hypot( + int x, + int y, + ) { + return _bid32_hypot( + x, + y, + ); + } + + late final _bid32_hypotPtr = + _lookup>( + 'bid32_hypot'); + late final _bid32_hypot = + _bid32_hypotPtr.asFunction(); + + int bid32_ilogb( + int x, + ) { + return _bid32_ilogb( + x, + ); + } + + late final _bid32_ilogbPtr = + _lookup>('bid32_ilogb'); + late final _bid32_ilogb = _bid32_ilogbPtr.asFunction(); + + int bid32_inf() { + return _bid32_inf(); + } + + late final _bid32_infPtr = + _lookup>('bid32_inf'); + late final _bid32_inf = _bid32_infPtr.asFunction(); + + int bid32_isCanonical( + int x, + ) { + return _bid32_isCanonical( + x, + ); + } + + late final _bid32_isCanonicalPtr = + _lookup>( + 'bid32_isCanonical'); + late final _bid32_isCanonical = + _bid32_isCanonicalPtr.asFunction(); + + int bid32_isFinite( + int x, + ) { + return _bid32_isFinite( + x, + ); + } + + late final _bid32_isFinitePtr = + _lookup>( + 'bid32_isFinite'); + late final _bid32_isFinite = + _bid32_isFinitePtr.asFunction(); + + int bid32_isInf( + int x, + ) { + return _bid32_isInf( + x, + ); + } + + late final _bid32_isInfPtr = + _lookup>('bid32_isInf'); + late final _bid32_isInf = _bid32_isInfPtr.asFunction(); + + int bid32_isNaN( + int x, + ) { + return _bid32_isNaN( + x, + ); + } + + late final _bid32_isNaNPtr = + _lookup>('bid32_isNaN'); + late final _bid32_isNaN = _bid32_isNaNPtr.asFunction(); + + int bid32_isNormal( + int x, + ) { + return _bid32_isNormal( + x, + ); + } + + late final _bid32_isNormalPtr = + _lookup>( + 'bid32_isNormal'); + late final _bid32_isNormal = + _bid32_isNormalPtr.asFunction(); + + int bid32_isSignaling( + int x, + ) { + return _bid32_isSignaling( + x, + ); + } + + late final _bid32_isSignalingPtr = + _lookup>( + 'bid32_isSignaling'); + late final _bid32_isSignaling = + _bid32_isSignalingPtr.asFunction(); + + int bid32_isSigned( + int x, + ) { + return _bid32_isSigned( + x, + ); + } + + late final _bid32_isSignedPtr = + _lookup>( + 'bid32_isSigned'); + late final _bid32_isSigned = + _bid32_isSignedPtr.asFunction(); + + int bid32_isSubnormal( + int x, + ) { + return _bid32_isSubnormal( + x, + ); + } + + late final _bid32_isSubnormalPtr = + _lookup>( + 'bid32_isSubnormal'); + late final _bid32_isSubnormal = + _bid32_isSubnormalPtr.asFunction(); + + int bid32_isZero( + int x, + ) { + return _bid32_isZero( + x, + ); + } + + late final _bid32_isZeroPtr = + _lookup>('bid32_isZero'); + late final _bid32_isZero = _bid32_isZeroPtr.asFunction(); + + int bid32_ldexp( + int x, + int n, + ) { + return _bid32_ldexp( + x, + n, + ); + } + + late final _bid32_ldexpPtr = + _lookup>( + 'bid32_ldexp'); + late final _bid32_ldexp = + _bid32_ldexpPtr.asFunction(); + + int bid32_lgamma( + int x, + ) { + return _bid32_lgamma( + x, + ); + } + + late final _bid32_lgammaPtr = + _lookup>( + 'bid32_lgamma'); + late final _bid32_lgamma = _bid32_lgammaPtr.asFunction(); + + int bid32_llquantexp( + int x, + ) { + return _bid32_llquantexp( + x, + ); + } + + late final _bid32_llquantexpPtr = + _lookup>( + 'bid32_llquantexp'); + late final _bid32_llquantexp = + _bid32_llquantexpPtr.asFunction(); + + int bid32_llrint( + int x, + ) { + return _bid32_llrint( + x, + ); + } + + late final _bid32_llrintPtr = + _lookup>( + 'bid32_llrint'); + late final _bid32_llrint = _bid32_llrintPtr.asFunction(); + + int bid32_llround( + int x, + ) { + return _bid32_llround( + x, + ); + } + + late final _bid32_llroundPtr = + _lookup>( + 'bid32_llround'); + late final _bid32_llround = _bid32_llroundPtr.asFunction(); + + int bid32_log( + int x, + ) { + return _bid32_log( + x, + ); + } + + late final _bid32_logPtr = + _lookup>('bid32_log'); + late final _bid32_log = _bid32_logPtr.asFunction(); + + int bid32_log10( + int x, + ) { + return _bid32_log10( + x, + ); + } + + late final _bid32_log10Ptr = + _lookup>( + 'bid32_log10'); + late final _bid32_log10 = _bid32_log10Ptr.asFunction(); + + int bid32_log1p( + int x, + ) { + return _bid32_log1p( + x, + ); + } + + late final _bid32_log1pPtr = + _lookup>( + 'bid32_log1p'); + late final _bid32_log1p = _bid32_log1pPtr.asFunction(); + + int bid32_log2( + int x, + ) { + return _bid32_log2( + x, + ); + } + + late final _bid32_log2Ptr = + _lookup>( + 'bid32_log2'); + late final _bid32_log2 = _bid32_log2Ptr.asFunction(); + + int bid32_logb( + int x, + ) { + return _bid32_logb( + x, + ); + } + + late final _bid32_logbPtr = + _lookup>( + 'bid32_logb'); + late final _bid32_logb = _bid32_logbPtr.asFunction(); + + int bid32_lrint( + int x, + ) { + return _bid32_lrint( + x, + ); + } + + late final _bid32_lrintPtr = + _lookup>('bid32_lrint'); + late final _bid32_lrint = _bid32_lrintPtr.asFunction(); + + int bid32_lround( + int x, + ) { + return _bid32_lround( + x, + ); + } + + late final _bid32_lroundPtr = + _lookup>( + 'bid32_lround'); + late final _bid32_lround = _bid32_lroundPtr.asFunction(); + + int bid32_maxnum( + int x, + int y, + ) { + return _bid32_maxnum( + x, + y, + ); + } + + late final _bid32_maxnumPtr = + _lookup>( + 'bid32_maxnum'); + late final _bid32_maxnum = + _bid32_maxnumPtr.asFunction(); + + int bid32_maxnum_mag( + int x, + int y, + ) { + return _bid32_maxnum_mag( + x, + y, + ); + } + + late final _bid32_maxnum_magPtr = + _lookup>( + 'bid32_maxnum_mag'); + late final _bid32_maxnum_mag = + _bid32_maxnum_magPtr.asFunction(); + + int bid32_minnum( + int x, + int y, + ) { + return _bid32_minnum( + x, + y, + ); + } + + late final _bid32_minnumPtr = + _lookup>( + 'bid32_minnum'); + late final _bid32_minnum = + _bid32_minnumPtr.asFunction(); + + int bid32_minnum_mag( + int x, + int y, + ) { + return _bid32_minnum_mag( + x, + y, + ); + } + + late final _bid32_minnum_magPtr = + _lookup>( + 'bid32_minnum_mag'); + late final _bid32_minnum_mag = + _bid32_minnum_magPtr.asFunction(); + + int bid32_modf( + int x, + ffi.Pointer y, + ) { + return _bid32_modf( + x, + y, + ); + } + + late final _bid32_modfPtr = _lookup< + ffi.NativeFunction< + BID_UINT32 Function( + BID_UINT32, ffi.Pointer)>>('bid32_modf'); + late final _bid32_modf = + _bid32_modfPtr.asFunction)>(); + + int bid32_mul( + int x, + int y, + ) { + return _bid32_mul( + x, + y, + ); + } + + late final _bid32_mulPtr = + _lookup>( + 'bid32_mul'); + late final _bid32_mul = _bid32_mulPtr.asFunction(); + + int bid32_nan( + ffi.Pointer tagp, + ) { + return _bid32_nan( + tagp, + ); + } + + late final _bid32_nanPtr = + _lookup)>>( + 'bid32_nan'); + late final _bid32_nan = + _bid32_nanPtr.asFunction)>(); + + int bid32_nearbyint( + int x, + ) { + return _bid32_nearbyint( + x, + ); + } + + late final _bid32_nearbyintPtr = + _lookup>( + 'bid32_nearbyint'); + late final _bid32_nearbyint = + _bid32_nearbyintPtr.asFunction(); + + int bid32_negate( + int x, + ) { + return _bid32_negate( + x, + ); + } + + late final _bid32_negatePtr = + _lookup>( + 'bid32_negate'); + late final _bid32_negate = _bid32_negatePtr.asFunction(); + + int bid32_nextafter( + int x, + int y, + ) { + return _bid32_nextafter( + x, + y, + ); + } + + late final _bid32_nextafterPtr = + _lookup>( + 'bid32_nextafter'); + late final _bid32_nextafter = + _bid32_nextafterPtr.asFunction(); + + int bid32_nextdown( + int x, + ) { + return _bid32_nextdown( + x, + ); + } + + late final _bid32_nextdownPtr = + _lookup>( + 'bid32_nextdown'); + late final _bid32_nextdown = + _bid32_nextdownPtr.asFunction(); + + int bid32_nexttoward( + int x, + BID_UINT128 y, + ) { + return _bid32_nexttoward( + x, + y, + ); + } + + late final _bid32_nexttowardPtr = + _lookup>( + 'bid32_nexttoward'); + late final _bid32_nexttoward = + _bid32_nexttowardPtr.asFunction(); + + int bid32_nextup( + int x, + ) { + return _bid32_nextup( + x, + ); + } + + late final _bid32_nextupPtr = + _lookup>( + 'bid32_nextup'); + late final _bid32_nextup = _bid32_nextupPtr.asFunction(); + + int bid32_pow( + int x, + int y, + ) { + return _bid32_pow( + x, + y, + ); + } + + late final _bid32_powPtr = + _lookup>( + 'bid32_pow'); + late final _bid32_pow = _bid32_powPtr.asFunction(); + + int bid32_quantexp( + int x, + ) { + return _bid32_quantexp( + x, + ); + } + + late final _bid32_quantexpPtr = + _lookup>( + 'bid32_quantexp'); + late final _bid32_quantexp = + _bid32_quantexpPtr.asFunction(); + + int bid32_quantize( + int x, + int y, + ) { + return _bid32_quantize( + x, + y, + ); + } + + late final _bid32_quantizePtr = + _lookup>( + 'bid32_quantize'); + late final _bid32_quantize = + _bid32_quantizePtr.asFunction(); + + int bid32_quantum( + int x, + ) { + return _bid32_quantum( + x, + ); + } + + late final _bid32_quantumPtr = + _lookup>( + 'bid32_quantum'); + late final _bid32_quantum = _bid32_quantumPtr.asFunction(); + + int bid32_quiet_equal( + int x, + int y, + ) { + return _bid32_quiet_equal( + x, + y, + ); + } + + late final _bid32_quiet_equalPtr = + _lookup>( + 'bid32_quiet_equal'); + late final _bid32_quiet_equal = + _bid32_quiet_equalPtr.asFunction(); + + int bid32_quiet_greater( + int x, + int y, + ) { + return _bid32_quiet_greater( + x, + y, + ); + } + + late final _bid32_quiet_greaterPtr = + _lookup>( + 'bid32_quiet_greater'); + late final _bid32_quiet_greater = + _bid32_quiet_greaterPtr.asFunction(); + + int bid32_quiet_greater_equal( + int x, + int y, + ) { + return _bid32_quiet_greater_equal( + x, + y, + ); + } + + late final _bid32_quiet_greater_equalPtr = + _lookup>( + 'bid32_quiet_greater_equal'); + late final _bid32_quiet_greater_equal = + _bid32_quiet_greater_equalPtr.asFunction(); + + int bid32_quiet_greater_unordered( + int x, + int y, + ) { + return _bid32_quiet_greater_unordered( + x, + y, + ); + } + + late final _bid32_quiet_greater_unorderedPtr = + _lookup>( + 'bid32_quiet_greater_unordered'); + late final _bid32_quiet_greater_unordered = + _bid32_quiet_greater_unorderedPtr.asFunction(); + + int bid32_quiet_less( + int x, + int y, + ) { + return _bid32_quiet_less( + x, + y, + ); + } + + late final _bid32_quiet_lessPtr = + _lookup>( + 'bid32_quiet_less'); + late final _bid32_quiet_less = + _bid32_quiet_lessPtr.asFunction(); + + int bid32_quiet_less_equal( + int x, + int y, + ) { + return _bid32_quiet_less_equal( + x, + y, + ); + } + + late final _bid32_quiet_less_equalPtr = + _lookup>( + 'bid32_quiet_less_equal'); + late final _bid32_quiet_less_equal = + _bid32_quiet_less_equalPtr.asFunction(); + + int bid32_quiet_less_unordered( + int x, + int y, + ) { + return _bid32_quiet_less_unordered( + x, + y, + ); + } + + late final _bid32_quiet_less_unorderedPtr = + _lookup>( + 'bid32_quiet_less_unordered'); + late final _bid32_quiet_less_unordered = + _bid32_quiet_less_unorderedPtr.asFunction(); + + int bid32_quiet_not_equal( + int x, + int y, + ) { + return _bid32_quiet_not_equal( + x, + y, + ); + } + + late final _bid32_quiet_not_equalPtr = + _lookup>( + 'bid32_quiet_not_equal'); + late final _bid32_quiet_not_equal = + _bid32_quiet_not_equalPtr.asFunction(); + + int bid32_quiet_not_greater( + int x, + int y, + ) { + return _bid32_quiet_not_greater( + x, + y, + ); + } + + late final _bid32_quiet_not_greaterPtr = + _lookup>( + 'bid32_quiet_not_greater'); + late final _bid32_quiet_not_greater = + _bid32_quiet_not_greaterPtr.asFunction(); + + int bid32_quiet_not_less( + int x, + int y, + ) { + return _bid32_quiet_not_less( + x, + y, + ); + } + + late final _bid32_quiet_not_lessPtr = + _lookup>( + 'bid32_quiet_not_less'); + late final _bid32_quiet_not_less = + _bid32_quiet_not_lessPtr.asFunction(); + + int bid32_quiet_ordered( + int x, + int y, + ) { + return _bid32_quiet_ordered( + x, + y, + ); + } + + late final _bid32_quiet_orderedPtr = + _lookup>( + 'bid32_quiet_ordered'); + late final _bid32_quiet_ordered = + _bid32_quiet_orderedPtr.asFunction(); + + int bid32_quiet_unordered( + int x, + int y, + ) { + return _bid32_quiet_unordered( + x, + y, + ); + } + + late final _bid32_quiet_unorderedPtr = + _lookup>( + 'bid32_quiet_unordered'); + late final _bid32_quiet_unordered = + _bid32_quiet_unorderedPtr.asFunction(); + + int bid32_radix( + int x, + ) { + return _bid32_radix( + x, + ); + } + + late final _bid32_radixPtr = + _lookup>('bid32_radix'); + late final _bid32_radix = _bid32_radixPtr.asFunction(); + + int bid32_rem( + int x, + int y, + ) { + return _bid32_rem( + x, + y, + ); + } + + late final _bid32_remPtr = + _lookup>( + 'bid32_rem'); + late final _bid32_rem = _bid32_remPtr.asFunction(); + + int bid32_round_integral_exact( + int x, + ) { + return _bid32_round_integral_exact( + x, + ); + } + + late final _bid32_round_integral_exactPtr = + _lookup>( + 'bid32_round_integral_exact'); + late final _bid32_round_integral_exact = + _bid32_round_integral_exactPtr.asFunction(); + + int bid32_round_integral_nearest_away( + int x, + ) { + return _bid32_round_integral_nearest_away( + x, + ); + } + + late final _bid32_round_integral_nearest_awayPtr = + _lookup>( + 'bid32_round_integral_nearest_away'); + late final _bid32_round_integral_nearest_away = + _bid32_round_integral_nearest_awayPtr.asFunction(); + + int bid32_round_integral_nearest_even( + int x, + ) { + return _bid32_round_integral_nearest_even( + x, + ); + } + + late final _bid32_round_integral_nearest_evenPtr = + _lookup>( + 'bid32_round_integral_nearest_even'); + late final _bid32_round_integral_nearest_even = + _bid32_round_integral_nearest_evenPtr.asFunction(); + + int bid32_round_integral_negative( + int x, + ) { + return _bid32_round_integral_negative( + x, + ); + } + + late final _bid32_round_integral_negativePtr = + _lookup>( + 'bid32_round_integral_negative'); + late final _bid32_round_integral_negative = + _bid32_round_integral_negativePtr.asFunction(); + + int bid32_round_integral_positive( + int x, + ) { + return _bid32_round_integral_positive( + x, + ); + } + + late final _bid32_round_integral_positivePtr = + _lookup>( + 'bid32_round_integral_positive'); + late final _bid32_round_integral_positive = + _bid32_round_integral_positivePtr.asFunction(); + + int bid32_round_integral_zero( + int x, + ) { + return _bid32_round_integral_zero( + x, + ); + } + + late final _bid32_round_integral_zeroPtr = + _lookup>( + 'bid32_round_integral_zero'); + late final _bid32_round_integral_zero = + _bid32_round_integral_zeroPtr.asFunction(); + + int bid32_sameQuantum( + int x, + int y, + ) { + return _bid32_sameQuantum( + x, + y, + ); + } + + late final _bid32_sameQuantumPtr = + _lookup>( + 'bid32_sameQuantum'); + late final _bid32_sameQuantum = + _bid32_sameQuantumPtr.asFunction(); + + int bid32_scalbln( + int x, + int n, + ) { + return _bid32_scalbln( + x, + n, + ); + } + + late final _bid32_scalblnPtr = + _lookup>( + 'bid32_scalbln'); + late final _bid32_scalbln = + _bid32_scalblnPtr.asFunction(); + + int bid32_scalbn( + int x, + int n, + ) { + return _bid32_scalbn( + x, + n, + ); + } + + late final _bid32_scalbnPtr = + _lookup>( + 'bid32_scalbn'); + late final _bid32_scalbn = + _bid32_scalbnPtr.asFunction(); + + int bid32_signaling_greater( + int x, + int y, + ) { + return _bid32_signaling_greater( + x, + y, + ); + } + + late final _bid32_signaling_greaterPtr = + _lookup>( + 'bid32_signaling_greater'); + late final _bid32_signaling_greater = + _bid32_signaling_greaterPtr.asFunction(); + + int bid32_signaling_greater_equal( + int x, + int y, + ) { + return _bid32_signaling_greater_equal( + x, + y, + ); + } + + late final _bid32_signaling_greater_equalPtr = + _lookup>( + 'bid32_signaling_greater_equal'); + late final _bid32_signaling_greater_equal = + _bid32_signaling_greater_equalPtr.asFunction(); + + int bid32_signaling_greater_unordered( + int x, + int y, + ) { + return _bid32_signaling_greater_unordered( + x, + y, + ); + } + + late final _bid32_signaling_greater_unorderedPtr = + _lookup>( + 'bid32_signaling_greater_unordered'); + late final _bid32_signaling_greater_unordered = + _bid32_signaling_greater_unorderedPtr + .asFunction(); + + int bid32_signaling_less( + int x, + int y, + ) { + return _bid32_signaling_less( + x, + y, + ); + } + + late final _bid32_signaling_lessPtr = + _lookup>( + 'bid32_signaling_less'); + late final _bid32_signaling_less = + _bid32_signaling_lessPtr.asFunction(); + + int bid32_signaling_less_equal( + int x, + int y, + ) { + return _bid32_signaling_less_equal( + x, + y, + ); + } + + late final _bid32_signaling_less_equalPtr = + _lookup>( + 'bid32_signaling_less_equal'); + late final _bid32_signaling_less_equal = + _bid32_signaling_less_equalPtr.asFunction(); + + int bid32_signaling_less_unordered( + int x, + int y, + ) { + return _bid32_signaling_less_unordered( + x, + y, + ); + } + + late final _bid32_signaling_less_unorderedPtr = + _lookup>( + 'bid32_signaling_less_unordered'); + late final _bid32_signaling_less_unordered = + _bid32_signaling_less_unorderedPtr.asFunction(); + + int bid32_signaling_not_greater( + int x, + int y, + ) { + return _bid32_signaling_not_greater( + x, + y, + ); + } + + late final _bid32_signaling_not_greaterPtr = + _lookup>( + 'bid32_signaling_not_greater'); + late final _bid32_signaling_not_greater = + _bid32_signaling_not_greaterPtr.asFunction(); + + int bid32_signaling_not_less( + int x, + int y, + ) { + return _bid32_signaling_not_less( + x, + y, + ); + } + + late final _bid32_signaling_not_lessPtr = + _lookup>( + 'bid32_signaling_not_less'); + late final _bid32_signaling_not_less = + _bid32_signaling_not_lessPtr.asFunction(); + + int bid32_sin( + int x, + ) { + return _bid32_sin( + x, + ); + } + + late final _bid32_sinPtr = + _lookup>('bid32_sin'); + late final _bid32_sin = _bid32_sinPtr.asFunction(); + + int bid32_sinh( + int x, + ) { + return _bid32_sinh( + x, + ); + } + + late final _bid32_sinhPtr = + _lookup>( + 'bid32_sinh'); + late final _bid32_sinh = _bid32_sinhPtr.asFunction(); + + int bid32_sqrt( + int x, + ) { + return _bid32_sqrt( + x, + ); + } + + late final _bid32_sqrtPtr = + _lookup>( + 'bid32_sqrt'); + late final _bid32_sqrt = _bid32_sqrtPtr.asFunction(); + + int bid32_sub( + int x, + int y, + ) { + return _bid32_sub( + x, + y, + ); + } + + late final _bid32_subPtr = + _lookup>( + 'bid32_sub'); + late final _bid32_sub = _bid32_subPtr.asFunction(); + + int bid32_tan( + int x, + ) { + return _bid32_tan( + x, + ); + } + + late final _bid32_tanPtr = + _lookup>('bid32_tan'); + late final _bid32_tan = _bid32_tanPtr.asFunction(); + + int bid32_tanh( + int x, + ) { + return _bid32_tanh( + x, + ); + } + + late final _bid32_tanhPtr = + _lookup>( + 'bid32_tanh'); + late final _bid32_tanh = _bid32_tanhPtr.asFunction(); + + int bid32_tgamma( + int x, + ) { + return _bid32_tgamma( + x, + ); + } + + late final _bid32_tgammaPtr = + _lookup>( + 'bid32_tgamma'); + late final _bid32_tgamma = _bid32_tgammaPtr.asFunction(); + + BID_UINT128 bid32_to_bid128( + int x, + ) { + return _bid32_to_bid128( + x, + ); + } + + late final _bid32_to_bid128Ptr = + _lookup>( + 'bid32_to_bid128'); + late final _bid32_to_bid128 = + _bid32_to_bid128Ptr.asFunction(); + + int bid32_to_bid64( + int x, + ) { + return _bid32_to_bid64( + x, + ); + } + + late final _bid32_to_bid64Ptr = + _lookup>( + 'bid32_to_bid64'); + late final _bid32_to_bid64 = + _bid32_to_bid64Ptr.asFunction(); + + BID_UINT128 bid32_to_binary128( + int x, + ) { + return _bid32_to_binary128( + x, + ); + } + + late final _bid32_to_binary128Ptr = + _lookup>( + 'bid32_to_binary128'); + late final _bid32_to_binary128 = + _bid32_to_binary128Ptr.asFunction(); + + double bid32_to_binary32( + int x, + ) { + return _bid32_to_binary32( + x, + ); + } + + late final _bid32_to_binary32Ptr = + _lookup>( + 'bid32_to_binary32'); + late final _bid32_to_binary32 = + _bid32_to_binary32Ptr.asFunction(); + + double bid32_to_binary64( + int x, + ) { + return _bid32_to_binary64( + x, + ); + } + + late final _bid32_to_binary64Ptr = + _lookup>( + 'bid32_to_binary64'); + late final _bid32_to_binary64 = + _bid32_to_binary64Ptr.asFunction(); + + int bid32_to_int16_ceil( + int x, + ) { + return _bid32_to_int16_ceil( + x, + ); + } + + late final _bid32_to_int16_ceilPtr = + _lookup>( + 'bid32_to_int16_ceil'); + late final _bid32_to_int16_ceil = + _bid32_to_int16_ceilPtr.asFunction(); + + int bid32_to_int16_floor( + int x, + ) { + return _bid32_to_int16_floor( + x, + ); + } + + late final _bid32_to_int16_floorPtr = + _lookup>( + 'bid32_to_int16_floor'); + late final _bid32_to_int16_floor = + _bid32_to_int16_floorPtr.asFunction(); + + int bid32_to_int16_int( + int x, + ) { + return _bid32_to_int16_int( + x, + ); + } + + late final _bid32_to_int16_intPtr = + _lookup>( + 'bid32_to_int16_int'); + late final _bid32_to_int16_int = + _bid32_to_int16_intPtr.asFunction(); + + int bid32_to_int16_rnint( + int x, + ) { + return _bid32_to_int16_rnint( + x, + ); + } + + late final _bid32_to_int16_rnintPtr = + _lookup>( + 'bid32_to_int16_rnint'); + late final _bid32_to_int16_rnint = + _bid32_to_int16_rnintPtr.asFunction(); + + int bid32_to_int16_rninta( + int x, + ) { + return _bid32_to_int16_rninta( + x, + ); + } + + late final _bid32_to_int16_rnintaPtr = + _lookup>( + 'bid32_to_int16_rninta'); + late final _bid32_to_int16_rninta = + _bid32_to_int16_rnintaPtr.asFunction(); + + int bid32_to_int16_xceil( + int x, + ) { + return _bid32_to_int16_xceil( + x, + ); + } + + late final _bid32_to_int16_xceilPtr = + _lookup>( + 'bid32_to_int16_xceil'); + late final _bid32_to_int16_xceil = + _bid32_to_int16_xceilPtr.asFunction(); + + int bid32_to_int16_xfloor( + int x, + ) { + return _bid32_to_int16_xfloor( + x, + ); + } + + late final _bid32_to_int16_xfloorPtr = + _lookup>( + 'bid32_to_int16_xfloor'); + late final _bid32_to_int16_xfloor = + _bid32_to_int16_xfloorPtr.asFunction(); + + int bid32_to_int16_xint( + int x, + ) { + return _bid32_to_int16_xint( + x, + ); + } + + late final _bid32_to_int16_xintPtr = + _lookup>( + 'bid32_to_int16_xint'); + late final _bid32_to_int16_xint = + _bid32_to_int16_xintPtr.asFunction(); + + int bid32_to_int16_xrnint( + int x, + ) { + return _bid32_to_int16_xrnint( + x, + ); + } + + late final _bid32_to_int16_xrnintPtr = + _lookup>( + 'bid32_to_int16_xrnint'); + late final _bid32_to_int16_xrnint = + _bid32_to_int16_xrnintPtr.asFunction(); + + int bid32_to_int16_xrninta( + int x, + ) { + return _bid32_to_int16_xrninta( + x, + ); + } + + late final _bid32_to_int16_xrnintaPtr = + _lookup>( + 'bid32_to_int16_xrninta'); + late final _bid32_to_int16_xrninta = + _bid32_to_int16_xrnintaPtr.asFunction(); + + int bid32_to_int32_ceil( + int x, + ) { + return _bid32_to_int32_ceil( + x, + ); + } + + late final _bid32_to_int32_ceilPtr = + _lookup>( + 'bid32_to_int32_ceil'); + late final _bid32_to_int32_ceil = + _bid32_to_int32_ceilPtr.asFunction(); + + int bid32_to_int32_floor( + int x, + ) { + return _bid32_to_int32_floor( + x, + ); + } + + late final _bid32_to_int32_floorPtr = + _lookup>( + 'bid32_to_int32_floor'); + late final _bid32_to_int32_floor = + _bid32_to_int32_floorPtr.asFunction(); + + int bid32_to_int32_int( + int x, + ) { + return _bid32_to_int32_int( + x, + ); + } + + late final _bid32_to_int32_intPtr = + _lookup>( + 'bid32_to_int32_int'); + late final _bid32_to_int32_int = + _bid32_to_int32_intPtr.asFunction(); + + int bid32_to_int32_rnint( + int x, + ) { + return _bid32_to_int32_rnint( + x, + ); + } + + late final _bid32_to_int32_rnintPtr = + _lookup>( + 'bid32_to_int32_rnint'); + late final _bid32_to_int32_rnint = + _bid32_to_int32_rnintPtr.asFunction(); + + int bid32_to_int32_rninta( + int x, + ) { + return _bid32_to_int32_rninta( + x, + ); + } + + late final _bid32_to_int32_rnintaPtr = + _lookup>( + 'bid32_to_int32_rninta'); + late final _bid32_to_int32_rninta = + _bid32_to_int32_rnintaPtr.asFunction(); + + int bid32_to_int32_xceil( + int x, + ) { + return _bid32_to_int32_xceil( + x, + ); + } + + late final _bid32_to_int32_xceilPtr = + _lookup>( + 'bid32_to_int32_xceil'); + late final _bid32_to_int32_xceil = + _bid32_to_int32_xceilPtr.asFunction(); + + int bid32_to_int32_xfloor( + int x, + ) { + return _bid32_to_int32_xfloor( + x, + ); + } + + late final _bid32_to_int32_xfloorPtr = + _lookup>( + 'bid32_to_int32_xfloor'); + late final _bid32_to_int32_xfloor = + _bid32_to_int32_xfloorPtr.asFunction(); + + int bid32_to_int32_xint( + int x, + ) { + return _bid32_to_int32_xint( + x, + ); + } + + late final _bid32_to_int32_xintPtr = + _lookup>( + 'bid32_to_int32_xint'); + late final _bid32_to_int32_xint = + _bid32_to_int32_xintPtr.asFunction(); + + int bid32_to_int32_xrnint( + int x, + ) { + return _bid32_to_int32_xrnint( + x, + ); + } + + late final _bid32_to_int32_xrnintPtr = + _lookup>( + 'bid32_to_int32_xrnint'); + late final _bid32_to_int32_xrnint = + _bid32_to_int32_xrnintPtr.asFunction(); + + int bid32_to_int32_xrninta( + int x, + ) { + return _bid32_to_int32_xrninta( + x, + ); + } + + late final _bid32_to_int32_xrnintaPtr = + _lookup>( + 'bid32_to_int32_xrninta'); + late final _bid32_to_int32_xrninta = + _bid32_to_int32_xrnintaPtr.asFunction(); + + int bid32_to_int64_ceil( + int x, + ) { + return _bid32_to_int64_ceil( + x, + ); + } + + late final _bid32_to_int64_ceilPtr = + _lookup>( + 'bid32_to_int64_ceil'); + late final _bid32_to_int64_ceil = + _bid32_to_int64_ceilPtr.asFunction(); + + int bid32_to_int64_floor( + int x, + ) { + return _bid32_to_int64_floor( + x, + ); + } + + late final _bid32_to_int64_floorPtr = + _lookup>( + 'bid32_to_int64_floor'); + late final _bid32_to_int64_floor = + _bid32_to_int64_floorPtr.asFunction(); + + int bid32_to_int64_int( + int x, + ) { + return _bid32_to_int64_int( + x, + ); + } + + late final _bid32_to_int64_intPtr = + _lookup>( + 'bid32_to_int64_int'); + late final _bid32_to_int64_int = + _bid32_to_int64_intPtr.asFunction(); + + int bid32_to_int64_rnint( + int x, + ) { + return _bid32_to_int64_rnint( + x, + ); + } + + late final _bid32_to_int64_rnintPtr = + _lookup>( + 'bid32_to_int64_rnint'); + late final _bid32_to_int64_rnint = + _bid32_to_int64_rnintPtr.asFunction(); + + int bid32_to_int64_rninta( + int x, + ) { + return _bid32_to_int64_rninta( + x, + ); + } + + late final _bid32_to_int64_rnintaPtr = + _lookup>( + 'bid32_to_int64_rninta'); + late final _bid32_to_int64_rninta = + _bid32_to_int64_rnintaPtr.asFunction(); + + int bid32_to_int64_xceil( + int x, + ) { + return _bid32_to_int64_xceil( + x, + ); + } + + late final _bid32_to_int64_xceilPtr = + _lookup>( + 'bid32_to_int64_xceil'); + late final _bid32_to_int64_xceil = + _bid32_to_int64_xceilPtr.asFunction(); + + int bid32_to_int64_xfloor( + int x, + ) { + return _bid32_to_int64_xfloor( + x, + ); + } + + late final _bid32_to_int64_xfloorPtr = + _lookup>( + 'bid32_to_int64_xfloor'); + late final _bid32_to_int64_xfloor = + _bid32_to_int64_xfloorPtr.asFunction(); + + int bid32_to_int64_xint( + int x, + ) { + return _bid32_to_int64_xint( + x, + ); + } + + late final _bid32_to_int64_xintPtr = + _lookup>( + 'bid32_to_int64_xint'); + late final _bid32_to_int64_xint = + _bid32_to_int64_xintPtr.asFunction(); + + int bid32_to_int64_xrnint( + int x, + ) { + return _bid32_to_int64_xrnint( + x, + ); + } + + late final _bid32_to_int64_xrnintPtr = + _lookup>( + 'bid32_to_int64_xrnint'); + late final _bid32_to_int64_xrnint = + _bid32_to_int64_xrnintPtr.asFunction(); + + int bid32_to_int64_xrninta( + int x, + ) { + return _bid32_to_int64_xrninta( + x, + ); + } + + late final _bid32_to_int64_xrnintaPtr = + _lookup>( + 'bid32_to_int64_xrninta'); + late final _bid32_to_int64_xrninta = + _bid32_to_int64_xrnintaPtr.asFunction(); + + int bid32_to_int8_ceil( + int x, + ) { + return _bid32_to_int8_ceil( + x, + ); + } + + late final _bid32_to_int8_ceilPtr = + _lookup>( + 'bid32_to_int8_ceil'); + late final _bid32_to_int8_ceil = + _bid32_to_int8_ceilPtr.asFunction(); + + int bid32_to_int8_floor( + int x, + ) { + return _bid32_to_int8_floor( + x, + ); + } + + late final _bid32_to_int8_floorPtr = + _lookup>( + 'bid32_to_int8_floor'); + late final _bid32_to_int8_floor = + _bid32_to_int8_floorPtr.asFunction(); + + int bid32_to_int8_int( + int x, + ) { + return _bid32_to_int8_int( + x, + ); + } + + late final _bid32_to_int8_intPtr = + _lookup>( + 'bid32_to_int8_int'); + late final _bid32_to_int8_int = + _bid32_to_int8_intPtr.asFunction(); + + int bid32_to_int8_rnint( + int x, + ) { + return _bid32_to_int8_rnint( + x, + ); + } + + late final _bid32_to_int8_rnintPtr = + _lookup>( + 'bid32_to_int8_rnint'); + late final _bid32_to_int8_rnint = + _bid32_to_int8_rnintPtr.asFunction(); + + int bid32_to_int8_rninta( + int x, + ) { + return _bid32_to_int8_rninta( + x, + ); + } + + late final _bid32_to_int8_rnintaPtr = + _lookup>( + 'bid32_to_int8_rninta'); + late final _bid32_to_int8_rninta = + _bid32_to_int8_rnintaPtr.asFunction(); + + int bid32_to_int8_xceil( + int x, + ) { + return _bid32_to_int8_xceil( + x, + ); + } + + late final _bid32_to_int8_xceilPtr = + _lookup>( + 'bid32_to_int8_xceil'); + late final _bid32_to_int8_xceil = + _bid32_to_int8_xceilPtr.asFunction(); + + int bid32_to_int8_xfloor( + int x, + ) { + return _bid32_to_int8_xfloor( + x, + ); + } + + late final _bid32_to_int8_xfloorPtr = + _lookup>( + 'bid32_to_int8_xfloor'); + late final _bid32_to_int8_xfloor = + _bid32_to_int8_xfloorPtr.asFunction(); + + int bid32_to_int8_xint( + int x, + ) { + return _bid32_to_int8_xint( + x, + ); + } + + late final _bid32_to_int8_xintPtr = + _lookup>( + 'bid32_to_int8_xint'); + late final _bid32_to_int8_xint = + _bid32_to_int8_xintPtr.asFunction(); + + int bid32_to_int8_xrnint( + int x, + ) { + return _bid32_to_int8_xrnint( + x, + ); + } + + late final _bid32_to_int8_xrnintPtr = + _lookup>( + 'bid32_to_int8_xrnint'); + late final _bid32_to_int8_xrnint = + _bid32_to_int8_xrnintPtr.asFunction(); + + int bid32_to_int8_xrninta( + int x, + ) { + return _bid32_to_int8_xrninta( + x, + ); + } + + late final _bid32_to_int8_xrnintaPtr = + _lookup>( + 'bid32_to_int8_xrninta'); + late final _bid32_to_int8_xrninta = + _bid32_to_int8_xrnintaPtr.asFunction(); + + void bid32_to_string( + ffi.Pointer ps, + int x, + ) { + return _bid32_to_string( + ps, + x, + ); + } + + late final _bid32_to_stringPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, BID_UINT32)>>('bid32_to_string'); + late final _bid32_to_string = _bid32_to_stringPtr + .asFunction, int)>(); + + int bid32_to_uint16_ceil( + int x, + ) { + return _bid32_to_uint16_ceil( + x, + ); + } + + late final _bid32_to_uint16_ceilPtr = + _lookup>( + 'bid32_to_uint16_ceil'); + late final _bid32_to_uint16_ceil = + _bid32_to_uint16_ceilPtr.asFunction(); + + int bid32_to_uint16_floor( + int x, + ) { + return _bid32_to_uint16_floor( + x, + ); + } + + late final _bid32_to_uint16_floorPtr = + _lookup>( + 'bid32_to_uint16_floor'); + late final _bid32_to_uint16_floor = + _bid32_to_uint16_floorPtr.asFunction(); + + int bid32_to_uint16_int( + int x, + ) { + return _bid32_to_uint16_int( + x, + ); + } + + late final _bid32_to_uint16_intPtr = + _lookup>( + 'bid32_to_uint16_int'); + late final _bid32_to_uint16_int = + _bid32_to_uint16_intPtr.asFunction(); + + int bid32_to_uint16_rnint( + int x, + ) { + return _bid32_to_uint16_rnint( + x, + ); + } + + late final _bid32_to_uint16_rnintPtr = + _lookup>( + 'bid32_to_uint16_rnint'); + late final _bid32_to_uint16_rnint = + _bid32_to_uint16_rnintPtr.asFunction(); + + int bid32_to_uint16_rninta( + int x, + ) { + return _bid32_to_uint16_rninta( + x, + ); + } + + late final _bid32_to_uint16_rnintaPtr = + _lookup>( + 'bid32_to_uint16_rninta'); + late final _bid32_to_uint16_rninta = + _bid32_to_uint16_rnintaPtr.asFunction(); + + int bid32_to_uint16_xceil( + int x, + ) { + return _bid32_to_uint16_xceil( + x, + ); + } + + late final _bid32_to_uint16_xceilPtr = + _lookup>( + 'bid32_to_uint16_xceil'); + late final _bid32_to_uint16_xceil = + _bid32_to_uint16_xceilPtr.asFunction(); + + int bid32_to_uint16_xfloor( + int x, + ) { + return _bid32_to_uint16_xfloor( + x, + ); + } + + late final _bid32_to_uint16_xfloorPtr = + _lookup>( + 'bid32_to_uint16_xfloor'); + late final _bid32_to_uint16_xfloor = + _bid32_to_uint16_xfloorPtr.asFunction(); + + int bid32_to_uint16_xint( + int x, + ) { + return _bid32_to_uint16_xint( + x, + ); + } + + late final _bid32_to_uint16_xintPtr = + _lookup>( + 'bid32_to_uint16_xint'); + late final _bid32_to_uint16_xint = + _bid32_to_uint16_xintPtr.asFunction(); + + int bid32_to_uint16_xrnint( + int x, + ) { + return _bid32_to_uint16_xrnint( + x, + ); + } + + late final _bid32_to_uint16_xrnintPtr = + _lookup>( + 'bid32_to_uint16_xrnint'); + late final _bid32_to_uint16_xrnint = + _bid32_to_uint16_xrnintPtr.asFunction(); + + int bid32_to_uint16_xrninta( + int x, + ) { + return _bid32_to_uint16_xrninta( + x, + ); + } + + late final _bid32_to_uint16_xrnintaPtr = + _lookup>( + 'bid32_to_uint16_xrninta'); + late final _bid32_to_uint16_xrninta = + _bid32_to_uint16_xrnintaPtr.asFunction(); + + int bid32_to_uint32_ceil( + int x, + ) { + return _bid32_to_uint32_ceil( + x, + ); + } + + late final _bid32_to_uint32_ceilPtr = + _lookup>( + 'bid32_to_uint32_ceil'); + late final _bid32_to_uint32_ceil = + _bid32_to_uint32_ceilPtr.asFunction(); + + int bid32_to_uint32_floor( + int x, + ) { + return _bid32_to_uint32_floor( + x, + ); + } + + late final _bid32_to_uint32_floorPtr = + _lookup>( + 'bid32_to_uint32_floor'); + late final _bid32_to_uint32_floor = + _bid32_to_uint32_floorPtr.asFunction(); + + int bid32_to_uint32_int( + int x, + ) { + return _bid32_to_uint32_int( + x, + ); + } + + late final _bid32_to_uint32_intPtr = + _lookup>( + 'bid32_to_uint32_int'); + late final _bid32_to_uint32_int = + _bid32_to_uint32_intPtr.asFunction(); + + int bid32_to_uint32_rnint( + int x, + ) { + return _bid32_to_uint32_rnint( + x, + ); + } + + late final _bid32_to_uint32_rnintPtr = + _lookup>( + 'bid32_to_uint32_rnint'); + late final _bid32_to_uint32_rnint = + _bid32_to_uint32_rnintPtr.asFunction(); + + int bid32_to_uint32_rninta( + int x, + ) { + return _bid32_to_uint32_rninta( + x, + ); + } + + late final _bid32_to_uint32_rnintaPtr = + _lookup>( + 'bid32_to_uint32_rninta'); + late final _bid32_to_uint32_rninta = + _bid32_to_uint32_rnintaPtr.asFunction(); + + int bid32_to_uint32_xceil( + int x, + ) { + return _bid32_to_uint32_xceil( + x, + ); + } + + late final _bid32_to_uint32_xceilPtr = + _lookup>( + 'bid32_to_uint32_xceil'); + late final _bid32_to_uint32_xceil = + _bid32_to_uint32_xceilPtr.asFunction(); + + int bid32_to_uint32_xfloor( + int x, + ) { + return _bid32_to_uint32_xfloor( + x, + ); + } + + late final _bid32_to_uint32_xfloorPtr = + _lookup>( + 'bid32_to_uint32_xfloor'); + late final _bid32_to_uint32_xfloor = + _bid32_to_uint32_xfloorPtr.asFunction(); + + int bid32_to_uint32_xint( + int x, + ) { + return _bid32_to_uint32_xint( + x, + ); + } + + late final _bid32_to_uint32_xintPtr = + _lookup>( + 'bid32_to_uint32_xint'); + late final _bid32_to_uint32_xint = + _bid32_to_uint32_xintPtr.asFunction(); + + int bid32_to_uint32_xrnint( + int x, + ) { + return _bid32_to_uint32_xrnint( + x, + ); + } + + late final _bid32_to_uint32_xrnintPtr = + _lookup>( + 'bid32_to_uint32_xrnint'); + late final _bid32_to_uint32_xrnint = + _bid32_to_uint32_xrnintPtr.asFunction(); + + int bid32_to_uint32_xrninta( + int x, + ) { + return _bid32_to_uint32_xrninta( + x, + ); + } + + late final _bid32_to_uint32_xrnintaPtr = + _lookup>( + 'bid32_to_uint32_xrninta'); + late final _bid32_to_uint32_xrninta = + _bid32_to_uint32_xrnintaPtr.asFunction(); + + int bid32_to_uint64_ceil( + int x, + ) { + return _bid32_to_uint64_ceil( + x, + ); + } + + late final _bid32_to_uint64_ceilPtr = + _lookup>( + 'bid32_to_uint64_ceil'); + late final _bid32_to_uint64_ceil = + _bid32_to_uint64_ceilPtr.asFunction(); + + int bid32_to_uint64_floor( + int x, + ) { + return _bid32_to_uint64_floor( + x, + ); + } + + late final _bid32_to_uint64_floorPtr = + _lookup>( + 'bid32_to_uint64_floor'); + late final _bid32_to_uint64_floor = + _bid32_to_uint64_floorPtr.asFunction(); + + int bid32_to_uint64_int( + int x, + ) { + return _bid32_to_uint64_int( + x, + ); + } + + late final _bid32_to_uint64_intPtr = + _lookup>( + 'bid32_to_uint64_int'); + late final _bid32_to_uint64_int = + _bid32_to_uint64_intPtr.asFunction(); + + int bid32_to_uint64_rnint( + int x, + ) { + return _bid32_to_uint64_rnint( + x, + ); + } + + late final _bid32_to_uint64_rnintPtr = + _lookup>( + 'bid32_to_uint64_rnint'); + late final _bid32_to_uint64_rnint = + _bid32_to_uint64_rnintPtr.asFunction(); + + int bid32_to_uint64_rninta( + int x, + ) { + return _bid32_to_uint64_rninta( + x, + ); + } + + late final _bid32_to_uint64_rnintaPtr = + _lookup>( + 'bid32_to_uint64_rninta'); + late final _bid32_to_uint64_rninta = + _bid32_to_uint64_rnintaPtr.asFunction(); + + int bid32_to_uint64_xceil( + int x, + ) { + return _bid32_to_uint64_xceil( + x, + ); + } + + late final _bid32_to_uint64_xceilPtr = + _lookup>( + 'bid32_to_uint64_xceil'); + late final _bid32_to_uint64_xceil = + _bid32_to_uint64_xceilPtr.asFunction(); + + int bid32_to_uint64_xfloor( + int x, + ) { + return _bid32_to_uint64_xfloor( + x, + ); + } + + late final _bid32_to_uint64_xfloorPtr = + _lookup>( + 'bid32_to_uint64_xfloor'); + late final _bid32_to_uint64_xfloor = + _bid32_to_uint64_xfloorPtr.asFunction(); + + int bid32_to_uint64_xint( + int x, + ) { + return _bid32_to_uint64_xint( + x, + ); + } + + late final _bid32_to_uint64_xintPtr = + _lookup>( + 'bid32_to_uint64_xint'); + late final _bid32_to_uint64_xint = + _bid32_to_uint64_xintPtr.asFunction(); + + int bid32_to_uint64_xrnint( + int x, + ) { + return _bid32_to_uint64_xrnint( + x, + ); + } + + late final _bid32_to_uint64_xrnintPtr = + _lookup>( + 'bid32_to_uint64_xrnint'); + late final _bid32_to_uint64_xrnint = + _bid32_to_uint64_xrnintPtr.asFunction(); + + int bid32_to_uint64_xrninta( + int x, + ) { + return _bid32_to_uint64_xrninta( + x, + ); + } + + late final _bid32_to_uint64_xrnintaPtr = + _lookup>( + 'bid32_to_uint64_xrninta'); + late final _bid32_to_uint64_xrninta = + _bid32_to_uint64_xrnintaPtr.asFunction(); + + int bid32_to_uint8_ceil( + int x, + ) { + return _bid32_to_uint8_ceil( + x, + ); + } + + late final _bid32_to_uint8_ceilPtr = + _lookup>( + 'bid32_to_uint8_ceil'); + late final _bid32_to_uint8_ceil = + _bid32_to_uint8_ceilPtr.asFunction(); + + int bid32_to_uint8_floor( + int x, + ) { + return _bid32_to_uint8_floor( + x, + ); + } + + late final _bid32_to_uint8_floorPtr = + _lookup>( + 'bid32_to_uint8_floor'); + late final _bid32_to_uint8_floor = + _bid32_to_uint8_floorPtr.asFunction(); + + int bid32_to_uint8_int( + int x, + ) { + return _bid32_to_uint8_int( + x, + ); + } + + late final _bid32_to_uint8_intPtr = + _lookup>( + 'bid32_to_uint8_int'); + late final _bid32_to_uint8_int = + _bid32_to_uint8_intPtr.asFunction(); + + int bid32_to_uint8_rnint( + int x, + ) { + return _bid32_to_uint8_rnint( + x, + ); + } + + late final _bid32_to_uint8_rnintPtr = + _lookup>( + 'bid32_to_uint8_rnint'); + late final _bid32_to_uint8_rnint = + _bid32_to_uint8_rnintPtr.asFunction(); + + int bid32_to_uint8_rninta( + int x, + ) { + return _bid32_to_uint8_rninta( + x, + ); + } + + late final _bid32_to_uint8_rnintaPtr = + _lookup>( + 'bid32_to_uint8_rninta'); + late final _bid32_to_uint8_rninta = + _bid32_to_uint8_rnintaPtr.asFunction(); + + int bid32_to_uint8_xceil( + int x, + ) { + return _bid32_to_uint8_xceil( + x, + ); + } + + late final _bid32_to_uint8_xceilPtr = + _lookup>( + 'bid32_to_uint8_xceil'); + late final _bid32_to_uint8_xceil = + _bid32_to_uint8_xceilPtr.asFunction(); + + int bid32_to_uint8_xfloor( + int x, + ) { + return _bid32_to_uint8_xfloor( + x, + ); + } + + late final _bid32_to_uint8_xfloorPtr = + _lookup>( + 'bid32_to_uint8_xfloor'); + late final _bid32_to_uint8_xfloor = + _bid32_to_uint8_xfloorPtr.asFunction(); + + int bid32_to_uint8_xint( + int x, + ) { + return _bid32_to_uint8_xint( + x, + ); + } + + late final _bid32_to_uint8_xintPtr = + _lookup>( + 'bid32_to_uint8_xint'); + late final _bid32_to_uint8_xint = + _bid32_to_uint8_xintPtr.asFunction(); + + int bid32_to_uint8_xrnint( + int x, + ) { + return _bid32_to_uint8_xrnint( + x, + ); + } + + late final _bid32_to_uint8_xrnintPtr = + _lookup>( + 'bid32_to_uint8_xrnint'); + late final _bid32_to_uint8_xrnint = + _bid32_to_uint8_xrnintPtr.asFunction(); + + int bid32_to_uint8_xrninta( + int x, + ) { + return _bid32_to_uint8_xrninta( + x, + ); + } + + late final _bid32_to_uint8_xrnintaPtr = + _lookup>( + 'bid32_to_uint8_xrninta'); + late final _bid32_to_uint8_xrninta = + _bid32_to_uint8_xrnintaPtr.asFunction(); + + int bid32_totalOrder( + int x, + int y, + ) { + return _bid32_totalOrder( + x, + y, + ); + } + + late final _bid32_totalOrderPtr = + _lookup>( + 'bid32_totalOrder'); + late final _bid32_totalOrder = + _bid32_totalOrderPtr.asFunction(); + + int bid32_totalOrderMag( + int x, + int y, + ) { + return _bid32_totalOrderMag( + x, + y, + ); + } + + late final _bid32_totalOrderMagPtr = + _lookup>( + 'bid32_totalOrderMag'); + late final _bid32_totalOrderMag = + _bid32_totalOrderMagPtr.asFunction(); + + int bid64_abs( + int x, + ) { + return _bid64_abs( + x, + ); + } + + late final _bid64_absPtr = + _lookup>('bid64_abs'); + late final _bid64_abs = _bid64_absPtr.asFunction(); + + int bid64_acos( + int x, + ) { + return _bid64_acos( + x, + ); + } + + late final _bid64_acosPtr = + _lookup>( + 'bid64_acos'); + late final _bid64_acos = _bid64_acosPtr.asFunction(); + + int bid64_acosh( + int x, + ) { + return _bid64_acosh( + x, + ); + } + + late final _bid64_acoshPtr = + _lookup>( + 'bid64_acosh'); + late final _bid64_acosh = _bid64_acoshPtr.asFunction(); + + int bid64_add( + int x, + int y, + ) { + return _bid64_add( + x, + y, + ); + } + + late final _bid64_addPtr = + _lookup>( + 'bid64_add'); + late final _bid64_add = _bid64_addPtr.asFunction(); + + int bid64_asin( + int x, + ) { + return _bid64_asin( + x, + ); + } + + late final _bid64_asinPtr = + _lookup>( + 'bid64_asin'); + late final _bid64_asin = _bid64_asinPtr.asFunction(); + + int bid64_asinh( + int x, + ) { + return _bid64_asinh( + x, + ); + } + + late final _bid64_asinhPtr = + _lookup>( + 'bid64_asinh'); + late final _bid64_asinh = _bid64_asinhPtr.asFunction(); + + int bid64_atan( + int x, + ) { + return _bid64_atan( + x, + ); + } + + late final _bid64_atanPtr = + _lookup>( + 'bid64_atan'); + late final _bid64_atan = _bid64_atanPtr.asFunction(); + + int bid64_atan2( + int x, + int y, + ) { + return _bid64_atan2( + x, + y, + ); + } + + late final _bid64_atan2Ptr = + _lookup>( + 'bid64_atan2'); + late final _bid64_atan2 = + _bid64_atan2Ptr.asFunction(); + + int bid64_atanh( + int x, + ) { + return _bid64_atanh( + x, + ); + } + + late final _bid64_atanhPtr = + _lookup>( + 'bid64_atanh'); + late final _bid64_atanh = _bid64_atanhPtr.asFunction(); + + int bid64_cbrt( + int x, + ) { + return _bid64_cbrt( + x, + ); + } + + late final _bid64_cbrtPtr = + _lookup>( + 'bid64_cbrt'); + late final _bid64_cbrt = _bid64_cbrtPtr.asFunction(); + + int bid64_class( + int x, + ) { + return _bid64_class( + x, + ); + } + + late final _bid64_classPtr = + _lookup>('bid64_class'); + late final _bid64_class = _bid64_classPtr.asFunction(); + + int bid64_copy( + int x, + ) { + return _bid64_copy( + x, + ); + } + + late final _bid64_copyPtr = + _lookup>( + 'bid64_copy'); + late final _bid64_copy = _bid64_copyPtr.asFunction(); + + int bid64_copySign( + int x, + int y, + ) { + return _bid64_copySign( + x, + y, + ); + } + + late final _bid64_copySignPtr = + _lookup>( + 'bid64_copySign'); + late final _bid64_copySign = + _bid64_copySignPtr.asFunction(); + + int bid64_cos( + int x, + ) { + return _bid64_cos( + x, + ); + } + + late final _bid64_cosPtr = + _lookup>('bid64_cos'); + late final _bid64_cos = _bid64_cosPtr.asFunction(); + + int bid64_cosh( + int x, + ) { + return _bid64_cosh( + x, + ); + } + + late final _bid64_coshPtr = + _lookup>( + 'bid64_cosh'); + late final _bid64_cosh = _bid64_coshPtr.asFunction(); + + int bid64_div( + int x, + int y, + ) { + return _bid64_div( + x, + y, + ); + } + + late final _bid64_divPtr = + _lookup>( + 'bid64_div'); + late final _bid64_div = _bid64_divPtr.asFunction(); + + int bid64_erf( + int x, + ) { + return _bid64_erf( + x, + ); + } + + late final _bid64_erfPtr = + _lookup>('bid64_erf'); + late final _bid64_erf = _bid64_erfPtr.asFunction(); + + int bid64_erfc( + int x, + ) { + return _bid64_erfc( + x, + ); + } + + late final _bid64_erfcPtr = + _lookup>( + 'bid64_erfc'); + late final _bid64_erfc = _bid64_erfcPtr.asFunction(); + + int bid64_exp( + int x, + ) { + return _bid64_exp( + x, + ); + } + + late final _bid64_expPtr = + _lookup>('bid64_exp'); + late final _bid64_exp = _bid64_expPtr.asFunction(); + + int bid64_exp10( + int x, + ) { + return _bid64_exp10( + x, + ); + } + + late final _bid64_exp10Ptr = + _lookup>( + 'bid64_exp10'); + late final _bid64_exp10 = _bid64_exp10Ptr.asFunction(); + + int bid64_exp2( + int x, + ) { + return _bid64_exp2( + x, + ); + } + + late final _bid64_exp2Ptr = + _lookup>( + 'bid64_exp2'); + late final _bid64_exp2 = _bid64_exp2Ptr.asFunction(); + + int bid64_expm1( + int x, + ) { + return _bid64_expm1( + x, + ); + } + + late final _bid64_expm1Ptr = + _lookup>( + 'bid64_expm1'); + late final _bid64_expm1 = _bid64_expm1Ptr.asFunction(); + + int bid64_fdim( + int x, + int y, + ) { + return _bid64_fdim( + x, + y, + ); + } + + late final _bid64_fdimPtr = + _lookup>( + 'bid64_fdim'); + late final _bid64_fdim = _bid64_fdimPtr.asFunction(); + + int bid64_fma( + int x, + int y, + int z, + ) { + return _bid64_fma( + x, + y, + z, + ); + } + + late final _bid64_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT64, BID_UINT64, BID_UINT64)>>('bid64_fma'); + late final _bid64_fma = + _bid64_fmaPtr.asFunction(); + + int bid64_fmod( + int x, + int y, + ) { + return _bid64_fmod( + x, + y, + ); + } + + late final _bid64_fmodPtr = + _lookup>( + 'bid64_fmod'); + late final _bid64_fmod = _bid64_fmodPtr.asFunction(); + + int bid64_frexp( + int x, + ffi.Pointer exp, + ) { + return _bid64_frexp( + x, + exp, + ); + } + + late final _bid64_frexpPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT64, ffi.Pointer)>>('bid64_frexp'); + late final _bid64_frexp = + _bid64_frexpPtr.asFunction)>(); + + int bid64_from_int32( + int x, + ) { + return _bid64_from_int32( + x, + ); + } + + late final _bid64_from_int32Ptr = + _lookup>( + 'bid64_from_int32'); + late final _bid64_from_int32 = + _bid64_from_int32Ptr.asFunction(); + + int bid64_from_int64( + int x, + ) { + return _bid64_from_int64( + x, + ); + } + + late final _bid64_from_int64Ptr = + _lookup>( + 'bid64_from_int64'); + late final _bid64_from_int64 = + _bid64_from_int64Ptr.asFunction(); + + int bid64_from_string( + ffi.Pointer ps, + ) { + return _bid64_from_string( + ps, + ); + } + + late final _bid64_from_stringPtr = + _lookup)>>( + 'bid64_from_string'); + late final _bid64_from_string = + _bid64_from_stringPtr.asFunction)>(); + + int bid64_from_uint32( + int x, + ) { + return _bid64_from_uint32( + x, + ); + } + + late final _bid64_from_uint32Ptr = + _lookup>( + 'bid64_from_uint32'); + late final _bid64_from_uint32 = + _bid64_from_uint32Ptr.asFunction(); + + int bid64_from_uint64( + int _RND_MODE_PARAM, + ) { + return _bid64_from_uint64( + _RND_MODE_PARAM, + ); + } + + late final _bid64_from_uint64Ptr = + _lookup>( + 'bid64_from_uint64'); + late final _bid64_from_uint64 = + _bid64_from_uint64Ptr.asFunction(); + + int bid64_hypot( + int x, + int y, + ) { + return _bid64_hypot( + x, + y, + ); + } + + late final _bid64_hypotPtr = + _lookup>( + 'bid64_hypot'); + late final _bid64_hypot = + _bid64_hypotPtr.asFunction(); + + int bid64_ilogb( + int x, + ) { + return _bid64_ilogb( + x, + ); + } + + late final _bid64_ilogbPtr = + _lookup>('bid64_ilogb'); + late final _bid64_ilogb = _bid64_ilogbPtr.asFunction(); + + int bid64_inf() { + return _bid64_inf(); + } + + late final _bid64_infPtr = + _lookup>('bid64_inf'); + late final _bid64_inf = _bid64_infPtr.asFunction(); + + int bid64_isCanonical( + int x, + ) { + return _bid64_isCanonical( + x, + ); + } + + late final _bid64_isCanonicalPtr = + _lookup>( + 'bid64_isCanonical'); + late final _bid64_isCanonical = + _bid64_isCanonicalPtr.asFunction(); + + int bid64_isFinite( + int x, + ) { + return _bid64_isFinite( + x, + ); + } + + late final _bid64_isFinitePtr = + _lookup>( + 'bid64_isFinite'); + late final _bid64_isFinite = + _bid64_isFinitePtr.asFunction(); + + int bid64_isInf( + int x, + ) { + return _bid64_isInf( + x, + ); + } + + late final _bid64_isInfPtr = + _lookup>('bid64_isInf'); + late final _bid64_isInf = _bid64_isInfPtr.asFunction(); + + int bid64_isNaN( + int x, + ) { + return _bid64_isNaN( + x, + ); + } + + late final _bid64_isNaNPtr = + _lookup>('bid64_isNaN'); + late final _bid64_isNaN = _bid64_isNaNPtr.asFunction(); + + int bid64_isNormal( + int x, + ) { + return _bid64_isNormal( + x, + ); + } + + late final _bid64_isNormalPtr = + _lookup>( + 'bid64_isNormal'); + late final _bid64_isNormal = + _bid64_isNormalPtr.asFunction(); + + int bid64_isSignaling( + int x, + ) { + return _bid64_isSignaling( + x, + ); + } + + late final _bid64_isSignalingPtr = + _lookup>( + 'bid64_isSignaling'); + late final _bid64_isSignaling = + _bid64_isSignalingPtr.asFunction(); + + int bid64_isSigned( + int x, + ) { + return _bid64_isSigned( + x, + ); + } + + late final _bid64_isSignedPtr = + _lookup>( + 'bid64_isSigned'); + late final _bid64_isSigned = + _bid64_isSignedPtr.asFunction(); + + int bid64_isSubnormal( + int x, + ) { + return _bid64_isSubnormal( + x, + ); + } + + late final _bid64_isSubnormalPtr = + _lookup>( + 'bid64_isSubnormal'); + late final _bid64_isSubnormal = + _bid64_isSubnormalPtr.asFunction(); + + int bid64_isZero( + int x, + ) { + return _bid64_isZero( + x, + ); + } + + late final _bid64_isZeroPtr = + _lookup>('bid64_isZero'); + late final _bid64_isZero = _bid64_isZeroPtr.asFunction(); + + int bid64_ldexp( + int x, + int n, + ) { + return _bid64_ldexp( + x, + n, + ); + } + + late final _bid64_ldexpPtr = + _lookup>( + 'bid64_ldexp'); + late final _bid64_ldexp = + _bid64_ldexpPtr.asFunction(); + + int bid64_lgamma( + int x, + ) { + return _bid64_lgamma( + x, + ); + } + + late final _bid64_lgammaPtr = + _lookup>( + 'bid64_lgamma'); + late final _bid64_lgamma = _bid64_lgammaPtr.asFunction(); + + int bid64_llquantexp( + int x, + ) { + return _bid64_llquantexp( + x, + ); + } + + late final _bid64_llquantexpPtr = + _lookup>( + 'bid64_llquantexp'); + late final _bid64_llquantexp = + _bid64_llquantexpPtr.asFunction(); + + int bid64_llrint( + int x, + ) { + return _bid64_llrint( + x, + ); + } + + late final _bid64_llrintPtr = + _lookup>( + 'bid64_llrint'); + late final _bid64_llrint = _bid64_llrintPtr.asFunction(); + + int bid64_llround( + int x, + ) { + return _bid64_llround( + x, + ); + } + + late final _bid64_llroundPtr = + _lookup>( + 'bid64_llround'); + late final _bid64_llround = _bid64_llroundPtr.asFunction(); + + int bid64_log( + int x, + ) { + return _bid64_log( + x, + ); + } + + late final _bid64_logPtr = + _lookup>('bid64_log'); + late final _bid64_log = _bid64_logPtr.asFunction(); + + int bid64_log10( + int x, + ) { + return _bid64_log10( + x, + ); + } + + late final _bid64_log10Ptr = + _lookup>( + 'bid64_log10'); + late final _bid64_log10 = _bid64_log10Ptr.asFunction(); + + int bid64_log1p( + int x, + ) { + return _bid64_log1p( + x, + ); + } + + late final _bid64_log1pPtr = + _lookup>( + 'bid64_log1p'); + late final _bid64_log1p = _bid64_log1pPtr.asFunction(); + + int bid64_log2( + int x, + ) { + return _bid64_log2( + x, + ); + } + + late final _bid64_log2Ptr = + _lookup>( + 'bid64_log2'); + late final _bid64_log2 = _bid64_log2Ptr.asFunction(); + + int bid64_logb( + int x, + ) { + return _bid64_logb( + x, + ); + } + + late final _bid64_logbPtr = + _lookup>( + 'bid64_logb'); + late final _bid64_logb = _bid64_logbPtr.asFunction(); + + int bid64_lrint( + int x, + ) { + return _bid64_lrint( + x, + ); + } + + late final _bid64_lrintPtr = + _lookup>('bid64_lrint'); + late final _bid64_lrint = _bid64_lrintPtr.asFunction(); + + int bid64_lround( + int x, + ) { + return _bid64_lround( + x, + ); + } + + late final _bid64_lroundPtr = + _lookup>( + 'bid64_lround'); + late final _bid64_lround = _bid64_lroundPtr.asFunction(); + + int bid64_maxnum( + int x, + int y, + ) { + return _bid64_maxnum( + x, + y, + ); + } + + late final _bid64_maxnumPtr = + _lookup>( + 'bid64_maxnum'); + late final _bid64_maxnum = + _bid64_maxnumPtr.asFunction(); + + int bid64_maxnum_mag( + int x, + int y, + ) { + return _bid64_maxnum_mag( + x, + y, + ); + } + + late final _bid64_maxnum_magPtr = + _lookup>( + 'bid64_maxnum_mag'); + late final _bid64_maxnum_mag = + _bid64_maxnum_magPtr.asFunction(); + + int bid64_minnum( + int x, + int y, + ) { + return _bid64_minnum( + x, + y, + ); + } + + late final _bid64_minnumPtr = + _lookup>( + 'bid64_minnum'); + late final _bid64_minnum = + _bid64_minnumPtr.asFunction(); + + int bid64_minnum_mag( + int x, + int y, + ) { + return _bid64_minnum_mag( + x, + y, + ); + } + + late final _bid64_minnum_magPtr = + _lookup>( + 'bid64_minnum_mag'); + late final _bid64_minnum_mag = + _bid64_minnum_magPtr.asFunction(); + + int bid64_modf( + int x, + ffi.Pointer y, + ) { + return _bid64_modf( + x, + y, + ); + } + + late final _bid64_modfPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT64, ffi.Pointer)>>('bid64_modf'); + late final _bid64_modf = + _bid64_modfPtr.asFunction)>(); + + int bid64_mul( + int x, + int y, + ) { + return _bid64_mul( + x, + y, + ); + } + + late final _bid64_mulPtr = + _lookup>( + 'bid64_mul'); + late final _bid64_mul = _bid64_mulPtr.asFunction(); + + int bid64_nan( + ffi.Pointer tagp, + ) { + return _bid64_nan( + tagp, + ); + } + + late final _bid64_nanPtr = + _lookup)>>( + 'bid64_nan'); + late final _bid64_nan = + _bid64_nanPtr.asFunction)>(); + + int bid64_nearbyint( + int x, + ) { + return _bid64_nearbyint( + x, + ); + } + + late final _bid64_nearbyintPtr = + _lookup>( + 'bid64_nearbyint'); + late final _bid64_nearbyint = + _bid64_nearbyintPtr.asFunction(); + + int bid64_negate( + int x, + ) { + return _bid64_negate( + x, + ); + } + + late final _bid64_negatePtr = + _lookup>( + 'bid64_negate'); + late final _bid64_negate = _bid64_negatePtr.asFunction(); + + int bid64_nextafter( + int x, + int y, + ) { + return _bid64_nextafter( + x, + y, + ); + } + + late final _bid64_nextafterPtr = + _lookup>( + 'bid64_nextafter'); + late final _bid64_nextafter = + _bid64_nextafterPtr.asFunction(); + + int bid64_nextdown( + int x, + ) { + return _bid64_nextdown( + x, + ); + } + + late final _bid64_nextdownPtr = + _lookup>( + 'bid64_nextdown'); + late final _bid64_nextdown = + _bid64_nextdownPtr.asFunction(); + + int bid64_nexttoward( + int x, + BID_UINT128 y, + ) { + return _bid64_nexttoward( + x, + y, + ); + } + + late final _bid64_nexttowardPtr = + _lookup>( + 'bid64_nexttoward'); + late final _bid64_nexttoward = + _bid64_nexttowardPtr.asFunction(); + + int bid64_nextup( + int x, + ) { + return _bid64_nextup( + x, + ); + } + + late final _bid64_nextupPtr = + _lookup>( + 'bid64_nextup'); + late final _bid64_nextup = _bid64_nextupPtr.asFunction(); + + int bid64_pow( + int x, + int y, + ) { + return _bid64_pow( + x, + y, + ); + } + + late final _bid64_powPtr = + _lookup>( + 'bid64_pow'); + late final _bid64_pow = _bid64_powPtr.asFunction(); + + int bid64_quantexp( + int x, + ) { + return _bid64_quantexp( + x, + ); + } + + late final _bid64_quantexpPtr = + _lookup>( + 'bid64_quantexp'); + late final _bid64_quantexp = + _bid64_quantexpPtr.asFunction(); + + int bid64_quantize( + int x, + int y, + ) { + return _bid64_quantize( + x, + y, + ); + } + + late final _bid64_quantizePtr = + _lookup>( + 'bid64_quantize'); + late final _bid64_quantize = + _bid64_quantizePtr.asFunction(); + + int bid64_quantum( + int x, + ) { + return _bid64_quantum( + x, + ); + } + + late final _bid64_quantumPtr = + _lookup>( + 'bid64_quantum'); + late final _bid64_quantum = _bid64_quantumPtr.asFunction(); + + int bid64_quiet_equal( + int x, + int y, + ) { + return _bid64_quiet_equal( + x, + y, + ); + } + + late final _bid64_quiet_equalPtr = + _lookup>( + 'bid64_quiet_equal'); + late final _bid64_quiet_equal = + _bid64_quiet_equalPtr.asFunction(); + + int bid64_quiet_greater( + int x, + int y, + ) { + return _bid64_quiet_greater( + x, + y, + ); + } + + late final _bid64_quiet_greaterPtr = + _lookup>( + 'bid64_quiet_greater'); + late final _bid64_quiet_greater = + _bid64_quiet_greaterPtr.asFunction(); + + int bid64_quiet_greater_equal( + int x, + int y, + ) { + return _bid64_quiet_greater_equal( + x, + y, + ); + } + + late final _bid64_quiet_greater_equalPtr = + _lookup>( + 'bid64_quiet_greater_equal'); + late final _bid64_quiet_greater_equal = + _bid64_quiet_greater_equalPtr.asFunction(); + + int bid64_quiet_greater_unordered( + int x, + int y, + ) { + return _bid64_quiet_greater_unordered( + x, + y, + ); + } + + late final _bid64_quiet_greater_unorderedPtr = + _lookup>( + 'bid64_quiet_greater_unordered'); + late final _bid64_quiet_greater_unordered = + _bid64_quiet_greater_unorderedPtr.asFunction(); + + int bid64_quiet_less( + int x, + int y, + ) { + return _bid64_quiet_less( + x, + y, + ); + } + + late final _bid64_quiet_lessPtr = + _lookup>( + 'bid64_quiet_less'); + late final _bid64_quiet_less = + _bid64_quiet_lessPtr.asFunction(); + + int bid64_quiet_less_equal( + int x, + int y, + ) { + return _bid64_quiet_less_equal( + x, + y, + ); + } + + late final _bid64_quiet_less_equalPtr = + _lookup>( + 'bid64_quiet_less_equal'); + late final _bid64_quiet_less_equal = + _bid64_quiet_less_equalPtr.asFunction(); + + int bid64_quiet_less_unordered( + int x, + int y, + ) { + return _bid64_quiet_less_unordered( + x, + y, + ); + } + + late final _bid64_quiet_less_unorderedPtr = + _lookup>( + 'bid64_quiet_less_unordered'); + late final _bid64_quiet_less_unordered = + _bid64_quiet_less_unorderedPtr.asFunction(); + + int bid64_quiet_not_equal( + int x, + int y, + ) { + return _bid64_quiet_not_equal( + x, + y, + ); + } + + late final _bid64_quiet_not_equalPtr = + _lookup>( + 'bid64_quiet_not_equal'); + late final _bid64_quiet_not_equal = + _bid64_quiet_not_equalPtr.asFunction(); + + int bid64_quiet_not_greater( + int x, + int y, + ) { + return _bid64_quiet_not_greater( + x, + y, + ); + } + + late final _bid64_quiet_not_greaterPtr = + _lookup>( + 'bid64_quiet_not_greater'); + late final _bid64_quiet_not_greater = + _bid64_quiet_not_greaterPtr.asFunction(); + + int bid64_quiet_not_less( + int x, + int y, + ) { + return _bid64_quiet_not_less( + x, + y, + ); + } + + late final _bid64_quiet_not_lessPtr = + _lookup>( + 'bid64_quiet_not_less'); + late final _bid64_quiet_not_less = + _bid64_quiet_not_lessPtr.asFunction(); + + int bid64_quiet_ordered( + int x, + int y, + ) { + return _bid64_quiet_ordered( + x, + y, + ); + } + + late final _bid64_quiet_orderedPtr = + _lookup>( + 'bid64_quiet_ordered'); + late final _bid64_quiet_ordered = + _bid64_quiet_orderedPtr.asFunction(); + + int bid64_quiet_unordered( + int x, + int y, + ) { + return _bid64_quiet_unordered( + x, + y, + ); + } + + late final _bid64_quiet_unorderedPtr = + _lookup>( + 'bid64_quiet_unordered'); + late final _bid64_quiet_unordered = + _bid64_quiet_unorderedPtr.asFunction(); + + int bid64_radix( + int x, + ) { + return _bid64_radix( + x, + ); + } + + late final _bid64_radixPtr = + _lookup>('bid64_radix'); + late final _bid64_radix = _bid64_radixPtr.asFunction(); + + int bid64_rem( + int x, + int y, + ) { + return _bid64_rem( + x, + y, + ); + } + + late final _bid64_remPtr = + _lookup>( + 'bid64_rem'); + late final _bid64_rem = _bid64_remPtr.asFunction(); + + int bid64_round_integral_exact( + int x, + ) { + return _bid64_round_integral_exact( + x, + ); + } + + late final _bid64_round_integral_exactPtr = + _lookup>( + 'bid64_round_integral_exact'); + late final _bid64_round_integral_exact = + _bid64_round_integral_exactPtr.asFunction(); + + int bid64_round_integral_nearest_away( + int x, + ) { + return _bid64_round_integral_nearest_away( + x, + ); + } + + late final _bid64_round_integral_nearest_awayPtr = + _lookup>( + 'bid64_round_integral_nearest_away'); + late final _bid64_round_integral_nearest_away = + _bid64_round_integral_nearest_awayPtr.asFunction(); + + int bid64_round_integral_nearest_even( + int x, + ) { + return _bid64_round_integral_nearest_even( + x, + ); + } + + late final _bid64_round_integral_nearest_evenPtr = + _lookup>( + 'bid64_round_integral_nearest_even'); + late final _bid64_round_integral_nearest_even = + _bid64_round_integral_nearest_evenPtr.asFunction(); + + int bid64_round_integral_negative( + int x, + ) { + return _bid64_round_integral_negative( + x, + ); + } + + late final _bid64_round_integral_negativePtr = + _lookup>( + 'bid64_round_integral_negative'); + late final _bid64_round_integral_negative = + _bid64_round_integral_negativePtr.asFunction(); + + int bid64_round_integral_positive( + int x, + ) { + return _bid64_round_integral_positive( + x, + ); + } + + late final _bid64_round_integral_positivePtr = + _lookup>( + 'bid64_round_integral_positive'); + late final _bid64_round_integral_positive = + _bid64_round_integral_positivePtr.asFunction(); + + int bid64_round_integral_zero( + int x, + ) { + return _bid64_round_integral_zero( + x, + ); + } + + late final _bid64_round_integral_zeroPtr = + _lookup>( + 'bid64_round_integral_zero'); + late final _bid64_round_integral_zero = + _bid64_round_integral_zeroPtr.asFunction(); + + int bid64_sameQuantum( + int x, + int y, + ) { + return _bid64_sameQuantum( + x, + y, + ); + } + + late final _bid64_sameQuantumPtr = + _lookup>( + 'bid64_sameQuantum'); + late final _bid64_sameQuantum = + _bid64_sameQuantumPtr.asFunction(); + + int bid64_scalbln( + int x, + int n, + ) { + return _bid64_scalbln( + x, + n, + ); + } + + late final _bid64_scalblnPtr = + _lookup>( + 'bid64_scalbln'); + late final _bid64_scalbln = + _bid64_scalblnPtr.asFunction(); + + int bid64_scalbn( + int x, + int n, + ) { + return _bid64_scalbn( + x, + n, + ); + } + + late final _bid64_scalbnPtr = + _lookup>( + 'bid64_scalbn'); + late final _bid64_scalbn = + _bid64_scalbnPtr.asFunction(); + + int bid64_signaling_greater( + int x, + int y, + ) { + return _bid64_signaling_greater( + x, + y, + ); + } + + late final _bid64_signaling_greaterPtr = + _lookup>( + 'bid64_signaling_greater'); + late final _bid64_signaling_greater = + _bid64_signaling_greaterPtr.asFunction(); + + int bid64_signaling_greater_equal( + int x, + int y, + ) { + return _bid64_signaling_greater_equal( + x, + y, + ); + } + + late final _bid64_signaling_greater_equalPtr = + _lookup>( + 'bid64_signaling_greater_equal'); + late final _bid64_signaling_greater_equal = + _bid64_signaling_greater_equalPtr.asFunction(); + + int bid64_signaling_greater_unordered( + int x, + int y, + ) { + return _bid64_signaling_greater_unordered( + x, + y, + ); + } + + late final _bid64_signaling_greater_unorderedPtr = + _lookup>( + 'bid64_signaling_greater_unordered'); + late final _bid64_signaling_greater_unordered = + _bid64_signaling_greater_unorderedPtr + .asFunction(); + + int bid64_signaling_less( + int x, + int y, + ) { + return _bid64_signaling_less( + x, + y, + ); + } + + late final _bid64_signaling_lessPtr = + _lookup>( + 'bid64_signaling_less'); + late final _bid64_signaling_less = + _bid64_signaling_lessPtr.asFunction(); + + int bid64_signaling_less_equal( + int x, + int y, + ) { + return _bid64_signaling_less_equal( + x, + y, + ); + } + + late final _bid64_signaling_less_equalPtr = + _lookup>( + 'bid64_signaling_less_equal'); + late final _bid64_signaling_less_equal = + _bid64_signaling_less_equalPtr.asFunction(); + + int bid64_signaling_less_unordered( + int x, + int y, + ) { + return _bid64_signaling_less_unordered( + x, + y, + ); + } + + late final _bid64_signaling_less_unorderedPtr = + _lookup>( + 'bid64_signaling_less_unordered'); + late final _bid64_signaling_less_unordered = + _bid64_signaling_less_unorderedPtr.asFunction(); + + int bid64_signaling_not_greater( + int x, + int y, + ) { + return _bid64_signaling_not_greater( + x, + y, + ); + } + + late final _bid64_signaling_not_greaterPtr = + _lookup>( + 'bid64_signaling_not_greater'); + late final _bid64_signaling_not_greater = + _bid64_signaling_not_greaterPtr.asFunction(); + + int bid64_signaling_not_less( + int x, + int y, + ) { + return _bid64_signaling_not_less( + x, + y, + ); + } + + late final _bid64_signaling_not_lessPtr = + _lookup>( + 'bid64_signaling_not_less'); + late final _bid64_signaling_not_less = + _bid64_signaling_not_lessPtr.asFunction(); + + int bid64_sin( + int x, + ) { + return _bid64_sin( + x, + ); + } + + late final _bid64_sinPtr = + _lookup>('bid64_sin'); + late final _bid64_sin = _bid64_sinPtr.asFunction(); + + int bid64_sinh( + int x, + ) { + return _bid64_sinh( + x, + ); + } + + late final _bid64_sinhPtr = + _lookup>( + 'bid64_sinh'); + late final _bid64_sinh = _bid64_sinhPtr.asFunction(); + + int bid64_sqrt( + int x, + ) { + return _bid64_sqrt( + x, + ); + } + + late final _bid64_sqrtPtr = + _lookup>( + 'bid64_sqrt'); + late final _bid64_sqrt = _bid64_sqrtPtr.asFunction(); + + int bid64_sub( + int x, + int y, + ) { + return _bid64_sub( + x, + y, + ); + } + + late final _bid64_subPtr = + _lookup>( + 'bid64_sub'); + late final _bid64_sub = _bid64_subPtr.asFunction(); + + int bid64_tan( + int x, + ) { + return _bid64_tan( + x, + ); + } + + late final _bid64_tanPtr = + _lookup>('bid64_tan'); + late final _bid64_tan = _bid64_tanPtr.asFunction(); + + int bid64_tanh( + int x, + ) { + return _bid64_tanh( + x, + ); + } + + late final _bid64_tanhPtr = + _lookup>( + 'bid64_tanh'); + late final _bid64_tanh = _bid64_tanhPtr.asFunction(); + + int bid64_tgamma( + int x, + ) { + return _bid64_tgamma( + x, + ); + } + + late final _bid64_tgammaPtr = + _lookup>( + 'bid64_tgamma'); + late final _bid64_tgamma = _bid64_tgammaPtr.asFunction(); + + BID_UINT128 bid64_to_bid128( + int x, + ) { + return _bid64_to_bid128( + x, + ); + } + + late final _bid64_to_bid128Ptr = + _lookup>( + 'bid64_to_bid128'); + late final _bid64_to_bid128 = + _bid64_to_bid128Ptr.asFunction(); + + int bid64_to_bid32( + int x, + ) { + return _bid64_to_bid32( + x, + ); + } + + late final _bid64_to_bid32Ptr = + _lookup>( + 'bid64_to_bid32'); + late final _bid64_to_bid32 = + _bid64_to_bid32Ptr.asFunction(); + + BID_UINT128 bid64_to_binary128( + int x, + ) { + return _bid64_to_binary128( + x, + ); + } + + late final _bid64_to_binary128Ptr = + _lookup>( + 'bid64_to_binary128'); + late final _bid64_to_binary128 = + _bid64_to_binary128Ptr.asFunction(); + + double bid64_to_binary32( + int x, + ) { + return _bid64_to_binary32( + x, + ); + } + + late final _bid64_to_binary32Ptr = + _lookup>( + 'bid64_to_binary32'); + late final _bid64_to_binary32 = + _bid64_to_binary32Ptr.asFunction(); + + double bid64_to_binary64( + int x, + ) { + return _bid64_to_binary64( + x, + ); + } + + late final _bid64_to_binary64Ptr = + _lookup>( + 'bid64_to_binary64'); + late final _bid64_to_binary64 = + _bid64_to_binary64Ptr.asFunction(); + + int bid64_to_int16_ceil( + int x, + ) { + return _bid64_to_int16_ceil( + x, + ); + } + + late final _bid64_to_int16_ceilPtr = + _lookup>( + 'bid64_to_int16_ceil'); + late final _bid64_to_int16_ceil = + _bid64_to_int16_ceilPtr.asFunction(); + + int bid64_to_int16_floor( + int x, + ) { + return _bid64_to_int16_floor( + x, + ); + } + + late final _bid64_to_int16_floorPtr = + _lookup>( + 'bid64_to_int16_floor'); + late final _bid64_to_int16_floor = + _bid64_to_int16_floorPtr.asFunction(); + + int bid64_to_int16_int( + int x, + ) { + return _bid64_to_int16_int( + x, + ); + } + + late final _bid64_to_int16_intPtr = + _lookup>( + 'bid64_to_int16_int'); + late final _bid64_to_int16_int = + _bid64_to_int16_intPtr.asFunction(); + + int bid64_to_int16_rnint( + int x, + ) { + return _bid64_to_int16_rnint( + x, + ); + } + + late final _bid64_to_int16_rnintPtr = + _lookup>( + 'bid64_to_int16_rnint'); + late final _bid64_to_int16_rnint = + _bid64_to_int16_rnintPtr.asFunction(); + + int bid64_to_int16_rninta( + int x, + ) { + return _bid64_to_int16_rninta( + x, + ); + } + + late final _bid64_to_int16_rnintaPtr = + _lookup>( + 'bid64_to_int16_rninta'); + late final _bid64_to_int16_rninta = + _bid64_to_int16_rnintaPtr.asFunction(); + + int bid64_to_int16_xceil( + int x, + ) { + return _bid64_to_int16_xceil( + x, + ); + } + + late final _bid64_to_int16_xceilPtr = + _lookup>( + 'bid64_to_int16_xceil'); + late final _bid64_to_int16_xceil = + _bid64_to_int16_xceilPtr.asFunction(); + + int bid64_to_int16_xfloor( + int x, + ) { + return _bid64_to_int16_xfloor( + x, + ); + } + + late final _bid64_to_int16_xfloorPtr = + _lookup>( + 'bid64_to_int16_xfloor'); + late final _bid64_to_int16_xfloor = + _bid64_to_int16_xfloorPtr.asFunction(); + + int bid64_to_int16_xint( + int x, + ) { + return _bid64_to_int16_xint( + x, + ); + } + + late final _bid64_to_int16_xintPtr = + _lookup>( + 'bid64_to_int16_xint'); + late final _bid64_to_int16_xint = + _bid64_to_int16_xintPtr.asFunction(); + + int bid64_to_int16_xrnint( + int x, + ) { + return _bid64_to_int16_xrnint( + x, + ); + } + + late final _bid64_to_int16_xrnintPtr = + _lookup>( + 'bid64_to_int16_xrnint'); + late final _bid64_to_int16_xrnint = + _bid64_to_int16_xrnintPtr.asFunction(); + + int bid64_to_int16_xrninta( + int x, + ) { + return _bid64_to_int16_xrninta( + x, + ); + } + + late final _bid64_to_int16_xrnintaPtr = + _lookup>( + 'bid64_to_int16_xrninta'); + late final _bid64_to_int16_xrninta = + _bid64_to_int16_xrnintaPtr.asFunction(); + + int bid64_to_int32_ceil( + int x, + ) { + return _bid64_to_int32_ceil( + x, + ); + } + + late final _bid64_to_int32_ceilPtr = + _lookup>( + 'bid64_to_int32_ceil'); + late final _bid64_to_int32_ceil = + _bid64_to_int32_ceilPtr.asFunction(); + + int bid64_to_int32_floor( + int x, + ) { + return _bid64_to_int32_floor( + x, + ); + } + + late final _bid64_to_int32_floorPtr = + _lookup>( + 'bid64_to_int32_floor'); + late final _bid64_to_int32_floor = + _bid64_to_int32_floorPtr.asFunction(); + + int bid64_to_int32_int( + int x, + ) { + return _bid64_to_int32_int( + x, + ); + } + + late final _bid64_to_int32_intPtr = + _lookup>( + 'bid64_to_int32_int'); + late final _bid64_to_int32_int = + _bid64_to_int32_intPtr.asFunction(); + + int bid64_to_int32_rnint( + int x, + ) { + return _bid64_to_int32_rnint( + x, + ); + } + + late final _bid64_to_int32_rnintPtr = + _lookup>( + 'bid64_to_int32_rnint'); + late final _bid64_to_int32_rnint = + _bid64_to_int32_rnintPtr.asFunction(); + + int bid64_to_int32_rninta( + int x, + ) { + return _bid64_to_int32_rninta( + x, + ); + } + + late final _bid64_to_int32_rnintaPtr = + _lookup>( + 'bid64_to_int32_rninta'); + late final _bid64_to_int32_rninta = + _bid64_to_int32_rnintaPtr.asFunction(); + + int bid64_to_int32_xceil( + int x, + ) { + return _bid64_to_int32_xceil( + x, + ); + } + + late final _bid64_to_int32_xceilPtr = + _lookup>( + 'bid64_to_int32_xceil'); + late final _bid64_to_int32_xceil = + _bid64_to_int32_xceilPtr.asFunction(); + + int bid64_to_int32_xfloor( + int x, + ) { + return _bid64_to_int32_xfloor( + x, + ); + } + + late final _bid64_to_int32_xfloorPtr = + _lookup>( + 'bid64_to_int32_xfloor'); + late final _bid64_to_int32_xfloor = + _bid64_to_int32_xfloorPtr.asFunction(); + + int bid64_to_int32_xint( + int x, + ) { + return _bid64_to_int32_xint( + x, + ); + } + + late final _bid64_to_int32_xintPtr = + _lookup>( + 'bid64_to_int32_xint'); + late final _bid64_to_int32_xint = + _bid64_to_int32_xintPtr.asFunction(); + + int bid64_to_int32_xrnint( + int x, + ) { + return _bid64_to_int32_xrnint( + x, + ); + } + + late final _bid64_to_int32_xrnintPtr = + _lookup>( + 'bid64_to_int32_xrnint'); + late final _bid64_to_int32_xrnint = + _bid64_to_int32_xrnintPtr.asFunction(); + + int bid64_to_int32_xrninta( + int x, + ) { + return _bid64_to_int32_xrninta( + x, + ); + } + + late final _bid64_to_int32_xrnintaPtr = + _lookup>( + 'bid64_to_int32_xrninta'); + late final _bid64_to_int32_xrninta = + _bid64_to_int32_xrnintaPtr.asFunction(); + + int bid64_to_int64_ceil( + int x, + ) { + return _bid64_to_int64_ceil( + x, + ); + } + + late final _bid64_to_int64_ceilPtr = + _lookup>( + 'bid64_to_int64_ceil'); + late final _bid64_to_int64_ceil = + _bid64_to_int64_ceilPtr.asFunction(); + + int bid64_to_int64_floor( + int x, + ) { + return _bid64_to_int64_floor( + x, + ); + } + + late final _bid64_to_int64_floorPtr = + _lookup>( + 'bid64_to_int64_floor'); + late final _bid64_to_int64_floor = + _bid64_to_int64_floorPtr.asFunction(); + + int bid64_to_int64_int( + int x, + ) { + return _bid64_to_int64_int( + x, + ); + } + + late final _bid64_to_int64_intPtr = + _lookup>( + 'bid64_to_int64_int'); + late final _bid64_to_int64_int = + _bid64_to_int64_intPtr.asFunction(); + + int bid64_to_int64_rnint( + int x, + ) { + return _bid64_to_int64_rnint( + x, + ); + } + + late final _bid64_to_int64_rnintPtr = + _lookup>( + 'bid64_to_int64_rnint'); + late final _bid64_to_int64_rnint = + _bid64_to_int64_rnintPtr.asFunction(); + + int bid64_to_int64_rninta( + int x, + ) { + return _bid64_to_int64_rninta( + x, + ); + } + + late final _bid64_to_int64_rnintaPtr = + _lookup>( + 'bid64_to_int64_rninta'); + late final _bid64_to_int64_rninta = + _bid64_to_int64_rnintaPtr.asFunction(); + + int bid64_to_int64_xceil( + int x, + ) { + return _bid64_to_int64_xceil( + x, + ); + } + + late final _bid64_to_int64_xceilPtr = + _lookup>( + 'bid64_to_int64_xceil'); + late final _bid64_to_int64_xceil = + _bid64_to_int64_xceilPtr.asFunction(); + + int bid64_to_int64_xfloor( + int x, + ) { + return _bid64_to_int64_xfloor( + x, + ); + } + + late final _bid64_to_int64_xfloorPtr = + _lookup>( + 'bid64_to_int64_xfloor'); + late final _bid64_to_int64_xfloor = + _bid64_to_int64_xfloorPtr.asFunction(); + + int bid64_to_int64_xint( + int x, + ) { + return _bid64_to_int64_xint( + x, + ); + } + + late final _bid64_to_int64_xintPtr = + _lookup>( + 'bid64_to_int64_xint'); + late final _bid64_to_int64_xint = + _bid64_to_int64_xintPtr.asFunction(); + + int bid64_to_int64_xrnint( + int x, + ) { + return _bid64_to_int64_xrnint( + x, + ); + } + + late final _bid64_to_int64_xrnintPtr = + _lookup>( + 'bid64_to_int64_xrnint'); + late final _bid64_to_int64_xrnint = + _bid64_to_int64_xrnintPtr.asFunction(); + + int bid64_to_int64_xrninta( + int x, + ) { + return _bid64_to_int64_xrninta( + x, + ); + } + + late final _bid64_to_int64_xrnintaPtr = + _lookup>( + 'bid64_to_int64_xrninta'); + late final _bid64_to_int64_xrninta = + _bid64_to_int64_xrnintaPtr.asFunction(); + + int bid64_to_int8_ceil( + int x, + ) { + return _bid64_to_int8_ceil( + x, + ); + } + + late final _bid64_to_int8_ceilPtr = + _lookup>( + 'bid64_to_int8_ceil'); + late final _bid64_to_int8_ceil = + _bid64_to_int8_ceilPtr.asFunction(); + + int bid64_to_int8_floor( + int x, + ) { + return _bid64_to_int8_floor( + x, + ); + } + + late final _bid64_to_int8_floorPtr = + _lookup>( + 'bid64_to_int8_floor'); + late final _bid64_to_int8_floor = + _bid64_to_int8_floorPtr.asFunction(); + + int bid64_to_int8_int( + int x, + ) { + return _bid64_to_int8_int( + x, + ); + } + + late final _bid64_to_int8_intPtr = + _lookup>( + 'bid64_to_int8_int'); + late final _bid64_to_int8_int = + _bid64_to_int8_intPtr.asFunction(); + + int bid64_to_int8_rnint( + int x, + ) { + return _bid64_to_int8_rnint( + x, + ); + } + + late final _bid64_to_int8_rnintPtr = + _lookup>( + 'bid64_to_int8_rnint'); + late final _bid64_to_int8_rnint = + _bid64_to_int8_rnintPtr.asFunction(); + + int bid64_to_int8_rninta( + int x, + ) { + return _bid64_to_int8_rninta( + x, + ); + } + + late final _bid64_to_int8_rnintaPtr = + _lookup>( + 'bid64_to_int8_rninta'); + late final _bid64_to_int8_rninta = + _bid64_to_int8_rnintaPtr.asFunction(); + + int bid64_to_int8_xceil( + int x, + ) { + return _bid64_to_int8_xceil( + x, + ); + } + + late final _bid64_to_int8_xceilPtr = + _lookup>( + 'bid64_to_int8_xceil'); + late final _bid64_to_int8_xceil = + _bid64_to_int8_xceilPtr.asFunction(); + + int bid64_to_int8_xfloor( + int x, + ) { + return _bid64_to_int8_xfloor( + x, + ); + } + + late final _bid64_to_int8_xfloorPtr = + _lookup>( + 'bid64_to_int8_xfloor'); + late final _bid64_to_int8_xfloor = + _bid64_to_int8_xfloorPtr.asFunction(); + + int bid64_to_int8_xint( + int x, + ) { + return _bid64_to_int8_xint( + x, + ); + } + + late final _bid64_to_int8_xintPtr = + _lookup>( + 'bid64_to_int8_xint'); + late final _bid64_to_int8_xint = + _bid64_to_int8_xintPtr.asFunction(); + + int bid64_to_int8_xrnint( + int x, + ) { + return _bid64_to_int8_xrnint( + x, + ); + } + + late final _bid64_to_int8_xrnintPtr = + _lookup>( + 'bid64_to_int8_xrnint'); + late final _bid64_to_int8_xrnint = + _bid64_to_int8_xrnintPtr.asFunction(); + + int bid64_to_int8_xrninta( + int x, + ) { + return _bid64_to_int8_xrninta( + x, + ); + } + + late final _bid64_to_int8_xrnintaPtr = + _lookup>( + 'bid64_to_int8_xrninta'); + late final _bid64_to_int8_xrninta = + _bid64_to_int8_xrnintaPtr.asFunction(); + + void bid64_to_string( + ffi.Pointer ps, + int x, + ) { + return _bid64_to_string( + ps, + x, + ); + } + + late final _bid64_to_stringPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, BID_UINT64)>>('bid64_to_string'); + late final _bid64_to_string = _bid64_to_stringPtr + .asFunction, int)>(); + + int bid64_to_uint16_ceil( + int x, + ) { + return _bid64_to_uint16_ceil( + x, + ); + } + + late final _bid64_to_uint16_ceilPtr = + _lookup>( + 'bid64_to_uint16_ceil'); + late final _bid64_to_uint16_ceil = + _bid64_to_uint16_ceilPtr.asFunction(); + + int bid64_to_uint16_floor( + int x, + ) { + return _bid64_to_uint16_floor( + x, + ); + } + + late final _bid64_to_uint16_floorPtr = + _lookup>( + 'bid64_to_uint16_floor'); + late final _bid64_to_uint16_floor = + _bid64_to_uint16_floorPtr.asFunction(); + + int bid64_to_uint16_int( + int x, + ) { + return _bid64_to_uint16_int( + x, + ); + } + + late final _bid64_to_uint16_intPtr = + _lookup>( + 'bid64_to_uint16_int'); + late final _bid64_to_uint16_int = + _bid64_to_uint16_intPtr.asFunction(); + + int bid64_to_uint16_rnint( + int x, + ) { + return _bid64_to_uint16_rnint( + x, + ); + } + + late final _bid64_to_uint16_rnintPtr = + _lookup>( + 'bid64_to_uint16_rnint'); + late final _bid64_to_uint16_rnint = + _bid64_to_uint16_rnintPtr.asFunction(); + + int bid64_to_uint16_rninta( + int x, + ) { + return _bid64_to_uint16_rninta( + x, + ); + } + + late final _bid64_to_uint16_rnintaPtr = + _lookup>( + 'bid64_to_uint16_rninta'); + late final _bid64_to_uint16_rninta = + _bid64_to_uint16_rnintaPtr.asFunction(); + + int bid64_to_uint16_xceil( + int x, + ) { + return _bid64_to_uint16_xceil( + x, + ); + } + + late final _bid64_to_uint16_xceilPtr = + _lookup>( + 'bid64_to_uint16_xceil'); + late final _bid64_to_uint16_xceil = + _bid64_to_uint16_xceilPtr.asFunction(); + + int bid64_to_uint16_xfloor( + int x, + ) { + return _bid64_to_uint16_xfloor( + x, + ); + } + + late final _bid64_to_uint16_xfloorPtr = + _lookup>( + 'bid64_to_uint16_xfloor'); + late final _bid64_to_uint16_xfloor = + _bid64_to_uint16_xfloorPtr.asFunction(); + + int bid64_to_uint16_xint( + int x, + ) { + return _bid64_to_uint16_xint( + x, + ); + } + + late final _bid64_to_uint16_xintPtr = + _lookup>( + 'bid64_to_uint16_xint'); + late final _bid64_to_uint16_xint = + _bid64_to_uint16_xintPtr.asFunction(); + + int bid64_to_uint16_xrnint( + int x, + ) { + return _bid64_to_uint16_xrnint( + x, + ); + } + + late final _bid64_to_uint16_xrnintPtr = + _lookup>( + 'bid64_to_uint16_xrnint'); + late final _bid64_to_uint16_xrnint = + _bid64_to_uint16_xrnintPtr.asFunction(); + + int bid64_to_uint16_xrninta( + int x, + ) { + return _bid64_to_uint16_xrninta( + x, + ); + } + + late final _bid64_to_uint16_xrnintaPtr = + _lookup>( + 'bid64_to_uint16_xrninta'); + late final _bid64_to_uint16_xrninta = + _bid64_to_uint16_xrnintaPtr.asFunction(); + + int bid64_to_uint32_ceil( + int x, + ) { + return _bid64_to_uint32_ceil( + x, + ); + } + + late final _bid64_to_uint32_ceilPtr = + _lookup>( + 'bid64_to_uint32_ceil'); + late final _bid64_to_uint32_ceil = + _bid64_to_uint32_ceilPtr.asFunction(); + + int bid64_to_uint32_floor( + int x, + ) { + return _bid64_to_uint32_floor( + x, + ); + } + + late final _bid64_to_uint32_floorPtr = + _lookup>( + 'bid64_to_uint32_floor'); + late final _bid64_to_uint32_floor = + _bid64_to_uint32_floorPtr.asFunction(); + + int bid64_to_uint32_int( + int x, + ) { + return _bid64_to_uint32_int( + x, + ); + } + + late final _bid64_to_uint32_intPtr = + _lookup>( + 'bid64_to_uint32_int'); + late final _bid64_to_uint32_int = + _bid64_to_uint32_intPtr.asFunction(); + + int bid64_to_uint32_rnint( + int x, + ) { + return _bid64_to_uint32_rnint( + x, + ); + } + + late final _bid64_to_uint32_rnintPtr = + _lookup>( + 'bid64_to_uint32_rnint'); + late final _bid64_to_uint32_rnint = + _bid64_to_uint32_rnintPtr.asFunction(); + + int bid64_to_uint32_rninta( + int x, + ) { + return _bid64_to_uint32_rninta( + x, + ); + } + + late final _bid64_to_uint32_rnintaPtr = + _lookup>( + 'bid64_to_uint32_rninta'); + late final _bid64_to_uint32_rninta = + _bid64_to_uint32_rnintaPtr.asFunction(); + + int bid64_to_uint32_xceil( + int x, + ) { + return _bid64_to_uint32_xceil( + x, + ); + } + + late final _bid64_to_uint32_xceilPtr = + _lookup>( + 'bid64_to_uint32_xceil'); + late final _bid64_to_uint32_xceil = + _bid64_to_uint32_xceilPtr.asFunction(); + + int bid64_to_uint32_xfloor( + int x, + ) { + return _bid64_to_uint32_xfloor( + x, + ); + } + + late final _bid64_to_uint32_xfloorPtr = + _lookup>( + 'bid64_to_uint32_xfloor'); + late final _bid64_to_uint32_xfloor = + _bid64_to_uint32_xfloorPtr.asFunction(); + + int bid64_to_uint32_xint( + int x, + ) { + return _bid64_to_uint32_xint( + x, + ); + } + + late final _bid64_to_uint32_xintPtr = + _lookup>( + 'bid64_to_uint32_xint'); + late final _bid64_to_uint32_xint = + _bid64_to_uint32_xintPtr.asFunction(); + + int bid64_to_uint32_xrnint( + int x, + ) { + return _bid64_to_uint32_xrnint( + x, + ); + } + + late final _bid64_to_uint32_xrnintPtr = + _lookup>( + 'bid64_to_uint32_xrnint'); + late final _bid64_to_uint32_xrnint = + _bid64_to_uint32_xrnintPtr.asFunction(); + + int bid64_to_uint32_xrninta( + int x, + ) { + return _bid64_to_uint32_xrninta( + x, + ); + } + + late final _bid64_to_uint32_xrnintaPtr = + _lookup>( + 'bid64_to_uint32_xrninta'); + late final _bid64_to_uint32_xrninta = + _bid64_to_uint32_xrnintaPtr.asFunction(); + + int bid64_to_uint64_ceil( + int x, + ) { + return _bid64_to_uint64_ceil( + x, + ); + } + + late final _bid64_to_uint64_ceilPtr = + _lookup>( + 'bid64_to_uint64_ceil'); + late final _bid64_to_uint64_ceil = + _bid64_to_uint64_ceilPtr.asFunction(); + + int bid64_to_uint64_floor( + int x, + ) { + return _bid64_to_uint64_floor( + x, + ); + } + + late final _bid64_to_uint64_floorPtr = + _lookup>( + 'bid64_to_uint64_floor'); + late final _bid64_to_uint64_floor = + _bid64_to_uint64_floorPtr.asFunction(); + + int bid64_to_uint64_int( + int x, + ) { + return _bid64_to_uint64_int( + x, + ); + } + + late final _bid64_to_uint64_intPtr = + _lookup>( + 'bid64_to_uint64_int'); + late final _bid64_to_uint64_int = + _bid64_to_uint64_intPtr.asFunction(); + + int bid64_to_uint64_rnint( + int x, + ) { + return _bid64_to_uint64_rnint( + x, + ); + } + + late final _bid64_to_uint64_rnintPtr = + _lookup>( + 'bid64_to_uint64_rnint'); + late final _bid64_to_uint64_rnint = + _bid64_to_uint64_rnintPtr.asFunction(); + + int bid64_to_uint64_rninta( + int x, + ) { + return _bid64_to_uint64_rninta( + x, + ); + } + + late final _bid64_to_uint64_rnintaPtr = + _lookup>( + 'bid64_to_uint64_rninta'); + late final _bid64_to_uint64_rninta = + _bid64_to_uint64_rnintaPtr.asFunction(); + + int bid64_to_uint64_xceil( + int x, + ) { + return _bid64_to_uint64_xceil( + x, + ); + } + + late final _bid64_to_uint64_xceilPtr = + _lookup>( + 'bid64_to_uint64_xceil'); + late final _bid64_to_uint64_xceil = + _bid64_to_uint64_xceilPtr.asFunction(); + + int bid64_to_uint64_xfloor( + int x, + ) { + return _bid64_to_uint64_xfloor( + x, + ); + } + + late final _bid64_to_uint64_xfloorPtr = + _lookup>( + 'bid64_to_uint64_xfloor'); + late final _bid64_to_uint64_xfloor = + _bid64_to_uint64_xfloorPtr.asFunction(); + + int bid64_to_uint64_xint( + int x, + ) { + return _bid64_to_uint64_xint( + x, + ); + } + + late final _bid64_to_uint64_xintPtr = + _lookup>( + 'bid64_to_uint64_xint'); + late final _bid64_to_uint64_xint = + _bid64_to_uint64_xintPtr.asFunction(); + + int bid64_to_uint64_xrnint( + int x, + ) { + return _bid64_to_uint64_xrnint( + x, + ); + } + + late final _bid64_to_uint64_xrnintPtr = + _lookup>( + 'bid64_to_uint64_xrnint'); + late final _bid64_to_uint64_xrnint = + _bid64_to_uint64_xrnintPtr.asFunction(); + + int bid64_to_uint64_xrninta( + int x, + ) { + return _bid64_to_uint64_xrninta( + x, + ); + } + + late final _bid64_to_uint64_xrnintaPtr = + _lookup>( + 'bid64_to_uint64_xrninta'); + late final _bid64_to_uint64_xrninta = + _bid64_to_uint64_xrnintaPtr.asFunction(); + + int bid64_to_uint8_ceil( + int x, + ) { + return _bid64_to_uint8_ceil( + x, + ); + } + + late final _bid64_to_uint8_ceilPtr = + _lookup>( + 'bid64_to_uint8_ceil'); + late final _bid64_to_uint8_ceil = + _bid64_to_uint8_ceilPtr.asFunction(); + + int bid64_to_uint8_floor( + int x, + ) { + return _bid64_to_uint8_floor( + x, + ); + } + + late final _bid64_to_uint8_floorPtr = + _lookup>( + 'bid64_to_uint8_floor'); + late final _bid64_to_uint8_floor = + _bid64_to_uint8_floorPtr.asFunction(); + + int bid64_to_uint8_int( + int x, + ) { + return _bid64_to_uint8_int( + x, + ); + } + + late final _bid64_to_uint8_intPtr = + _lookup>( + 'bid64_to_uint8_int'); + late final _bid64_to_uint8_int = + _bid64_to_uint8_intPtr.asFunction(); + + int bid64_to_uint8_rnint( + int x, + ) { + return _bid64_to_uint8_rnint( + x, + ); + } + + late final _bid64_to_uint8_rnintPtr = + _lookup>( + 'bid64_to_uint8_rnint'); + late final _bid64_to_uint8_rnint = + _bid64_to_uint8_rnintPtr.asFunction(); + + int bid64_to_uint8_rninta( + int x, + ) { + return _bid64_to_uint8_rninta( + x, + ); + } + + late final _bid64_to_uint8_rnintaPtr = + _lookup>( + 'bid64_to_uint8_rninta'); + late final _bid64_to_uint8_rninta = + _bid64_to_uint8_rnintaPtr.asFunction(); + + int bid64_to_uint8_xceil( + int x, + ) { + return _bid64_to_uint8_xceil( + x, + ); + } + + late final _bid64_to_uint8_xceilPtr = + _lookup>( + 'bid64_to_uint8_xceil'); + late final _bid64_to_uint8_xceil = + _bid64_to_uint8_xceilPtr.asFunction(); + + int bid64_to_uint8_xfloor( + int x, + ) { + return _bid64_to_uint8_xfloor( + x, + ); + } + + late final _bid64_to_uint8_xfloorPtr = + _lookup>( + 'bid64_to_uint8_xfloor'); + late final _bid64_to_uint8_xfloor = + _bid64_to_uint8_xfloorPtr.asFunction(); + + int bid64_to_uint8_xint( + int x, + ) { + return _bid64_to_uint8_xint( + x, + ); + } + + late final _bid64_to_uint8_xintPtr = + _lookup>( + 'bid64_to_uint8_xint'); + late final _bid64_to_uint8_xint = + _bid64_to_uint8_xintPtr.asFunction(); + + int bid64_to_uint8_xrnint( + int x, + ) { + return _bid64_to_uint8_xrnint( + x, + ); + } + + late final _bid64_to_uint8_xrnintPtr = + _lookup>( + 'bid64_to_uint8_xrnint'); + late final _bid64_to_uint8_xrnint = + _bid64_to_uint8_xrnintPtr.asFunction(); + + int bid64_to_uint8_xrninta( + int x, + ) { + return _bid64_to_uint8_xrninta( + x, + ); + } + + late final _bid64_to_uint8_xrnintaPtr = + _lookup>( + 'bid64_to_uint8_xrninta'); + late final _bid64_to_uint8_xrninta = + _bid64_to_uint8_xrnintaPtr.asFunction(); + + int bid64_totalOrder( + int x, + int y, + ) { + return _bid64_totalOrder( + x, + y, + ); + } + + late final _bid64_totalOrderPtr = + _lookup>( + 'bid64_totalOrder'); + late final _bid64_totalOrder = + _bid64_totalOrderPtr.asFunction(); + + int bid64_totalOrderMag( + int x, + int y, + ) { + return _bid64_totalOrderMag( + x, + y, + ); + } + + late final _bid64_totalOrderMagPtr = + _lookup>( + 'bid64_totalOrderMag'); + late final _bid64_totalOrderMag = + _bid64_totalOrderMagPtr.asFunction(); + + int bid64ddq_fma( + int x, + int y, + BID_UINT128 z, + ) { + return _bid64ddq_fma( + x, + y, + z, + ); + } + + late final _bid64ddq_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT64, BID_UINT64, BID_UINT128)>>('bid64ddq_fma'); + late final _bid64ddq_fma = + _bid64ddq_fmaPtr.asFunction(); + + int bid64dq_add( + int x, + BID_UINT128 y, + ) { + return _bid64dq_add( + x, + y, + ); + } + + late final _bid64dq_addPtr = + _lookup>( + 'bid64dq_add'); + late final _bid64dq_add = + _bid64dq_addPtr.asFunction(); + + int bid64dq_div( + int x, + BID_UINT128 y, + ) { + return _bid64dq_div( + x, + y, + ); + } + + late final _bid64dq_divPtr = + _lookup>( + 'bid64dq_div'); + late final _bid64dq_div = + _bid64dq_divPtr.asFunction(); + + int bid64dq_mul( + int x, + BID_UINT128 y, + ) { + return _bid64dq_mul( + x, + y, + ); + } + + late final _bid64dq_mulPtr = + _lookup>( + 'bid64dq_mul'); + late final _bid64dq_mul = + _bid64dq_mulPtr.asFunction(); + + int bid64dq_sub( + int x, + BID_UINT128 y, + ) { + return _bid64dq_sub( + x, + y, + ); + } + + late final _bid64dq_subPtr = + _lookup>( + 'bid64dq_sub'); + late final _bid64dq_sub = + _bid64dq_subPtr.asFunction(); + + int bid64dqd_fma( + int x, + BID_UINT128 y, + int z, + ) { + return _bid64dqd_fma( + x, + y, + z, + ); + } + + late final _bid64dqd_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT64, BID_UINT128, BID_UINT64)>>('bid64dqd_fma'); + late final _bid64dqd_fma = + _bid64dqd_fmaPtr.asFunction(); + + int bid64dqq_fma( + int x, + BID_UINT128 y, + BID_UINT128 z, + ) { + return _bid64dqq_fma( + x, + y, + z, + ); + } + + late final _bid64dqq_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT64, BID_UINT128, BID_UINT128)>>('bid64dqq_fma'); + late final _bid64dqq_fma = _bid64dqq_fmaPtr + .asFunction(); + + int bid64q_sqrt( + BID_UINT128 x, + ) { + return _bid64q_sqrt( + x, + ); + } + + late final _bid64q_sqrtPtr = + _lookup>( + 'bid64q_sqrt'); + late final _bid64q_sqrt = + _bid64q_sqrtPtr.asFunction(); + + int bid64qd_add( + BID_UINT128 x, + int y, + ) { + return _bid64qd_add( + x, + y, + ); + } + + late final _bid64qd_addPtr = + _lookup>( + 'bid64qd_add'); + late final _bid64qd_add = + _bid64qd_addPtr.asFunction(); + + int bid64qd_div( + BID_UINT128 x, + int y, + ) { + return _bid64qd_div( + x, + y, + ); + } + + late final _bid64qd_divPtr = + _lookup>( + 'bid64qd_div'); + late final _bid64qd_div = + _bid64qd_divPtr.asFunction(); + + int bid64qd_mul( + BID_UINT128 x, + int y, + ) { + return _bid64qd_mul( + x, + y, + ); + } + + late final _bid64qd_mulPtr = + _lookup>( + 'bid64qd_mul'); + late final _bid64qd_mul = + _bid64qd_mulPtr.asFunction(); + + int bid64qd_sub( + BID_UINT128 x, + int y, + ) { + return _bid64qd_sub( + x, + y, + ); + } + + late final _bid64qd_subPtr = + _lookup>( + 'bid64qd_sub'); + late final _bid64qd_sub = + _bid64qd_subPtr.asFunction(); + + int bid64qdd_fma( + BID_UINT128 x, + int y, + int z, + ) { + return _bid64qdd_fma( + x, + y, + z, + ); + } + + late final _bid64qdd_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT128, BID_UINT64, BID_UINT64)>>('bid64qdd_fma'); + late final _bid64qdd_fma = + _bid64qdd_fmaPtr.asFunction(); + + int bid64qdq_fma( + BID_UINT128 x, + int y, + BID_UINT128 z, + ) { + return _bid64qdq_fma( + x, + y, + z, + ); + } + + late final _bid64qdq_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT128, BID_UINT64, BID_UINT128)>>('bid64qdq_fma'); + late final _bid64qdq_fma = _bid64qdq_fmaPtr + .asFunction(); + + int bid64qq_add( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid64qq_add( + x, + y, + ); + } + + late final _bid64qq_addPtr = _lookup< + ffi.NativeFunction>( + 'bid64qq_add'); + late final _bid64qq_add = + _bid64qq_addPtr.asFunction(); + + int bid64qq_div( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid64qq_div( + x, + y, + ); + } + + late final _bid64qq_divPtr = _lookup< + ffi.NativeFunction>( + 'bid64qq_div'); + late final _bid64qq_div = + _bid64qq_divPtr.asFunction(); + + int bid64qq_mul( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid64qq_mul( + x, + y, + ); + } + + late final _bid64qq_mulPtr = _lookup< + ffi.NativeFunction>( + 'bid64qq_mul'); + late final _bid64qq_mul = + _bid64qq_mulPtr.asFunction(); + + int bid64qq_sub( + BID_UINT128 x, + BID_UINT128 y, + ) { + return _bid64qq_sub( + x, + y, + ); + } + + late final _bid64qq_subPtr = _lookup< + ffi.NativeFunction>( + 'bid64qq_sub'); + late final _bid64qq_sub = + _bid64qq_subPtr.asFunction(); + + int bid64qqd_fma( + BID_UINT128 x, + BID_UINT128 y, + int z, + ) { + return _bid64qqd_fma( + x, + y, + z, + ); + } + + late final _bid64qqd_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT128, BID_UINT128, BID_UINT64)>>('bid64qqd_fma'); + late final _bid64qqd_fma = _bid64qqd_fmaPtr + .asFunction(); + + int bid64qqq_fma( + BID_UINT128 x, + BID_UINT128 y, + BID_UINT128 z, + ) { + return _bid64qqq_fma( + x, + y, + z, + ); + } + + late final _bid64qqq_fmaPtr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function( + BID_UINT128, BID_UINT128, BID_UINT128)>>('bid64qqq_fma'); + late final _bid64qqq_fma = _bid64qqq_fmaPtr + .asFunction(); + + BID_UINT128 bid_dpd_to_bid128( + BID_UINT128 px, + ) { + return _bid_dpd_to_bid128( + px, + ); + } + + late final _bid_dpd_to_bid128Ptr = + _lookup>( + 'bid_dpd_to_bid128'); + late final _bid_dpd_to_bid128 = + _bid_dpd_to_bid128Ptr.asFunction(); + + int bid_dpd_to_bid32( + int px, + ) { + return _bid_dpd_to_bid32( + px, + ); + } + + late final _bid_dpd_to_bid32Ptr = + _lookup>( + 'bid_dpd_to_bid32'); + late final _bid_dpd_to_bid32 = + _bid_dpd_to_bid32Ptr.asFunction(); + + int bid_dpd_to_bid64( + int px, + ) { + return _bid_dpd_to_bid64( + px, + ); + } + + late final _bid_dpd_to_bid64Ptr = + _lookup>( + 'bid_dpd_to_bid64'); + late final _bid_dpd_to_bid64 = + _bid_dpd_to_bid64Ptr.asFunction(); + + void bid_feclearexcept( + int excepts, + ) { + return _bid_feclearexcept( + excepts, + ); + } + + late final _bid_feclearexceptPtr = + _lookup>( + 'bid_feclearexcept'); + late final _bid_feclearexcept = + _bid_feclearexceptPtr.asFunction(); + + void bid_fegetexceptflag( + ffi.Pointer flagp, + int excepts, + ) { + return _bid_fegetexceptflag( + flagp, + excepts, + ); + } + + late final _bid_fegetexceptflagPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, ffi.Int)>>('bid_fegetexceptflag'); + late final _bid_fegetexceptflag = _bid_fegetexceptflagPtr + .asFunction, int)>(); + + void bid_feraiseexcept( + int excepts, + ) { + return _bid_feraiseexcept( + excepts, + ); + } + + late final _bid_feraiseexceptPtr = + _lookup>( + 'bid_feraiseexcept'); + late final _bid_feraiseexcept = + _bid_feraiseexceptPtr.asFunction(); + + void bid_fesetexceptflag( + ffi.Pointer flagp, + int excepts, + ) { + return _bid_fesetexceptflag( + flagp, + excepts, + ); + } + + late final _bid_fesetexceptflagPtr = _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Pointer, ffi.Int)>>('bid_fesetexceptflag'); + late final _bid_fesetexceptflag = _bid_fesetexceptflagPtr + .asFunction, int)>(); + + int bid_fetestexcept( + int excepts, + ) { + return _bid_fetestexcept( + excepts, + ); + } + + late final _bid_fetestexceptPtr = + _lookup>( + 'bid_fetestexcept'); + late final _bid_fetestexcept = + _bid_fetestexceptPtr.asFunction(); + + int bid_getDecimalRoundingDirection( + int rnd_mode, + ) { + return _bid_getDecimalRoundingDirection( + rnd_mode, + ); + } + + late final _bid_getDecimalRoundingDirectionPtr = + _lookup>( + 'bid_getDecimalRoundingDirection'); + late final _bid_getDecimalRoundingDirection = + _bid_getDecimalRoundingDirectionPtr.asFunction(); + + int bid_is754() { + return _bid_is754(); + } + + late final _bid_is754Ptr = + _lookup>('bid_is754'); + late final _bid_is754 = _bid_is754Ptr.asFunction(); + + int bid_is754R() { + return _bid_is754R(); + } + + late final _bid_is754RPtr = + _lookup>('bid_is754R'); + late final _bid_is754R = _bid_is754RPtr.asFunction(); + + void bid_lowerFlags( + int flagsmask, + ) { + return _bid_lowerFlags( + flagsmask, + ); + } + + late final _bid_lowerFlagsPtr = + _lookup>('bid_lowerFlags'); + late final _bid_lowerFlags = + _bid_lowerFlagsPtr.asFunction(); + + void bid_restoreFlags( + int flagsvalues, + int flagsmask, + ) { + return _bid_restoreFlags( + flagsvalues, + flagsmask, + ); + } + + late final _bid_restoreFlagsPtr = + _lookup>( + 'bid_restoreFlags'); + late final _bid_restoreFlags = + _bid_restoreFlagsPtr.asFunction(); + + void bid_round128_19_38( + int q, + int x, + BID_UINT128 C, + ffi.Pointer ptr_Cstar, + ffi.Pointer delta_exp, + ffi.Pointer ptr_is_midpoint_lt_even, + ffi.Pointer ptr_is_midpoint_gt_even, + ffi.Pointer ptr_is_inexact_lt_midpoint, + ffi.Pointer ptr_is_inexact_gt_midpoint, + ) { + return _bid_round128_19_38( + q, + x, + C, + ptr_Cstar, + delta_exp, + ptr_is_midpoint_lt_even, + ptr_is_midpoint_gt_even, + ptr_is_inexact_lt_midpoint, + ptr_is_inexact_gt_midpoint, + ); + } + + late final _bid_round128_19_38Ptr = _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int, + ffi.Int, + BID_UINT128, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('bid_round128_19_38'); + late final _bid_round128_19_38 = _bid_round128_19_38Ptr.asFunction< + void Function( + int, + int, + BID_UINT128, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + void bid_round192_39_57( + int q, + int x, + BID_UINT192 C, + ffi.Pointer ptr_Cstar, + ffi.Pointer delta_exp, + ffi.Pointer ptr_is_midpoint_lt_even, + ffi.Pointer ptr_is_midpoint_gt_even, + ffi.Pointer ptr_is_inexact_lt_midpoint, + ffi.Pointer ptr_is_inexact_gt_midpoint, + ) { + return _bid_round192_39_57( + q, + x, + C, + ptr_Cstar, + delta_exp, + ptr_is_midpoint_lt_even, + ptr_is_midpoint_gt_even, + ptr_is_inexact_lt_midpoint, + ptr_is_inexact_gt_midpoint, + ); + } + + late final _bid_round192_39_57Ptr = _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int, + ffi.Int, + BID_UINT192, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('bid_round192_39_57'); + late final _bid_round192_39_57 = _bid_round192_39_57Ptr.asFunction< + void Function( + int, + int, + BID_UINT192, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + void bid_round256_58_76( + int q, + int x, + BID_UINT256 C, + ffi.Pointer ptr_Cstar, + ffi.Pointer delta_exp, + ffi.Pointer ptr_is_midpoint_lt_even, + ffi.Pointer ptr_is_midpoint_gt_even, + ffi.Pointer ptr_is_inexact_lt_midpoint, + ffi.Pointer ptr_is_inexact_gt_midpoint, + ) { + return _bid_round256_58_76( + q, + x, + C, + ptr_Cstar, + delta_exp, + ptr_is_midpoint_lt_even, + ptr_is_midpoint_gt_even, + ptr_is_inexact_lt_midpoint, + ptr_is_inexact_gt_midpoint, + ); + } + + late final _bid_round256_58_76Ptr = _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int, + ffi.Int, + BID_UINT256, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('bid_round256_58_76'); + late final _bid_round256_58_76 = _bid_round256_58_76Ptr.asFunction< + void Function( + int, + int, + BID_UINT256, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + void bid_round64_2_18( + int q, + int x, + int C, + ffi.Pointer ptr_Cstar, + ffi.Pointer delta_exp, + ffi.Pointer ptr_is_midpoint_lt_even, + ffi.Pointer ptr_is_midpoint_gt_even, + ffi.Pointer ptr_is_inexact_lt_midpoint, + ffi.Pointer ptr_is_inexact_gt_midpoint, + ) { + return _bid_round64_2_18( + q, + x, + C, + ptr_Cstar, + delta_exp, + ptr_is_midpoint_lt_even, + ptr_is_midpoint_gt_even, + ptr_is_inexact_lt_midpoint, + ptr_is_inexact_gt_midpoint, + ); + } + + late final _bid_round64_2_18Ptr = _lookup< + ffi.NativeFunction< + ffi.Void Function( + ffi.Int, + ffi.Int, + BID_UINT64, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>('bid_round64_2_18'); + late final _bid_round64_2_18 = _bid_round64_2_18Ptr.asFunction< + void Function( + int, + int, + int, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>(); + + int bid_saveFlags( + int flagsmask, + ) { + return _bid_saveFlags( + flagsmask, + ); + } + + late final _bid_saveFlagsPtr = + _lookup>('bid_saveFlags'); + late final _bid_saveFlags = _bid_saveFlagsPtr.asFunction(); + + int bid_setDecimalRoundingDirection( + int rounding_mode, + ) { + return _bid_setDecimalRoundingDirection( + rounding_mode, + ); + } + + late final _bid_setDecimalRoundingDirectionPtr = + _lookup>( + 'bid_setDecimalRoundingDirection'); + late final _bid_setDecimalRoundingDirection = + _bid_setDecimalRoundingDirectionPtr.asFunction(); + + void bid_signalException( + int flagsmask, + ) { + return _bid_signalException( + flagsmask, + ); + } + + late final _bid_signalExceptionPtr = + _lookup>( + 'bid_signalException'); + late final _bid_signalException = + _bid_signalExceptionPtr.asFunction(); + + BID_UINT128 bid_strtod128( + ffi.Pointer ps_in, + ffi.Pointer> endptr, + ) { + return _bid_strtod128( + ps_in, + endptr, + ); + } + + late final _bid_strtod128Ptr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function(ffi.Pointer, + ffi.Pointer>)>>('bid_strtod128'); + late final _bid_strtod128 = _bid_strtod128Ptr.asFunction< + BID_UINT128 Function( + ffi.Pointer, ffi.Pointer>)>(); + + int bid_strtod32( + ffi.Pointer ps_in, + ffi.Pointer> endptr, + ) { + return _bid_strtod32( + ps_in, + endptr, + ); + } + + late final _bid_strtod32Ptr = _lookup< + ffi.NativeFunction< + BID_UINT32 Function(ffi.Pointer, + ffi.Pointer>)>>('bid_strtod32'); + late final _bid_strtod32 = _bid_strtod32Ptr.asFunction< + int Function( + ffi.Pointer, ffi.Pointer>)>(); + + int bid_strtod64( + ffi.Pointer ps_in, + ffi.Pointer> endptr, + ) { + return _bid_strtod64( + ps_in, + endptr, + ); + } + + late final _bid_strtod64Ptr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function(ffi.Pointer, + ffi.Pointer>)>>('bid_strtod64'); + late final _bid_strtod64 = _bid_strtod64Ptr.asFunction< + int Function( + ffi.Pointer, ffi.Pointer>)>(); + + int bid_testFlags( + int flagsmask, + ) { + return _bid_testFlags( + flagsmask, + ); + } + + late final _bid_testFlagsPtr = + _lookup>('bid_testFlags'); + late final _bid_testFlags = _bid_testFlagsPtr.asFunction(); + + int bid_testSavedFlags( + int savedflags, + int flagsmask, + ) { + return _bid_testSavedFlags( + savedflags, + flagsmask, + ); + } + + late final _bid_testSavedFlagsPtr = + _lookup>( + 'bid_testSavedFlags'); + late final _bid_testSavedFlags = + _bid_testSavedFlagsPtr.asFunction(); + + BID_UINT128 bid_to_dpd128( + BID_UINT128 px, + ) { + return _bid_to_dpd128( + px, + ); + } + + late final _bid_to_dpd128Ptr = + _lookup>( + 'bid_to_dpd128'); + late final _bid_to_dpd128 = + _bid_to_dpd128Ptr.asFunction(); + + int bid_to_dpd32( + int px, + ) { + return _bid_to_dpd32( + px, + ); + } + + late final _bid_to_dpd32Ptr = + _lookup>( + 'bid_to_dpd32'); + late final _bid_to_dpd32 = _bid_to_dpd32Ptr.asFunction(); + + int bid_to_dpd64( + int px, + ) { + return _bid_to_dpd64( + px, + ); + } + + late final _bid_to_dpd64Ptr = + _lookup>( + 'bid_to_dpd64'); + late final _bid_to_dpd64 = _bid_to_dpd64Ptr.asFunction(); + + BID_UINT128 bid_wcstod128( + ffi.Pointer ps_in, + ffi.Pointer> endptr, + ) { + return _bid_wcstod128( + ps_in, + endptr, + ); + } + + late final _bid_wcstod128Ptr = _lookup< + ffi.NativeFunction< + BID_UINT128 Function(ffi.Pointer, + ffi.Pointer>)>>('bid_wcstod128'); + late final _bid_wcstod128 = _bid_wcstod128Ptr.asFunction< + BID_UINT128 Function( + ffi.Pointer, ffi.Pointer>)>(); + + int bid_wcstod32( + ffi.Pointer ps_in, + ffi.Pointer> endptr, + ) { + return _bid_wcstod32( + ps_in, + endptr, + ); + } + + late final _bid_wcstod32Ptr = _lookup< + ffi.NativeFunction< + BID_UINT32 Function(ffi.Pointer, + ffi.Pointer>)>>('bid_wcstod32'); + late final _bid_wcstod32 = _bid_wcstod32Ptr.asFunction< + int Function( + ffi.Pointer, ffi.Pointer>)>(); + + int bid_wcstod64( + ffi.Pointer ps_in, + ffi.Pointer> endptr, + ) { + return _bid_wcstod64( + ps_in, + endptr, + ); + } + + late final _bid_wcstod64Ptr = _lookup< + ffi.NativeFunction< + BID_UINT64 Function(ffi.Pointer, + ffi.Pointer>)>>('bid_wcstod64'); + late final _bid_wcstod64 = _bid_wcstod64Ptr.asFunction< + int Function( + ffi.Pointer, ffi.Pointer>)>(); + + BID_UINT128 binary128_to_bid128( + BID_UINT128 x, + ) { + return _binary128_to_bid128( + x, + ); + } + + late final _binary128_to_bid128Ptr = + _lookup>( + 'binary128_to_bid128'); + late final _binary128_to_bid128 = + _binary128_to_bid128Ptr.asFunction(); + + int binary128_to_bid32( + BID_UINT128 x, + ) { + return _binary128_to_bid32( + x, + ); + } + + late final _binary128_to_bid32Ptr = + _lookup>( + 'binary128_to_bid32'); + late final _binary128_to_bid32 = + _binary128_to_bid32Ptr.asFunction(); + + int binary128_to_bid64( + BID_UINT128 x, + ) { + return _binary128_to_bid64( + x, + ); + } + + late final _binary128_to_bid64Ptr = + _lookup>( + 'binary128_to_bid64'); + late final _binary128_to_bid64 = + _binary128_to_bid64Ptr.asFunction(); + + BID_UINT128 binary32_to_bid128( + double x, + ) { + return _binary32_to_bid128( + x, + ); + } + + late final _binary32_to_bid128Ptr = + _lookup>( + 'binary32_to_bid128'); + late final _binary32_to_bid128 = + _binary32_to_bid128Ptr.asFunction(); + + int binary32_to_bid32( + double x, + ) { + return _binary32_to_bid32( + x, + ); + } + + late final _binary32_to_bid32Ptr = + _lookup>( + 'binary32_to_bid32'); + late final _binary32_to_bid32 = + _binary32_to_bid32Ptr.asFunction(); + + int binary32_to_bid64( + double x, + ) { + return _binary32_to_bid64( + x, + ); + } + + late final _binary32_to_bid64Ptr = + _lookup>( + 'binary32_to_bid64'); + late final _binary32_to_bid64 = + _binary32_to_bid64Ptr.asFunction(); + + BID_UINT128 binary64_to_bid128( + double x, + ) { + return _binary64_to_bid128( + x, + ); + } + + late final _binary64_to_bid128Ptr = + _lookup>( + 'binary64_to_bid128'); + late final _binary64_to_bid128 = + _binary64_to_bid128Ptr.asFunction(); + + int binary64_to_bid32( + double x, + ) { + return _binary64_to_bid32( + x, + ); + } + + late final _binary64_to_bid32Ptr = + _lookup>( + 'binary64_to_bid32'); + late final _binary64_to_bid32 = + _binary64_to_bid32Ptr.asFunction(); + + int binary64_to_bid64( + double x, + ) { + return _binary64_to_bid64( + x, + ); + } + + late final _binary64_to_bid64Ptr = + _lookup>( + 'binary64_to_bid64'); + late final _binary64_to_bid64 = + _binary64_to_bid64Ptr.asFunction(); + /// Add a callback that will be invoked every time the view of this file is updated. /// /// This callback is guaranteed to be invoked before any object or collection change @@ -10569,6 +20444,156 @@ class _SymbolAddresses { get realm_release => _library._realm_releasePtr; } +const int BID128_MAXDIGITS = 34; + +const int BID32_MAXDIGITS = 7; + +const int BID64_MAXDIGITS = 16; + +const int BID_BIG_ENDIAN = 0; + +const int BID_DENORMAL_EXCEPTION = 2; + +const int BID_DENORMAL_MODE = 256; + +const int BID_EXACT_STATUS = 0; + +const int BID_FLAG_MASK = 63; + +const String BID_FMT_LLD = '%I64d'; + +const String BID_FMT_LLD16 = '%016I64d'; + +const String BID_FMT_LLU = '%I64u'; + +const String BID_FMT_LLU16 = '%016I64u'; + +const String BID_FMT_LLU4 = '%4I64u'; + +const String BID_FMT_LLX = '%I64x'; + +const String BID_FMT_LLX16 = '%016I64x'; + +const String BID_FMT_X4 = '%04x'; + +const String BID_FMT_X8 = '%08x'; + +const int BID_HAS_GCC_DECIMAL_INTRINSICS = 0; + +const int BID_HIGH_128W = 1; + +const int BID_IEEE_FLAGS = 61; + +const int BID_INEXACT_EXCEPTION = 32; + +const int BID_INEXACT_MODE = 4096; + +const int BID_INVALID_EXCEPTION = 1; + +const int BID_INVALID_MODE = 128; + +const String BID_LD = '%I64d'; + +const String BID_LD16 = '%016I64d'; + +const String BID_LD4 = '%4I64u'; + +const int BID_LOW_128W = 0; + +const String BID_LUD = '%I64u'; + +const String BID_LUD16 = '%016I64u'; + +const String BID_LX = '%I64x'; + +const String BID_LX16 = '%016I64x'; + +const int BID_MODE_MASK = 8064; + +const int BID_OVERFLOW_EXCEPTION = 8; + +const int BID_OVERFLOW_INEXACT_EXCEPTION = 40; + +const int BID_OVERFLOW_MODE = 1024; + +const int BID_RMODE_MASK = 7; + +const int BID_ROUNDING_DOWN = 1; + +const int BID_ROUNDING_TIES_AWAY = 4; + +const int BID_ROUNDING_TO_NEAREST = 0; + +const int BID_ROUNDING_TO_ZERO = 3; + +const int BID_ROUNDING_UP = 2; + +typedef BID_SINT64 = ffi.LongLong; + +const int BID_SIZE_LONG = 4; + +class BID_UINT128 extends ffi.Struct { + @ffi.Array.multi([2]) + external ffi.Array w; +} + +class BID_UINT192 extends ffi.Struct { + @ffi.Array.multi([3]) + external ffi.Array w; +} + +class BID_UINT256 extends ffi.Struct { + @ffi.Array.multi([4]) + external ffi.Array w; +} + +typedef BID_UINT32 = ffi.UnsignedInt; +typedef BID_UINT64 = ffi.UnsignedLongLong; + +const int BID_UNDERFLOW_EXCEPTION = 16; + +const int BID_UNDERFLOW_INEXACT_EXCEPTION = 48; + +const int BID_UNDERFLOW_MODE = 2048; + +const String BID_X4 = '%04x'; + +const String BID_X8 = '%08x'; + +const int BID_ZERO_DIVIDE_EXCEPTION = 4; + +const int BID_ZERO_DIVIDE_MODE = 512; + +const int BINARY_TINY_DETECTION_AFTER_ROUNDING = 1; + +const int DECIMAL_ALTERNATE_EXCEPTION_HANDLING = 0; + +const int DECIMAL_CALL_BY_REFERENCE = 1; + +const int DECIMAL_GLOBAL_EXCEPTION_FLAGS = 0; + +const int DECIMAL_GLOBAL_EXCEPTION_FLAGS_ACCESS_FUNCTIONS = 0; + +const int DECIMAL_GLOBAL_ROUNDING = 1; + +const int DECIMAL_GLOBAL_ROUNDING_ACCESS_FUNCTIONS = 0; + +const int DECIMAL_TINY_DETECTION_AFTER_ROUNDING = 0; + +const int DEC_FE_ALL_EXCEPT = 63; + +const int DEC_FE_DIVBYZERO = 4; + +const int DEC_FE_INEXACT = 32; + +const int DEC_FE_INVALID = 1; + +const int DEC_FE_OVERFLOW = 8; + +const int DEC_FE_UNDERFLOW = 16; + +const int DEC_FE_UNNORMAL = 2; + /// A port is used to send or receive inter-isolate messages typedef Dart_Port = ffi.Int64; @@ -10603,6 +20628,10 @@ class UnnamedUnion1 extends ffi.Union { external ffi.Array data; } +const int __ENABLE_BINARY80__ = 1; + +typedef fexcept_t = ffi.UnsignedShort; + class realm_app extends ffi.Opaque {} class realm_app_config extends ffi.Opaque {} From f83a1eb834e36ea9bb1cdcb1b41b1be269790f10 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Wed, 1 Mar 2023 22:37:53 +0100 Subject: [PATCH 02/30] WIP --- ffigen/config.yaml | 4 - lib/src/native/realm_bindings.dart | 10271 +-------------------------- lib/src/native/realm_core.dart | 2 + src/realm_dart.cpp | 84 + src/realm_dart.h | 14 + 5 files changed, 342 insertions(+), 10033 deletions(-) diff --git a/ffigen/config.yaml b/ffigen/config.yaml index 3505a7577..591384b1b 100644 --- a/ffigen/config.yaml +++ b/ffigen/config.yaml @@ -8,15 +8,11 @@ headers: - 'realm_dart.h' - 'realm_dart_scheduler.h' - 'realm_dart_sync.h' - - 'bid_conf.h' - - 'bid_functions.h' include-directives: #generate only for these headers - 'realm.h' - 'realm_dart.h' - 'realm_dart_scheduler.h' - 'realm_dart_sync.h' - - 'bid_conf.h' - - 'bid_functions.h' compiler-opts: - '-DRLM_NO_ANON_UNIONS' - '-DFFI_GEN' diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index 3f3adcffe..2906799d5 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -19,9881 +19,6 @@ class RealmLibrary { lookup) : _lookup = lookup; - BID_UINT128 bid128_abs( - BID_UINT128 x, - ) { - return _bid128_abs( - x, - ); - } - - late final _bid128_absPtr = - _lookup>( - 'bid128_abs'); - late final _bid128_abs = - _bid128_absPtr.asFunction(); - - BID_UINT128 bid128_acos( - BID_UINT128 x, - ) { - return _bid128_acos( - x, - ); - } - - late final _bid128_acosPtr = - _lookup>( - 'bid128_acos'); - late final _bid128_acos = - _bid128_acosPtr.asFunction(); - - BID_UINT128 bid128_acosh( - BID_UINT128 x, - ) { - return _bid128_acosh( - x, - ); - } - - late final _bid128_acoshPtr = - _lookup>( - 'bid128_acosh'); - late final _bid128_acosh = - _bid128_acoshPtr.asFunction(); - - BID_UINT128 bid128_add( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_add( - x, - y, - ); - } - - late final _bid128_addPtr = _lookup< - ffi.NativeFunction>( - 'bid128_add'); - late final _bid128_add = _bid128_addPtr - .asFunction(); - - BID_UINT128 bid128_asin( - BID_UINT128 x, - ) { - return _bid128_asin( - x, - ); - } - - late final _bid128_asinPtr = - _lookup>( - 'bid128_asin'); - late final _bid128_asin = - _bid128_asinPtr.asFunction(); - - BID_UINT128 bid128_asinh( - BID_UINT128 x, - ) { - return _bid128_asinh( - x, - ); - } - - late final _bid128_asinhPtr = - _lookup>( - 'bid128_asinh'); - late final _bid128_asinh = - _bid128_asinhPtr.asFunction(); - - BID_UINT128 bid128_atan( - BID_UINT128 x, - ) { - return _bid128_atan( - x, - ); - } - - late final _bid128_atanPtr = - _lookup>( - 'bid128_atan'); - late final _bid128_atan = - _bid128_atanPtr.asFunction(); - - BID_UINT128 bid128_atan2( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_atan2( - x, - y, - ); - } - - late final _bid128_atan2Ptr = _lookup< - ffi.NativeFunction>( - 'bid128_atan2'); - late final _bid128_atan2 = _bid128_atan2Ptr - .asFunction(); - - BID_UINT128 bid128_atanh( - BID_UINT128 x, - ) { - return _bid128_atanh( - x, - ); - } - - late final _bid128_atanhPtr = - _lookup>( - 'bid128_atanh'); - late final _bid128_atanh = - _bid128_atanhPtr.asFunction(); - - BID_UINT128 bid128_cbrt( - BID_UINT128 x, - ) { - return _bid128_cbrt( - x, - ); - } - - late final _bid128_cbrtPtr = - _lookup>( - 'bid128_cbrt'); - late final _bid128_cbrt = - _bid128_cbrtPtr.asFunction(); - - int bid128_class( - BID_UINT128 x, - ) { - return _bid128_class( - x, - ); - } - - late final _bid128_classPtr = - _lookup>( - 'bid128_class'); - late final _bid128_class = - _bid128_classPtr.asFunction(); - - BID_UINT128 bid128_copy( - BID_UINT128 x, - ) { - return _bid128_copy( - x, - ); - } - - late final _bid128_copyPtr = - _lookup>( - 'bid128_copy'); - late final _bid128_copy = - _bid128_copyPtr.asFunction(); - - BID_UINT128 bid128_copySign( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_copySign( - x, - y, - ); - } - - late final _bid128_copySignPtr = _lookup< - ffi.NativeFunction>( - 'bid128_copySign'); - late final _bid128_copySign = _bid128_copySignPtr - .asFunction(); - - BID_UINT128 bid128_cos( - BID_UINT128 x, - ) { - return _bid128_cos( - x, - ); - } - - late final _bid128_cosPtr = - _lookup>( - 'bid128_cos'); - late final _bid128_cos = - _bid128_cosPtr.asFunction(); - - BID_UINT128 bid128_cosh( - BID_UINT128 x, - ) { - return _bid128_cosh( - x, - ); - } - - late final _bid128_coshPtr = - _lookup>( - 'bid128_cosh'); - late final _bid128_cosh = - _bid128_coshPtr.asFunction(); - - BID_UINT128 bid128_div( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_div( - x, - y, - ); - } - - late final _bid128_divPtr = _lookup< - ffi.NativeFunction>( - 'bid128_div'); - late final _bid128_div = _bid128_divPtr - .asFunction(); - - BID_UINT128 bid128_erf( - BID_UINT128 x, - ) { - return _bid128_erf( - x, - ); - } - - late final _bid128_erfPtr = - _lookup>( - 'bid128_erf'); - late final _bid128_erf = - _bid128_erfPtr.asFunction(); - - BID_UINT128 bid128_erfc( - BID_UINT128 x, - ) { - return _bid128_erfc( - x, - ); - } - - late final _bid128_erfcPtr = - _lookup>( - 'bid128_erfc'); - late final _bid128_erfc = - _bid128_erfcPtr.asFunction(); - - BID_UINT128 bid128_exp( - BID_UINT128 x, - ) { - return _bid128_exp( - x, - ); - } - - late final _bid128_expPtr = - _lookup>( - 'bid128_exp'); - late final _bid128_exp = - _bid128_expPtr.asFunction(); - - BID_UINT128 bid128_exp10( - BID_UINT128 x, - ) { - return _bid128_exp10( - x, - ); - } - - late final _bid128_exp10Ptr = - _lookup>( - 'bid128_exp10'); - late final _bid128_exp10 = - _bid128_exp10Ptr.asFunction(); - - BID_UINT128 bid128_exp2( - BID_UINT128 x, - ) { - return _bid128_exp2( - x, - ); - } - - late final _bid128_exp2Ptr = - _lookup>( - 'bid128_exp2'); - late final _bid128_exp2 = - _bid128_exp2Ptr.asFunction(); - - BID_UINT128 bid128_expm1( - BID_UINT128 x, - ) { - return _bid128_expm1( - x, - ); - } - - late final _bid128_expm1Ptr = - _lookup>( - 'bid128_expm1'); - late final _bid128_expm1 = - _bid128_expm1Ptr.asFunction(); - - BID_UINT128 bid128_fdim( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_fdim( - x, - y, - ); - } - - late final _bid128_fdimPtr = _lookup< - ffi.NativeFunction>( - 'bid128_fdim'); - late final _bid128_fdim = _bid128_fdimPtr - .asFunction(); - - BID_UINT128 bid128_fma( - BID_UINT128 x, - BID_UINT128 y, - BID_UINT128 z, - ) { - return _bid128_fma( - x, - y, - z, - ); - } - - late final _bid128_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT128, BID_UINT128, BID_UINT128)>>('bid128_fma'); - late final _bid128_fma = _bid128_fmaPtr.asFunction< - BID_UINT128 Function(BID_UINT128, BID_UINT128, BID_UINT128)>(); - - BID_UINT128 bid128_fmod( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_fmod( - x, - y, - ); - } - - late final _bid128_fmodPtr = _lookup< - ffi.NativeFunction>( - 'bid128_fmod'); - late final _bid128_fmod = _bid128_fmodPtr - .asFunction(); - - BID_UINT128 bid128_frexp( - BID_UINT128 x, - ffi.Pointer exp, - ) { - return _bid128_frexp( - x, - exp, - ); - } - - late final _bid128_frexpPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT128, ffi.Pointer)>>('bid128_frexp'); - late final _bid128_frexp = _bid128_frexpPtr - .asFunction)>(); - - BID_UINT128 bid128_from_int32( - int x, - ) { - return _bid128_from_int32( - x, - ); - } - - late final _bid128_from_int32Ptr = - _lookup>( - 'bid128_from_int32'); - late final _bid128_from_int32 = - _bid128_from_int32Ptr.asFunction(); - - BID_UINT128 bid128_from_int64( - int x, - ) { - return _bid128_from_int64( - x, - ); - } - - late final _bid128_from_int64Ptr = - _lookup>( - 'bid128_from_int64'); - late final _bid128_from_int64 = - _bid128_from_int64Ptr.asFunction(); - - BID_UINT128 bid128_from_string( - ffi.Pointer ps, - ) { - return _bid128_from_string( - ps, - ); - } - - late final _bid128_from_stringPtr = - _lookup)>>( - 'bid128_from_string'); - late final _bid128_from_string = _bid128_from_stringPtr - .asFunction)>(); - - BID_UINT128 bid128_from_uint32( - int x, - ) { - return _bid128_from_uint32( - x, - ); - } - - late final _bid128_from_uint32Ptr = - _lookup>( - 'bid128_from_uint32'); - late final _bid128_from_uint32 = - _bid128_from_uint32Ptr.asFunction(); - - BID_UINT128 bid128_from_uint64( - int x, - ) { - return _bid128_from_uint64( - x, - ); - } - - late final _bid128_from_uint64Ptr = - _lookup>( - 'bid128_from_uint64'); - late final _bid128_from_uint64 = - _bid128_from_uint64Ptr.asFunction(); - - BID_UINT128 bid128_hypot( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_hypot( - x, - y, - ); - } - - late final _bid128_hypotPtr = _lookup< - ffi.NativeFunction>( - 'bid128_hypot'); - late final _bid128_hypot = _bid128_hypotPtr - .asFunction(); - - int bid128_ilogb( - BID_UINT128 x, - ) { - return _bid128_ilogb( - x, - ); - } - - late final _bid128_ilogbPtr = - _lookup>( - 'bid128_ilogb'); - late final _bid128_ilogb = - _bid128_ilogbPtr.asFunction(); - - BID_UINT128 bid128_inf() { - return _bid128_inf(); - } - - late final _bid128_infPtr = - _lookup>('bid128_inf'); - late final _bid128_inf = _bid128_infPtr.asFunction(); - - int bid128_isCanonical( - BID_UINT128 x, - ) { - return _bid128_isCanonical( - x, - ); - } - - late final _bid128_isCanonicalPtr = - _lookup>( - 'bid128_isCanonical'); - late final _bid128_isCanonical = - _bid128_isCanonicalPtr.asFunction(); - - int bid128_isFinite( - BID_UINT128 x, - ) { - return _bid128_isFinite( - x, - ); - } - - late final _bid128_isFinitePtr = - _lookup>( - 'bid128_isFinite'); - late final _bid128_isFinite = - _bid128_isFinitePtr.asFunction(); - - int bid128_isInf( - BID_UINT128 x, - ) { - return _bid128_isInf( - x, - ); - } - - late final _bid128_isInfPtr = - _lookup>( - 'bid128_isInf'); - late final _bid128_isInf = - _bid128_isInfPtr.asFunction(); - - int bid128_isNaN( - BID_UINT128 x, - ) { - return _bid128_isNaN( - x, - ); - } - - late final _bid128_isNaNPtr = - _lookup>( - 'bid128_isNaN'); - late final _bid128_isNaN = - _bid128_isNaNPtr.asFunction(); - - int bid128_isNormal( - BID_UINT128 x, - ) { - return _bid128_isNormal( - x, - ); - } - - late final _bid128_isNormalPtr = - _lookup>( - 'bid128_isNormal'); - late final _bid128_isNormal = - _bid128_isNormalPtr.asFunction(); - - int bid128_isSignaling( - BID_UINT128 x, - ) { - return _bid128_isSignaling( - x, - ); - } - - late final _bid128_isSignalingPtr = - _lookup>( - 'bid128_isSignaling'); - late final _bid128_isSignaling = - _bid128_isSignalingPtr.asFunction(); - - int bid128_isSigned( - BID_UINT128 x, - ) { - return _bid128_isSigned( - x, - ); - } - - late final _bid128_isSignedPtr = - _lookup>( - 'bid128_isSigned'); - late final _bid128_isSigned = - _bid128_isSignedPtr.asFunction(); - - int bid128_isSubnormal( - BID_UINT128 x, - ) { - return _bid128_isSubnormal( - x, - ); - } - - late final _bid128_isSubnormalPtr = - _lookup>( - 'bid128_isSubnormal'); - late final _bid128_isSubnormal = - _bid128_isSubnormalPtr.asFunction(); - - int bid128_isZero( - BID_UINT128 x, - ) { - return _bid128_isZero( - x, - ); - } - - late final _bid128_isZeroPtr = - _lookup>( - 'bid128_isZero'); - late final _bid128_isZero = - _bid128_isZeroPtr.asFunction(); - - BID_UINT128 bid128_ldexp( - BID_UINT128 x, - int n, - ) { - return _bid128_ldexp( - x, - n, - ); - } - - late final _bid128_ldexpPtr = - _lookup>( - 'bid128_ldexp'); - late final _bid128_ldexp = - _bid128_ldexpPtr.asFunction(); - - BID_UINT128 bid128_lgamma( - BID_UINT128 x, - ) { - return _bid128_lgamma( - x, - ); - } - - late final _bid128_lgammaPtr = - _lookup>( - 'bid128_lgamma'); - late final _bid128_lgamma = - _bid128_lgammaPtr.asFunction(); - - int bid128_llquantexp( - BID_UINT128 x, - ) { - return _bid128_llquantexp( - x, - ); - } - - late final _bid128_llquantexpPtr = - _lookup>( - 'bid128_llquantexp'); - late final _bid128_llquantexp = - _bid128_llquantexpPtr.asFunction(); - - int bid128_llrint( - BID_UINT128 x, - ) { - return _bid128_llrint( - x, - ); - } - - late final _bid128_llrintPtr = - _lookup>( - 'bid128_llrint'); - late final _bid128_llrint = - _bid128_llrintPtr.asFunction(); - - int bid128_llround( - BID_UINT128 x, - ) { - return _bid128_llround( - x, - ); - } - - late final _bid128_llroundPtr = - _lookup>( - 'bid128_llround'); - late final _bid128_llround = - _bid128_llroundPtr.asFunction(); - - BID_UINT128 bid128_log( - BID_UINT128 x, - ) { - return _bid128_log( - x, - ); - } - - late final _bid128_logPtr = - _lookup>( - 'bid128_log'); - late final _bid128_log = - _bid128_logPtr.asFunction(); - - BID_UINT128 bid128_log10( - BID_UINT128 x, - ) { - return _bid128_log10( - x, - ); - } - - late final _bid128_log10Ptr = - _lookup>( - 'bid128_log10'); - late final _bid128_log10 = - _bid128_log10Ptr.asFunction(); - - BID_UINT128 bid128_log1p( - BID_UINT128 x, - ) { - return _bid128_log1p( - x, - ); - } - - late final _bid128_log1pPtr = - _lookup>( - 'bid128_log1p'); - late final _bid128_log1p = - _bid128_log1pPtr.asFunction(); - - BID_UINT128 bid128_log2( - BID_UINT128 x, - ) { - return _bid128_log2( - x, - ); - } - - late final _bid128_log2Ptr = - _lookup>( - 'bid128_log2'); - late final _bid128_log2 = - _bid128_log2Ptr.asFunction(); - - BID_UINT128 bid128_logb( - BID_UINT128 x, - ) { - return _bid128_logb( - x, - ); - } - - late final _bid128_logbPtr = - _lookup>( - 'bid128_logb'); - late final _bid128_logb = - _bid128_logbPtr.asFunction(); - - int bid128_lrint( - BID_UINT128 x, - ) { - return _bid128_lrint( - x, - ); - } - - late final _bid128_lrintPtr = - _lookup>( - 'bid128_lrint'); - late final _bid128_lrint = - _bid128_lrintPtr.asFunction(); - - int bid128_lround( - BID_UINT128 x, - ) { - return _bid128_lround( - x, - ); - } - - late final _bid128_lroundPtr = - _lookup>( - 'bid128_lround'); - late final _bid128_lround = - _bid128_lroundPtr.asFunction(); - - BID_UINT128 bid128_maxnum( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_maxnum( - x, - y, - ); - } - - late final _bid128_maxnumPtr = _lookup< - ffi.NativeFunction>( - 'bid128_maxnum'); - late final _bid128_maxnum = _bid128_maxnumPtr - .asFunction(); - - BID_UINT128 bid128_maxnum_mag( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_maxnum_mag( - x, - y, - ); - } - - late final _bid128_maxnum_magPtr = _lookup< - ffi.NativeFunction>( - 'bid128_maxnum_mag'); - late final _bid128_maxnum_mag = _bid128_maxnum_magPtr - .asFunction(); - - BID_UINT128 bid128_minnum( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_minnum( - x, - y, - ); - } - - late final _bid128_minnumPtr = _lookup< - ffi.NativeFunction>( - 'bid128_minnum'); - late final _bid128_minnum = _bid128_minnumPtr - .asFunction(); - - BID_UINT128 bid128_minnum_mag( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_minnum_mag( - x, - y, - ); - } - - late final _bid128_minnum_magPtr = _lookup< - ffi.NativeFunction>( - 'bid128_minnum_mag'); - late final _bid128_minnum_mag = _bid128_minnum_magPtr - .asFunction(); - - BID_UINT128 bid128_modf( - BID_UINT128 x, - ffi.Pointer y, - ) { - return _bid128_modf( - x, - y, - ); - } - - late final _bid128_modfPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT128, ffi.Pointer)>>('bid128_modf'); - late final _bid128_modf = _bid128_modfPtr.asFunction< - BID_UINT128 Function(BID_UINT128, ffi.Pointer)>(); - - BID_UINT128 bid128_mul( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_mul( - x, - y, - ); - } - - late final _bid128_mulPtr = _lookup< - ffi.NativeFunction>( - 'bid128_mul'); - late final _bid128_mul = _bid128_mulPtr - .asFunction(); - - BID_UINT128 bid128_nan( - ffi.Pointer tagp, - ) { - return _bid128_nan( - tagp, - ); - } - - late final _bid128_nanPtr = - _lookup)>>( - 'bid128_nan'); - late final _bid128_nan = - _bid128_nanPtr.asFunction)>(); - - BID_UINT128 bid128_nearbyint( - BID_UINT128 x, - ) { - return _bid128_nearbyint( - x, - ); - } - - late final _bid128_nearbyintPtr = - _lookup>( - 'bid128_nearbyint'); - late final _bid128_nearbyint = - _bid128_nearbyintPtr.asFunction(); - - BID_UINT128 bid128_negate( - BID_UINT128 x, - ) { - return _bid128_negate( - x, - ); - } - - late final _bid128_negatePtr = - _lookup>( - 'bid128_negate'); - late final _bid128_negate = - _bid128_negatePtr.asFunction(); - - BID_UINT128 bid128_nextafter( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_nextafter( - x, - y, - ); - } - - late final _bid128_nextafterPtr = _lookup< - ffi.NativeFunction>( - 'bid128_nextafter'); - late final _bid128_nextafter = _bid128_nextafterPtr - .asFunction(); - - BID_UINT128 bid128_nextdown( - BID_UINT128 x, - ) { - return _bid128_nextdown( - x, - ); - } - - late final _bid128_nextdownPtr = - _lookup>( - 'bid128_nextdown'); - late final _bid128_nextdown = - _bid128_nextdownPtr.asFunction(); - - BID_UINT128 bid128_nexttoward( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_nexttoward( - x, - y, - ); - } - - late final _bid128_nexttowardPtr = _lookup< - ffi.NativeFunction>( - 'bid128_nexttoward'); - late final _bid128_nexttoward = _bid128_nexttowardPtr - .asFunction(); - - BID_UINT128 bid128_nextup( - BID_UINT128 x, - ) { - return _bid128_nextup( - x, - ); - } - - late final _bid128_nextupPtr = - _lookup>( - 'bid128_nextup'); - late final _bid128_nextup = - _bid128_nextupPtr.asFunction(); - - BID_UINT128 bid128_pow( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_pow( - x, - y, - ); - } - - late final _bid128_powPtr = _lookup< - ffi.NativeFunction>( - 'bid128_pow'); - late final _bid128_pow = _bid128_powPtr - .asFunction(); - - int bid128_quantexp( - BID_UINT128 x, - ) { - return _bid128_quantexp( - x, - ); - } - - late final _bid128_quantexpPtr = - _lookup>( - 'bid128_quantexp'); - late final _bid128_quantexp = - _bid128_quantexpPtr.asFunction(); - - BID_UINT128 bid128_quantize( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quantize( - x, - y, - ); - } - - late final _bid128_quantizePtr = _lookup< - ffi.NativeFunction>( - 'bid128_quantize'); - late final _bid128_quantize = _bid128_quantizePtr - .asFunction(); - - BID_UINT128 bid128_quantum( - BID_UINT128 x, - ) { - return _bid128_quantum( - x, - ); - } - - late final _bid128_quantumPtr = - _lookup>( - 'bid128_quantum'); - late final _bid128_quantum = - _bid128_quantumPtr.asFunction(); - - int bid128_quiet_equal( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_equal( - x, - y, - ); - } - - late final _bid128_quiet_equalPtr = - _lookup>( - 'bid128_quiet_equal'); - late final _bid128_quiet_equal = _bid128_quiet_equalPtr - .asFunction(); - - int bid128_quiet_greater( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_greater( - x, - y, - ); - } - - late final _bid128_quiet_greaterPtr = - _lookup>( - 'bid128_quiet_greater'); - late final _bid128_quiet_greater = _bid128_quiet_greaterPtr - .asFunction(); - - int bid128_quiet_greater_equal( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_greater_equal( - x, - y, - ); - } - - late final _bid128_quiet_greater_equalPtr = - _lookup>( - 'bid128_quiet_greater_equal'); - late final _bid128_quiet_greater_equal = _bid128_quiet_greater_equalPtr - .asFunction(); - - int bid128_quiet_greater_unordered( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_greater_unordered( - x, - y, - ); - } - - late final _bid128_quiet_greater_unorderedPtr = - _lookup>( - 'bid128_quiet_greater_unordered'); - late final _bid128_quiet_greater_unordered = - _bid128_quiet_greater_unorderedPtr - .asFunction(); - - int bid128_quiet_less( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_less( - x, - y, - ); - } - - late final _bid128_quiet_lessPtr = - _lookup>( - 'bid128_quiet_less'); - late final _bid128_quiet_less = _bid128_quiet_lessPtr - .asFunction(); - - int bid128_quiet_less_equal( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_less_equal( - x, - y, - ); - } - - late final _bid128_quiet_less_equalPtr = - _lookup>( - 'bid128_quiet_less_equal'); - late final _bid128_quiet_less_equal = _bid128_quiet_less_equalPtr - .asFunction(); - - int bid128_quiet_less_unordered( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_less_unordered( - x, - y, - ); - } - - late final _bid128_quiet_less_unorderedPtr = - _lookup>( - 'bid128_quiet_less_unordered'); - late final _bid128_quiet_less_unordered = _bid128_quiet_less_unorderedPtr - .asFunction(); - - int bid128_quiet_not_equal( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_not_equal( - x, - y, - ); - } - - late final _bid128_quiet_not_equalPtr = - _lookup>( - 'bid128_quiet_not_equal'); - late final _bid128_quiet_not_equal = _bid128_quiet_not_equalPtr - .asFunction(); - - int bid128_quiet_not_greater( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_not_greater( - x, - y, - ); - } - - late final _bid128_quiet_not_greaterPtr = - _lookup>( - 'bid128_quiet_not_greater'); - late final _bid128_quiet_not_greater = _bid128_quiet_not_greaterPtr - .asFunction(); - - int bid128_quiet_not_less( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_not_less( - x, - y, - ); - } - - late final _bid128_quiet_not_lessPtr = - _lookup>( - 'bid128_quiet_not_less'); - late final _bid128_quiet_not_less = _bid128_quiet_not_lessPtr - .asFunction(); - - int bid128_quiet_ordered( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_ordered( - x, - y, - ); - } - - late final _bid128_quiet_orderedPtr = - _lookup>( - 'bid128_quiet_ordered'); - late final _bid128_quiet_ordered = _bid128_quiet_orderedPtr - .asFunction(); - - int bid128_quiet_unordered( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_quiet_unordered( - x, - y, - ); - } - - late final _bid128_quiet_unorderedPtr = - _lookup>( - 'bid128_quiet_unordered'); - late final _bid128_quiet_unordered = _bid128_quiet_unorderedPtr - .asFunction(); - - int bid128_radix( - BID_UINT128 x, - ) { - return _bid128_radix( - x, - ); - } - - late final _bid128_radixPtr = - _lookup>( - 'bid128_radix'); - late final _bid128_radix = - _bid128_radixPtr.asFunction(); - - BID_UINT128 bid128_rem( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_rem( - x, - y, - ); - } - - late final _bid128_remPtr = _lookup< - ffi.NativeFunction>( - 'bid128_rem'); - late final _bid128_rem = _bid128_remPtr - .asFunction(); - - BID_UINT128 bid128_round_integral_exact( - BID_UINT128 x, - ) { - return _bid128_round_integral_exact( - x, - ); - } - - late final _bid128_round_integral_exactPtr = - _lookup>( - 'bid128_round_integral_exact'); - late final _bid128_round_integral_exact = _bid128_round_integral_exactPtr - .asFunction(); - - BID_UINT128 bid128_round_integral_nearest_away( - BID_UINT128 x, - ) { - return _bid128_round_integral_nearest_away( - x, - ); - } - - late final _bid128_round_integral_nearest_awayPtr = - _lookup>( - 'bid128_round_integral_nearest_away'); - late final _bid128_round_integral_nearest_away = - _bid128_round_integral_nearest_awayPtr - .asFunction(); - - BID_UINT128 bid128_round_integral_nearest_even( - BID_UINT128 x, - ) { - return _bid128_round_integral_nearest_even( - x, - ); - } - - late final _bid128_round_integral_nearest_evenPtr = - _lookup>( - 'bid128_round_integral_nearest_even'); - late final _bid128_round_integral_nearest_even = - _bid128_round_integral_nearest_evenPtr - .asFunction(); - - BID_UINT128 bid128_round_integral_negative( - BID_UINT128 x, - ) { - return _bid128_round_integral_negative( - x, - ); - } - - late final _bid128_round_integral_negativePtr = - _lookup>( - 'bid128_round_integral_negative'); - late final _bid128_round_integral_negative = - _bid128_round_integral_negativePtr - .asFunction(); - - BID_UINT128 bid128_round_integral_positive( - BID_UINT128 x, - ) { - return _bid128_round_integral_positive( - x, - ); - } - - late final _bid128_round_integral_positivePtr = - _lookup>( - 'bid128_round_integral_positive'); - late final _bid128_round_integral_positive = - _bid128_round_integral_positivePtr - .asFunction(); - - BID_UINT128 bid128_round_integral_zero( - BID_UINT128 x, - ) { - return _bid128_round_integral_zero( - x, - ); - } - - late final _bid128_round_integral_zeroPtr = - _lookup>( - 'bid128_round_integral_zero'); - late final _bid128_round_integral_zero = _bid128_round_integral_zeroPtr - .asFunction(); - - int bid128_sameQuantum( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_sameQuantum( - x, - y, - ); - } - - late final _bid128_sameQuantumPtr = - _lookup>( - 'bid128_sameQuantum'); - late final _bid128_sameQuantum = _bid128_sameQuantumPtr - .asFunction(); - - BID_UINT128 bid128_scalbln( - BID_UINT128 x, - int n, - ) { - return _bid128_scalbln( - x, - n, - ); - } - - late final _bid128_scalblnPtr = - _lookup>( - 'bid128_scalbln'); - late final _bid128_scalbln = - _bid128_scalblnPtr.asFunction(); - - BID_UINT128 bid128_scalbn( - BID_UINT128 x, - int n, - ) { - return _bid128_scalbn( - x, - n, - ); - } - - late final _bid128_scalbnPtr = - _lookup>( - 'bid128_scalbn'); - late final _bid128_scalbn = - _bid128_scalbnPtr.asFunction(); - - int bid128_signaling_greater( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_signaling_greater( - x, - y, - ); - } - - late final _bid128_signaling_greaterPtr = - _lookup>( - 'bid128_signaling_greater'); - late final _bid128_signaling_greater = _bid128_signaling_greaterPtr - .asFunction(); - - int bid128_signaling_greater_equal( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_signaling_greater_equal( - x, - y, - ); - } - - late final _bid128_signaling_greater_equalPtr = - _lookup>( - 'bid128_signaling_greater_equal'); - late final _bid128_signaling_greater_equal = - _bid128_signaling_greater_equalPtr - .asFunction(); - - int bid128_signaling_greater_unordered( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_signaling_greater_unordered( - x, - y, - ); - } - - late final _bid128_signaling_greater_unorderedPtr = - _lookup>( - 'bid128_signaling_greater_unordered'); - late final _bid128_signaling_greater_unordered = - _bid128_signaling_greater_unorderedPtr - .asFunction(); - - int bid128_signaling_less( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_signaling_less( - x, - y, - ); - } - - late final _bid128_signaling_lessPtr = - _lookup>( - 'bid128_signaling_less'); - late final _bid128_signaling_less = _bid128_signaling_lessPtr - .asFunction(); - - int bid128_signaling_less_equal( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_signaling_less_equal( - x, - y, - ); - } - - late final _bid128_signaling_less_equalPtr = - _lookup>( - 'bid128_signaling_less_equal'); - late final _bid128_signaling_less_equal = _bid128_signaling_less_equalPtr - .asFunction(); - - int bid128_signaling_less_unordered( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_signaling_less_unordered( - x, - y, - ); - } - - late final _bid128_signaling_less_unorderedPtr = - _lookup>( - 'bid128_signaling_less_unordered'); - late final _bid128_signaling_less_unordered = - _bid128_signaling_less_unorderedPtr - .asFunction(); - - int bid128_signaling_not_greater( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_signaling_not_greater( - x, - y, - ); - } - - late final _bid128_signaling_not_greaterPtr = - _lookup>( - 'bid128_signaling_not_greater'); - late final _bid128_signaling_not_greater = _bid128_signaling_not_greaterPtr - .asFunction(); - - int bid128_signaling_not_less( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_signaling_not_less( - x, - y, - ); - } - - late final _bid128_signaling_not_lessPtr = - _lookup>( - 'bid128_signaling_not_less'); - late final _bid128_signaling_not_less = _bid128_signaling_not_lessPtr - .asFunction(); - - BID_UINT128 bid128_sin( - BID_UINT128 x, - ) { - return _bid128_sin( - x, - ); - } - - late final _bid128_sinPtr = - _lookup>( - 'bid128_sin'); - late final _bid128_sin = - _bid128_sinPtr.asFunction(); - - BID_UINT128 bid128_sinh( - BID_UINT128 x, - ) { - return _bid128_sinh( - x, - ); - } - - late final _bid128_sinhPtr = - _lookup>( - 'bid128_sinh'); - late final _bid128_sinh = - _bid128_sinhPtr.asFunction(); - - BID_UINT128 bid128_sqrt( - BID_UINT128 x, - ) { - return _bid128_sqrt( - x, - ); - } - - late final _bid128_sqrtPtr = - _lookup>( - 'bid128_sqrt'); - late final _bid128_sqrt = - _bid128_sqrtPtr.asFunction(); - - BID_UINT128 bid128_sub( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_sub( - x, - y, - ); - } - - late final _bid128_subPtr = _lookup< - ffi.NativeFunction>( - 'bid128_sub'); - late final _bid128_sub = _bid128_subPtr - .asFunction(); - - BID_UINT128 bid128_tan( - BID_UINT128 x, - ) { - return _bid128_tan( - x, - ); - } - - late final _bid128_tanPtr = - _lookup>( - 'bid128_tan'); - late final _bid128_tan = - _bid128_tanPtr.asFunction(); - - BID_UINT128 bid128_tanh( - BID_UINT128 x, - ) { - return _bid128_tanh( - x, - ); - } - - late final _bid128_tanhPtr = - _lookup>( - 'bid128_tanh'); - late final _bid128_tanh = - _bid128_tanhPtr.asFunction(); - - BID_UINT128 bid128_tgamma( - BID_UINT128 x, - ) { - return _bid128_tgamma( - x, - ); - } - - late final _bid128_tgammaPtr = - _lookup>( - 'bid128_tgamma'); - late final _bid128_tgamma = - _bid128_tgammaPtr.asFunction(); - - int bid128_to_bid32( - BID_UINT128 x, - ) { - return _bid128_to_bid32( - x, - ); - } - - late final _bid128_to_bid32Ptr = - _lookup>( - 'bid128_to_bid32'); - late final _bid128_to_bid32 = - _bid128_to_bid32Ptr.asFunction(); - - int bid128_to_bid64( - BID_UINT128 x, - ) { - return _bid128_to_bid64( - x, - ); - } - - late final _bid128_to_bid64Ptr = - _lookup>( - 'bid128_to_bid64'); - late final _bid128_to_bid64 = - _bid128_to_bid64Ptr.asFunction(); - - BID_UINT128 bid128_to_binary128( - BID_UINT128 x, - ) { - return _bid128_to_binary128( - x, - ); - } - - late final _bid128_to_binary128Ptr = - _lookup>( - 'bid128_to_binary128'); - late final _bid128_to_binary128 = - _bid128_to_binary128Ptr.asFunction(); - - double bid128_to_binary32( - BID_UINT128 x, - ) { - return _bid128_to_binary32( - x, - ); - } - - late final _bid128_to_binary32Ptr = - _lookup>( - 'bid128_to_binary32'); - late final _bid128_to_binary32 = - _bid128_to_binary32Ptr.asFunction(); - - double bid128_to_binary64( - BID_UINT128 x, - ) { - return _bid128_to_binary64( - x, - ); - } - - late final _bid128_to_binary64Ptr = - _lookup>( - 'bid128_to_binary64'); - late final _bid128_to_binary64 = - _bid128_to_binary64Ptr.asFunction(); - - int bid128_to_int16_ceil( - BID_UINT128 x, - ) { - return _bid128_to_int16_ceil( - x, - ); - } - - late final _bid128_to_int16_ceilPtr = - _lookup>( - 'bid128_to_int16_ceil'); - late final _bid128_to_int16_ceil = - _bid128_to_int16_ceilPtr.asFunction(); - - int bid128_to_int16_floor( - BID_UINT128 x, - ) { - return _bid128_to_int16_floor( - x, - ); - } - - late final _bid128_to_int16_floorPtr = - _lookup>( - 'bid128_to_int16_floor'); - late final _bid128_to_int16_floor = - _bid128_to_int16_floorPtr.asFunction(); - - int bid128_to_int16_int( - BID_UINT128 x, - ) { - return _bid128_to_int16_int( - x, - ); - } - - late final _bid128_to_int16_intPtr = - _lookup>( - 'bid128_to_int16_int'); - late final _bid128_to_int16_int = - _bid128_to_int16_intPtr.asFunction(); - - int bid128_to_int16_rnint( - BID_UINT128 x, - ) { - return _bid128_to_int16_rnint( - x, - ); - } - - late final _bid128_to_int16_rnintPtr = - _lookup>( - 'bid128_to_int16_rnint'); - late final _bid128_to_int16_rnint = - _bid128_to_int16_rnintPtr.asFunction(); - - int bid128_to_int16_rninta( - BID_UINT128 x, - ) { - return _bid128_to_int16_rninta( - x, - ); - } - - late final _bid128_to_int16_rnintaPtr = - _lookup>( - 'bid128_to_int16_rninta'); - late final _bid128_to_int16_rninta = - _bid128_to_int16_rnintaPtr.asFunction(); - - int bid128_to_int16_xceil( - BID_UINT128 x, - ) { - return _bid128_to_int16_xceil( - x, - ); - } - - late final _bid128_to_int16_xceilPtr = - _lookup>( - 'bid128_to_int16_xceil'); - late final _bid128_to_int16_xceil = - _bid128_to_int16_xceilPtr.asFunction(); - - int bid128_to_int16_xfloor( - BID_UINT128 x, - ) { - return _bid128_to_int16_xfloor( - x, - ); - } - - late final _bid128_to_int16_xfloorPtr = - _lookup>( - 'bid128_to_int16_xfloor'); - late final _bid128_to_int16_xfloor = - _bid128_to_int16_xfloorPtr.asFunction(); - - int bid128_to_int16_xint( - BID_UINT128 x, - ) { - return _bid128_to_int16_xint( - x, - ); - } - - late final _bid128_to_int16_xintPtr = - _lookup>( - 'bid128_to_int16_xint'); - late final _bid128_to_int16_xint = - _bid128_to_int16_xintPtr.asFunction(); - - int bid128_to_int16_xrnint( - BID_UINT128 x, - ) { - return _bid128_to_int16_xrnint( - x, - ); - } - - late final _bid128_to_int16_xrnintPtr = - _lookup>( - 'bid128_to_int16_xrnint'); - late final _bid128_to_int16_xrnint = - _bid128_to_int16_xrnintPtr.asFunction(); - - int bid128_to_int16_xrninta( - BID_UINT128 x, - ) { - return _bid128_to_int16_xrninta( - x, - ); - } - - late final _bid128_to_int16_xrnintaPtr = - _lookup>( - 'bid128_to_int16_xrninta'); - late final _bid128_to_int16_xrninta = - _bid128_to_int16_xrnintaPtr.asFunction(); - - int bid128_to_int32_ceil( - BID_UINT128 x, - ) { - return _bid128_to_int32_ceil( - x, - ); - } - - late final _bid128_to_int32_ceilPtr = - _lookup>( - 'bid128_to_int32_ceil'); - late final _bid128_to_int32_ceil = - _bid128_to_int32_ceilPtr.asFunction(); - - int bid128_to_int32_floor( - BID_UINT128 x, - ) { - return _bid128_to_int32_floor( - x, - ); - } - - late final _bid128_to_int32_floorPtr = - _lookup>( - 'bid128_to_int32_floor'); - late final _bid128_to_int32_floor = - _bid128_to_int32_floorPtr.asFunction(); - - int bid128_to_int32_int( - BID_UINT128 x, - ) { - return _bid128_to_int32_int( - x, - ); - } - - late final _bid128_to_int32_intPtr = - _lookup>( - 'bid128_to_int32_int'); - late final _bid128_to_int32_int = - _bid128_to_int32_intPtr.asFunction(); - - int bid128_to_int32_rnint( - BID_UINT128 x, - ) { - return _bid128_to_int32_rnint( - x, - ); - } - - late final _bid128_to_int32_rnintPtr = - _lookup>( - 'bid128_to_int32_rnint'); - late final _bid128_to_int32_rnint = - _bid128_to_int32_rnintPtr.asFunction(); - - int bid128_to_int32_rninta( - BID_UINT128 x, - ) { - return _bid128_to_int32_rninta( - x, - ); - } - - late final _bid128_to_int32_rnintaPtr = - _lookup>( - 'bid128_to_int32_rninta'); - late final _bid128_to_int32_rninta = - _bid128_to_int32_rnintaPtr.asFunction(); - - int bid128_to_int32_xceil( - BID_UINT128 x, - ) { - return _bid128_to_int32_xceil( - x, - ); - } - - late final _bid128_to_int32_xceilPtr = - _lookup>( - 'bid128_to_int32_xceil'); - late final _bid128_to_int32_xceil = - _bid128_to_int32_xceilPtr.asFunction(); - - int bid128_to_int32_xfloor( - BID_UINT128 x, - ) { - return _bid128_to_int32_xfloor( - x, - ); - } - - late final _bid128_to_int32_xfloorPtr = - _lookup>( - 'bid128_to_int32_xfloor'); - late final _bid128_to_int32_xfloor = - _bid128_to_int32_xfloorPtr.asFunction(); - - int bid128_to_int32_xint( - BID_UINT128 x, - ) { - return _bid128_to_int32_xint( - x, - ); - } - - late final _bid128_to_int32_xintPtr = - _lookup>( - 'bid128_to_int32_xint'); - late final _bid128_to_int32_xint = - _bid128_to_int32_xintPtr.asFunction(); - - int bid128_to_int32_xrnint( - BID_UINT128 x, - ) { - return _bid128_to_int32_xrnint( - x, - ); - } - - late final _bid128_to_int32_xrnintPtr = - _lookup>( - 'bid128_to_int32_xrnint'); - late final _bid128_to_int32_xrnint = - _bid128_to_int32_xrnintPtr.asFunction(); - - int bid128_to_int32_xrninta( - BID_UINT128 x, - ) { - return _bid128_to_int32_xrninta( - x, - ); - } - - late final _bid128_to_int32_xrnintaPtr = - _lookup>( - 'bid128_to_int32_xrninta'); - late final _bid128_to_int32_xrninta = - _bid128_to_int32_xrnintaPtr.asFunction(); - - int bid128_to_int64_ceil( - BID_UINT128 x, - ) { - return _bid128_to_int64_ceil( - x, - ); - } - - late final _bid128_to_int64_ceilPtr = - _lookup>( - 'bid128_to_int64_ceil'); - late final _bid128_to_int64_ceil = - _bid128_to_int64_ceilPtr.asFunction(); - - int bid128_to_int64_floor( - BID_UINT128 x, - ) { - return _bid128_to_int64_floor( - x, - ); - } - - late final _bid128_to_int64_floorPtr = - _lookup>( - 'bid128_to_int64_floor'); - late final _bid128_to_int64_floor = - _bid128_to_int64_floorPtr.asFunction(); - - int bid128_to_int64_int( - BID_UINT128 x, - ) { - return _bid128_to_int64_int( - x, - ); - } - - late final _bid128_to_int64_intPtr = - _lookup>( - 'bid128_to_int64_int'); - late final _bid128_to_int64_int = - _bid128_to_int64_intPtr.asFunction(); - - int bid128_to_int64_rnint( - BID_UINT128 x, - ) { - return _bid128_to_int64_rnint( - x, - ); - } - - late final _bid128_to_int64_rnintPtr = - _lookup>( - 'bid128_to_int64_rnint'); - late final _bid128_to_int64_rnint = - _bid128_to_int64_rnintPtr.asFunction(); - - int bid128_to_int64_rninta( - BID_UINT128 x, - ) { - return _bid128_to_int64_rninta( - x, - ); - } - - late final _bid128_to_int64_rnintaPtr = - _lookup>( - 'bid128_to_int64_rninta'); - late final _bid128_to_int64_rninta = - _bid128_to_int64_rnintaPtr.asFunction(); - - int bid128_to_int64_xceil( - BID_UINT128 x, - ) { - return _bid128_to_int64_xceil( - x, - ); - } - - late final _bid128_to_int64_xceilPtr = - _lookup>( - 'bid128_to_int64_xceil'); - late final _bid128_to_int64_xceil = - _bid128_to_int64_xceilPtr.asFunction(); - - int bid128_to_int64_xfloor( - BID_UINT128 x, - ) { - return _bid128_to_int64_xfloor( - x, - ); - } - - late final _bid128_to_int64_xfloorPtr = - _lookup>( - 'bid128_to_int64_xfloor'); - late final _bid128_to_int64_xfloor = - _bid128_to_int64_xfloorPtr.asFunction(); - - int bid128_to_int64_xint( - BID_UINT128 x, - ) { - return _bid128_to_int64_xint( - x, - ); - } - - late final _bid128_to_int64_xintPtr = - _lookup>( - 'bid128_to_int64_xint'); - late final _bid128_to_int64_xint = - _bid128_to_int64_xintPtr.asFunction(); - - int bid128_to_int64_xrnint( - BID_UINT128 x, - ) { - return _bid128_to_int64_xrnint( - x, - ); - } - - late final _bid128_to_int64_xrnintPtr = - _lookup>( - 'bid128_to_int64_xrnint'); - late final _bid128_to_int64_xrnint = - _bid128_to_int64_xrnintPtr.asFunction(); - - int bid128_to_int64_xrninta( - BID_UINT128 x, - ) { - return _bid128_to_int64_xrninta( - x, - ); - } - - late final _bid128_to_int64_xrnintaPtr = - _lookup>( - 'bid128_to_int64_xrninta'); - late final _bid128_to_int64_xrninta = - _bid128_to_int64_xrnintaPtr.asFunction(); - - int bid128_to_int8_ceil( - BID_UINT128 x, - ) { - return _bid128_to_int8_ceil( - x, - ); - } - - late final _bid128_to_int8_ceilPtr = - _lookup>( - 'bid128_to_int8_ceil'); - late final _bid128_to_int8_ceil = - _bid128_to_int8_ceilPtr.asFunction(); - - int bid128_to_int8_floor( - BID_UINT128 x, - ) { - return _bid128_to_int8_floor( - x, - ); - } - - late final _bid128_to_int8_floorPtr = - _lookup>( - 'bid128_to_int8_floor'); - late final _bid128_to_int8_floor = - _bid128_to_int8_floorPtr.asFunction(); - - int bid128_to_int8_int( - BID_UINT128 x, - ) { - return _bid128_to_int8_int( - x, - ); - } - - late final _bid128_to_int8_intPtr = - _lookup>( - 'bid128_to_int8_int'); - late final _bid128_to_int8_int = - _bid128_to_int8_intPtr.asFunction(); - - int bid128_to_int8_rnint( - BID_UINT128 x, - ) { - return _bid128_to_int8_rnint( - x, - ); - } - - late final _bid128_to_int8_rnintPtr = - _lookup>( - 'bid128_to_int8_rnint'); - late final _bid128_to_int8_rnint = - _bid128_to_int8_rnintPtr.asFunction(); - - int bid128_to_int8_rninta( - BID_UINT128 x, - ) { - return _bid128_to_int8_rninta( - x, - ); - } - - late final _bid128_to_int8_rnintaPtr = - _lookup>( - 'bid128_to_int8_rninta'); - late final _bid128_to_int8_rninta = - _bid128_to_int8_rnintaPtr.asFunction(); - - int bid128_to_int8_xceil( - BID_UINT128 x, - ) { - return _bid128_to_int8_xceil( - x, - ); - } - - late final _bid128_to_int8_xceilPtr = - _lookup>( - 'bid128_to_int8_xceil'); - late final _bid128_to_int8_xceil = - _bid128_to_int8_xceilPtr.asFunction(); - - int bid128_to_int8_xfloor( - BID_UINT128 x, - ) { - return _bid128_to_int8_xfloor( - x, - ); - } - - late final _bid128_to_int8_xfloorPtr = - _lookup>( - 'bid128_to_int8_xfloor'); - late final _bid128_to_int8_xfloor = - _bid128_to_int8_xfloorPtr.asFunction(); - - int bid128_to_int8_xint( - BID_UINT128 x, - ) { - return _bid128_to_int8_xint( - x, - ); - } - - late final _bid128_to_int8_xintPtr = - _lookup>( - 'bid128_to_int8_xint'); - late final _bid128_to_int8_xint = - _bid128_to_int8_xintPtr.asFunction(); - - int bid128_to_int8_xrnint( - BID_UINT128 x, - ) { - return _bid128_to_int8_xrnint( - x, - ); - } - - late final _bid128_to_int8_xrnintPtr = - _lookup>( - 'bid128_to_int8_xrnint'); - late final _bid128_to_int8_xrnint = - _bid128_to_int8_xrnintPtr.asFunction(); - - int bid128_to_int8_xrninta( - BID_UINT128 x, - ) { - return _bid128_to_int8_xrninta( - x, - ); - } - - late final _bid128_to_int8_xrnintaPtr = - _lookup>( - 'bid128_to_int8_xrninta'); - late final _bid128_to_int8_xrninta = - _bid128_to_int8_xrnintaPtr.asFunction(); - - void bid128_to_string( - ffi.Pointer str, - BID_UINT128 x, - ) { - return _bid128_to_string( - str, - x, - ); - } - - late final _bid128_to_stringPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, BID_UINT128)>>('bid128_to_string'); - late final _bid128_to_string = _bid128_to_stringPtr - .asFunction, BID_UINT128)>(); - - int bid128_to_uint16_ceil( - BID_UINT128 x, - ) { - return _bid128_to_uint16_ceil( - x, - ); - } - - late final _bid128_to_uint16_ceilPtr = - _lookup>( - 'bid128_to_uint16_ceil'); - late final _bid128_to_uint16_ceil = - _bid128_to_uint16_ceilPtr.asFunction(); - - int bid128_to_uint16_floor( - BID_UINT128 x, - ) { - return _bid128_to_uint16_floor( - x, - ); - } - - late final _bid128_to_uint16_floorPtr = - _lookup>( - 'bid128_to_uint16_floor'); - late final _bid128_to_uint16_floor = - _bid128_to_uint16_floorPtr.asFunction(); - - int bid128_to_uint16_int( - BID_UINT128 x, - ) { - return _bid128_to_uint16_int( - x, - ); - } - - late final _bid128_to_uint16_intPtr = - _lookup>( - 'bid128_to_uint16_int'); - late final _bid128_to_uint16_int = - _bid128_to_uint16_intPtr.asFunction(); - - int bid128_to_uint16_rnint( - BID_UINT128 x, - ) { - return _bid128_to_uint16_rnint( - x, - ); - } - - late final _bid128_to_uint16_rnintPtr = - _lookup>( - 'bid128_to_uint16_rnint'); - late final _bid128_to_uint16_rnint = - _bid128_to_uint16_rnintPtr.asFunction(); - - int bid128_to_uint16_rninta( - BID_UINT128 x, - ) { - return _bid128_to_uint16_rninta( - x, - ); - } - - late final _bid128_to_uint16_rnintaPtr = - _lookup>( - 'bid128_to_uint16_rninta'); - late final _bid128_to_uint16_rninta = - _bid128_to_uint16_rnintaPtr.asFunction(); - - int bid128_to_uint16_xceil( - BID_UINT128 x, - ) { - return _bid128_to_uint16_xceil( - x, - ); - } - - late final _bid128_to_uint16_xceilPtr = - _lookup>( - 'bid128_to_uint16_xceil'); - late final _bid128_to_uint16_xceil = - _bid128_to_uint16_xceilPtr.asFunction(); - - int bid128_to_uint16_xfloor( - BID_UINT128 x, - ) { - return _bid128_to_uint16_xfloor( - x, - ); - } - - late final _bid128_to_uint16_xfloorPtr = - _lookup>( - 'bid128_to_uint16_xfloor'); - late final _bid128_to_uint16_xfloor = - _bid128_to_uint16_xfloorPtr.asFunction(); - - int bid128_to_uint16_xint( - BID_UINT128 x, - ) { - return _bid128_to_uint16_xint( - x, - ); - } - - late final _bid128_to_uint16_xintPtr = - _lookup>( - 'bid128_to_uint16_xint'); - late final _bid128_to_uint16_xint = - _bid128_to_uint16_xintPtr.asFunction(); - - int bid128_to_uint16_xrnint( - BID_UINT128 x, - ) { - return _bid128_to_uint16_xrnint( - x, - ); - } - - late final _bid128_to_uint16_xrnintPtr = - _lookup>( - 'bid128_to_uint16_xrnint'); - late final _bid128_to_uint16_xrnint = - _bid128_to_uint16_xrnintPtr.asFunction(); - - int bid128_to_uint16_xrninta( - BID_UINT128 x, - ) { - return _bid128_to_uint16_xrninta( - x, - ); - } - - late final _bid128_to_uint16_xrnintaPtr = - _lookup>( - 'bid128_to_uint16_xrninta'); - late final _bid128_to_uint16_xrninta = - _bid128_to_uint16_xrnintaPtr.asFunction(); - - int bid128_to_uint32_ceil( - BID_UINT128 x, - ) { - return _bid128_to_uint32_ceil( - x, - ); - } - - late final _bid128_to_uint32_ceilPtr = - _lookup>( - 'bid128_to_uint32_ceil'); - late final _bid128_to_uint32_ceil = - _bid128_to_uint32_ceilPtr.asFunction(); - - int bid128_to_uint32_floor( - BID_UINT128 x, - ) { - return _bid128_to_uint32_floor( - x, - ); - } - - late final _bid128_to_uint32_floorPtr = - _lookup>( - 'bid128_to_uint32_floor'); - late final _bid128_to_uint32_floor = - _bid128_to_uint32_floorPtr.asFunction(); - - int bid128_to_uint32_int( - BID_UINT128 x, - ) { - return _bid128_to_uint32_int( - x, - ); - } - - late final _bid128_to_uint32_intPtr = - _lookup>( - 'bid128_to_uint32_int'); - late final _bid128_to_uint32_int = - _bid128_to_uint32_intPtr.asFunction(); - - int bid128_to_uint32_rnint( - BID_UINT128 x, - ) { - return _bid128_to_uint32_rnint( - x, - ); - } - - late final _bid128_to_uint32_rnintPtr = - _lookup>( - 'bid128_to_uint32_rnint'); - late final _bid128_to_uint32_rnint = - _bid128_to_uint32_rnintPtr.asFunction(); - - int bid128_to_uint32_rninta( - BID_UINT128 x, - ) { - return _bid128_to_uint32_rninta( - x, - ); - } - - late final _bid128_to_uint32_rnintaPtr = - _lookup>( - 'bid128_to_uint32_rninta'); - late final _bid128_to_uint32_rninta = - _bid128_to_uint32_rnintaPtr.asFunction(); - - int bid128_to_uint32_xceil( - BID_UINT128 x, - ) { - return _bid128_to_uint32_xceil( - x, - ); - } - - late final _bid128_to_uint32_xceilPtr = - _lookup>( - 'bid128_to_uint32_xceil'); - late final _bid128_to_uint32_xceil = - _bid128_to_uint32_xceilPtr.asFunction(); - - int bid128_to_uint32_xfloor( - BID_UINT128 x, - ) { - return _bid128_to_uint32_xfloor( - x, - ); - } - - late final _bid128_to_uint32_xfloorPtr = - _lookup>( - 'bid128_to_uint32_xfloor'); - late final _bid128_to_uint32_xfloor = - _bid128_to_uint32_xfloorPtr.asFunction(); - - int bid128_to_uint32_xint( - BID_UINT128 x, - ) { - return _bid128_to_uint32_xint( - x, - ); - } - - late final _bid128_to_uint32_xintPtr = - _lookup>( - 'bid128_to_uint32_xint'); - late final _bid128_to_uint32_xint = - _bid128_to_uint32_xintPtr.asFunction(); - - int bid128_to_uint32_xrnint( - BID_UINT128 x, - ) { - return _bid128_to_uint32_xrnint( - x, - ); - } - - late final _bid128_to_uint32_xrnintPtr = - _lookup>( - 'bid128_to_uint32_xrnint'); - late final _bid128_to_uint32_xrnint = - _bid128_to_uint32_xrnintPtr.asFunction(); - - int bid128_to_uint32_xrninta( - BID_UINT128 x, - ) { - return _bid128_to_uint32_xrninta( - x, - ); - } - - late final _bid128_to_uint32_xrnintaPtr = - _lookup>( - 'bid128_to_uint32_xrninta'); - late final _bid128_to_uint32_xrninta = - _bid128_to_uint32_xrnintaPtr.asFunction(); - - int bid128_to_uint64_ceil( - BID_UINT128 x, - ) { - return _bid128_to_uint64_ceil( - x, - ); - } - - late final _bid128_to_uint64_ceilPtr = - _lookup>( - 'bid128_to_uint64_ceil'); - late final _bid128_to_uint64_ceil = - _bid128_to_uint64_ceilPtr.asFunction(); - - int bid128_to_uint64_floor( - BID_UINT128 x, - ) { - return _bid128_to_uint64_floor( - x, - ); - } - - late final _bid128_to_uint64_floorPtr = - _lookup>( - 'bid128_to_uint64_floor'); - late final _bid128_to_uint64_floor = - _bid128_to_uint64_floorPtr.asFunction(); - - int bid128_to_uint64_int( - BID_UINT128 x, - ) { - return _bid128_to_uint64_int( - x, - ); - } - - late final _bid128_to_uint64_intPtr = - _lookup>( - 'bid128_to_uint64_int'); - late final _bid128_to_uint64_int = - _bid128_to_uint64_intPtr.asFunction(); - - int bid128_to_uint64_rnint( - BID_UINT128 x, - ) { - return _bid128_to_uint64_rnint( - x, - ); - } - - late final _bid128_to_uint64_rnintPtr = - _lookup>( - 'bid128_to_uint64_rnint'); - late final _bid128_to_uint64_rnint = - _bid128_to_uint64_rnintPtr.asFunction(); - - int bid128_to_uint64_rninta( - BID_UINT128 x, - ) { - return _bid128_to_uint64_rninta( - x, - ); - } - - late final _bid128_to_uint64_rnintaPtr = - _lookup>( - 'bid128_to_uint64_rninta'); - late final _bid128_to_uint64_rninta = - _bid128_to_uint64_rnintaPtr.asFunction(); - - int bid128_to_uint64_xceil( - BID_UINT128 x, - ) { - return _bid128_to_uint64_xceil( - x, - ); - } - - late final _bid128_to_uint64_xceilPtr = - _lookup>( - 'bid128_to_uint64_xceil'); - late final _bid128_to_uint64_xceil = - _bid128_to_uint64_xceilPtr.asFunction(); - - int bid128_to_uint64_xfloor( - BID_UINT128 x, - ) { - return _bid128_to_uint64_xfloor( - x, - ); - } - - late final _bid128_to_uint64_xfloorPtr = - _lookup>( - 'bid128_to_uint64_xfloor'); - late final _bid128_to_uint64_xfloor = - _bid128_to_uint64_xfloorPtr.asFunction(); - - int bid128_to_uint64_xint( - BID_UINT128 x, - ) { - return _bid128_to_uint64_xint( - x, - ); - } - - late final _bid128_to_uint64_xintPtr = - _lookup>( - 'bid128_to_uint64_xint'); - late final _bid128_to_uint64_xint = - _bid128_to_uint64_xintPtr.asFunction(); - - int bid128_to_uint64_xrnint( - BID_UINT128 x, - ) { - return _bid128_to_uint64_xrnint( - x, - ); - } - - late final _bid128_to_uint64_xrnintPtr = - _lookup>( - 'bid128_to_uint64_xrnint'); - late final _bid128_to_uint64_xrnint = - _bid128_to_uint64_xrnintPtr.asFunction(); - - int bid128_to_uint64_xrninta( - BID_UINT128 x, - ) { - return _bid128_to_uint64_xrninta( - x, - ); - } - - late final _bid128_to_uint64_xrnintaPtr = - _lookup>( - 'bid128_to_uint64_xrninta'); - late final _bid128_to_uint64_xrninta = - _bid128_to_uint64_xrnintaPtr.asFunction(); - - int bid128_to_uint8_ceil( - BID_UINT128 x, - ) { - return _bid128_to_uint8_ceil( - x, - ); - } - - late final _bid128_to_uint8_ceilPtr = - _lookup>( - 'bid128_to_uint8_ceil'); - late final _bid128_to_uint8_ceil = - _bid128_to_uint8_ceilPtr.asFunction(); - - int bid128_to_uint8_floor( - BID_UINT128 x, - ) { - return _bid128_to_uint8_floor( - x, - ); - } - - late final _bid128_to_uint8_floorPtr = - _lookup>( - 'bid128_to_uint8_floor'); - late final _bid128_to_uint8_floor = - _bid128_to_uint8_floorPtr.asFunction(); - - int bid128_to_uint8_int( - BID_UINT128 x, - ) { - return _bid128_to_uint8_int( - x, - ); - } - - late final _bid128_to_uint8_intPtr = - _lookup>( - 'bid128_to_uint8_int'); - late final _bid128_to_uint8_int = - _bid128_to_uint8_intPtr.asFunction(); - - int bid128_to_uint8_rnint( - BID_UINT128 x, - ) { - return _bid128_to_uint8_rnint( - x, - ); - } - - late final _bid128_to_uint8_rnintPtr = - _lookup>( - 'bid128_to_uint8_rnint'); - late final _bid128_to_uint8_rnint = - _bid128_to_uint8_rnintPtr.asFunction(); - - int bid128_to_uint8_rninta( - BID_UINT128 x, - ) { - return _bid128_to_uint8_rninta( - x, - ); - } - - late final _bid128_to_uint8_rnintaPtr = - _lookup>( - 'bid128_to_uint8_rninta'); - late final _bid128_to_uint8_rninta = - _bid128_to_uint8_rnintaPtr.asFunction(); - - int bid128_to_uint8_xceil( - BID_UINT128 x, - ) { - return _bid128_to_uint8_xceil( - x, - ); - } - - late final _bid128_to_uint8_xceilPtr = - _lookup>( - 'bid128_to_uint8_xceil'); - late final _bid128_to_uint8_xceil = - _bid128_to_uint8_xceilPtr.asFunction(); - - int bid128_to_uint8_xfloor( - BID_UINT128 x, - ) { - return _bid128_to_uint8_xfloor( - x, - ); - } - - late final _bid128_to_uint8_xfloorPtr = - _lookup>( - 'bid128_to_uint8_xfloor'); - late final _bid128_to_uint8_xfloor = - _bid128_to_uint8_xfloorPtr.asFunction(); - - int bid128_to_uint8_xint( - BID_UINT128 x, - ) { - return _bid128_to_uint8_xint( - x, - ); - } - - late final _bid128_to_uint8_xintPtr = - _lookup>( - 'bid128_to_uint8_xint'); - late final _bid128_to_uint8_xint = - _bid128_to_uint8_xintPtr.asFunction(); - - int bid128_to_uint8_xrnint( - BID_UINT128 x, - ) { - return _bid128_to_uint8_xrnint( - x, - ); - } - - late final _bid128_to_uint8_xrnintPtr = - _lookup>( - 'bid128_to_uint8_xrnint'); - late final _bid128_to_uint8_xrnint = - _bid128_to_uint8_xrnintPtr.asFunction(); - - int bid128_to_uint8_xrninta( - BID_UINT128 x, - ) { - return _bid128_to_uint8_xrninta( - x, - ); - } - - late final _bid128_to_uint8_xrnintaPtr = - _lookup>( - 'bid128_to_uint8_xrninta'); - late final _bid128_to_uint8_xrninta = - _bid128_to_uint8_xrnintaPtr.asFunction(); - - int bid128_totalOrder( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_totalOrder( - x, - y, - ); - } - - late final _bid128_totalOrderPtr = - _lookup>( - 'bid128_totalOrder'); - late final _bid128_totalOrder = _bid128_totalOrderPtr - .asFunction(); - - int bid128_totalOrderMag( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid128_totalOrderMag( - x, - y, - ); - } - - late final _bid128_totalOrderMagPtr = - _lookup>( - 'bid128_totalOrderMag'); - late final _bid128_totalOrderMag = _bid128_totalOrderMagPtr - .asFunction(); - - BID_UINT128 bid128d_sqrt( - int x, - ) { - return _bid128d_sqrt( - x, - ); - } - - late final _bid128d_sqrtPtr = - _lookup>( - 'bid128d_sqrt'); - late final _bid128d_sqrt = - _bid128d_sqrtPtr.asFunction(); - - BID_UINT128 bid128dd_add( - int x, - int y, - ) { - return _bid128dd_add( - x, - y, - ); - } - - late final _bid128dd_addPtr = - _lookup>( - 'bid128dd_add'); - late final _bid128dd_add = - _bid128dd_addPtr.asFunction(); - - BID_UINT128 bid128dd_div( - int x, - int y, - ) { - return _bid128dd_div( - x, - y, - ); - } - - late final _bid128dd_divPtr = - _lookup>( - 'bid128dd_div'); - late final _bid128dd_div = - _bid128dd_divPtr.asFunction(); - - BID_UINT128 bid128dd_mul( - int x, - int y, - ) { - return _bid128dd_mul( - x, - y, - ); - } - - late final _bid128dd_mulPtr = - _lookup>( - 'bid128dd_mul'); - late final _bid128dd_mul = - _bid128dd_mulPtr.asFunction(); - - BID_UINT128 bid128dd_sub( - int x, - int y, - ) { - return _bid128dd_sub( - x, - y, - ); - } - - late final _bid128dd_subPtr = - _lookup>( - 'bid128dd_sub'); - late final _bid128dd_sub = - _bid128dd_subPtr.asFunction(); - - BID_UINT128 bid128ddd_fma( - int x, - int y, - int z, - ) { - return _bid128ddd_fma( - x, - y, - z, - ); - } - - late final _bid128ddd_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT64, BID_UINT64, BID_UINT64)>>('bid128ddd_fma'); - late final _bid128ddd_fma = - _bid128ddd_fmaPtr.asFunction(); - - BID_UINT128 bid128ddq_fma( - int x, - int y, - BID_UINT128 z, - ) { - return _bid128ddq_fma( - x, - y, - z, - ); - } - - late final _bid128ddq_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT64, BID_UINT64, BID_UINT128)>>('bid128ddq_fma'); - late final _bid128ddq_fma = _bid128ddq_fmaPtr - .asFunction(); - - BID_UINT128 bid128dq_add( - int x, - BID_UINT128 y, - ) { - return _bid128dq_add( - x, - y, - ); - } - - late final _bid128dq_addPtr = _lookup< - ffi.NativeFunction>( - 'bid128dq_add'); - late final _bid128dq_add = - _bid128dq_addPtr.asFunction(); - - BID_UINT128 bid128dq_div( - int x, - BID_UINT128 y, - ) { - return _bid128dq_div( - x, - y, - ); - } - - late final _bid128dq_divPtr = _lookup< - ffi.NativeFunction>( - 'bid128dq_div'); - late final _bid128dq_div = - _bid128dq_divPtr.asFunction(); - - BID_UINT128 bid128dq_mul( - int x, - BID_UINT128 y, - ) { - return _bid128dq_mul( - x, - y, - ); - } - - late final _bid128dq_mulPtr = _lookup< - ffi.NativeFunction>( - 'bid128dq_mul'); - late final _bid128dq_mul = - _bid128dq_mulPtr.asFunction(); - - BID_UINT128 bid128dq_sub( - int x, - BID_UINT128 y, - ) { - return _bid128dq_sub( - x, - y, - ); - } - - late final _bid128dq_subPtr = _lookup< - ffi.NativeFunction>( - 'bid128dq_sub'); - late final _bid128dq_sub = - _bid128dq_subPtr.asFunction(); - - BID_UINT128 bid128dqd_fma( - int x, - BID_UINT128 y, - int z, - ) { - return _bid128dqd_fma( - x, - y, - z, - ); - } - - late final _bid128dqd_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT64, BID_UINT128, BID_UINT64)>>('bid128dqd_fma'); - late final _bid128dqd_fma = _bid128dqd_fmaPtr - .asFunction(); - - BID_UINT128 bid128dqq_fma( - int x, - BID_UINT128 y, - BID_UINT128 z, - ) { - return _bid128dqq_fma( - x, - y, - z, - ); - } - - late final _bid128dqq_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT64, BID_UINT128, BID_UINT128)>>('bid128dqq_fma'); - late final _bid128dqq_fma = _bid128dqq_fmaPtr - .asFunction(); - - BID_UINT128 bid128qd_add( - BID_UINT128 x, - int y, - ) { - return _bid128qd_add( - x, - y, - ); - } - - late final _bid128qd_addPtr = _lookup< - ffi.NativeFunction>( - 'bid128qd_add'); - late final _bid128qd_add = - _bid128qd_addPtr.asFunction(); - - BID_UINT128 bid128qd_div( - BID_UINT128 x, - int y, - ) { - return _bid128qd_div( - x, - y, - ); - } - - late final _bid128qd_divPtr = _lookup< - ffi.NativeFunction>( - 'bid128qd_div'); - late final _bid128qd_div = - _bid128qd_divPtr.asFunction(); - - BID_UINT128 bid128qd_mul( - BID_UINT128 x, - int y, - ) { - return _bid128qd_mul( - x, - y, - ); - } - - late final _bid128qd_mulPtr = _lookup< - ffi.NativeFunction>( - 'bid128qd_mul'); - late final _bid128qd_mul = - _bid128qd_mulPtr.asFunction(); - - BID_UINT128 bid128qd_sub( - BID_UINT128 x, - int y, - ) { - return _bid128qd_sub( - x, - y, - ); - } - - late final _bid128qd_subPtr = _lookup< - ffi.NativeFunction>( - 'bid128qd_sub'); - late final _bid128qd_sub = - _bid128qd_subPtr.asFunction(); - - BID_UINT128 bid128qdd_fma( - BID_UINT128 x, - int y, - int z, - ) { - return _bid128qdd_fma( - x, - y, - z, - ); - } - - late final _bid128qdd_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT128, BID_UINT64, BID_UINT64)>>('bid128qdd_fma'); - late final _bid128qdd_fma = _bid128qdd_fmaPtr - .asFunction(); - - BID_UINT128 bid128qdq_fma( - BID_UINT128 x, - int y, - BID_UINT128 z, - ) { - return _bid128qdq_fma( - x, - y, - z, - ); - } - - late final _bid128qdq_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT128, BID_UINT64, BID_UINT128)>>('bid128qdq_fma'); - late final _bid128qdq_fma = _bid128qdq_fmaPtr - .asFunction(); - - BID_UINT128 bid128qqd_fma( - BID_UINT128 x, - BID_UINT128 y, - int z, - ) { - return _bid128qqd_fma( - x, - y, - z, - ); - } - - late final _bid128qqd_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function( - BID_UINT128, BID_UINT128, BID_UINT64)>>('bid128qqd_fma'); - late final _bid128qqd_fma = _bid128qqd_fmaPtr - .asFunction(); - - int bid32_abs( - int x, - ) { - return _bid32_abs( - x, - ); - } - - late final _bid32_absPtr = - _lookup>('bid32_abs'); - late final _bid32_abs = _bid32_absPtr.asFunction(); - - int bid32_acos( - int x, - ) { - return _bid32_acos( - x, - ); - } - - late final _bid32_acosPtr = - _lookup>( - 'bid32_acos'); - late final _bid32_acos = _bid32_acosPtr.asFunction(); - - int bid32_acosh( - int x, - ) { - return _bid32_acosh( - x, - ); - } - - late final _bid32_acoshPtr = - _lookup>( - 'bid32_acosh'); - late final _bid32_acosh = _bid32_acoshPtr.asFunction(); - - int bid32_add( - int x, - int y, - ) { - return _bid32_add( - x, - y, - ); - } - - late final _bid32_addPtr = - _lookup>( - 'bid32_add'); - late final _bid32_add = _bid32_addPtr.asFunction(); - - int bid32_asin( - int x, - ) { - return _bid32_asin( - x, - ); - } - - late final _bid32_asinPtr = - _lookup>( - 'bid32_asin'); - late final _bid32_asin = _bid32_asinPtr.asFunction(); - - int bid32_asinh( - int x, - ) { - return _bid32_asinh( - x, - ); - } - - late final _bid32_asinhPtr = - _lookup>( - 'bid32_asinh'); - late final _bid32_asinh = _bid32_asinhPtr.asFunction(); - - int bid32_atan( - int x, - ) { - return _bid32_atan( - x, - ); - } - - late final _bid32_atanPtr = - _lookup>( - 'bid32_atan'); - late final _bid32_atan = _bid32_atanPtr.asFunction(); - - int bid32_atan2( - int x, - int y, - ) { - return _bid32_atan2( - x, - y, - ); - } - - late final _bid32_atan2Ptr = - _lookup>( - 'bid32_atan2'); - late final _bid32_atan2 = - _bid32_atan2Ptr.asFunction(); - - int bid32_atanh( - int x, - ) { - return _bid32_atanh( - x, - ); - } - - late final _bid32_atanhPtr = - _lookup>( - 'bid32_atanh'); - late final _bid32_atanh = _bid32_atanhPtr.asFunction(); - - int bid32_cbrt( - int x, - ) { - return _bid32_cbrt( - x, - ); - } - - late final _bid32_cbrtPtr = - _lookup>( - 'bid32_cbrt'); - late final _bid32_cbrt = _bid32_cbrtPtr.asFunction(); - - int bid32_class( - int x, - ) { - return _bid32_class( - x, - ); - } - - late final _bid32_classPtr = - _lookup>('bid32_class'); - late final _bid32_class = _bid32_classPtr.asFunction(); - - int bid32_copy( - int x, - ) { - return _bid32_copy( - x, - ); - } - - late final _bid32_copyPtr = - _lookup>( - 'bid32_copy'); - late final _bid32_copy = _bid32_copyPtr.asFunction(); - - int bid32_copySign( - int x, - int y, - ) { - return _bid32_copySign( - x, - y, - ); - } - - late final _bid32_copySignPtr = - _lookup>( - 'bid32_copySign'); - late final _bid32_copySign = - _bid32_copySignPtr.asFunction(); - - int bid32_cos( - int x, - ) { - return _bid32_cos( - x, - ); - } - - late final _bid32_cosPtr = - _lookup>('bid32_cos'); - late final _bid32_cos = _bid32_cosPtr.asFunction(); - - int bid32_cosh( - int x, - ) { - return _bid32_cosh( - x, - ); - } - - late final _bid32_coshPtr = - _lookup>( - 'bid32_cosh'); - late final _bid32_cosh = _bid32_coshPtr.asFunction(); - - int bid32_div( - int x, - int y, - ) { - return _bid32_div( - x, - y, - ); - } - - late final _bid32_divPtr = - _lookup>( - 'bid32_div'); - late final _bid32_div = _bid32_divPtr.asFunction(); - - int bid32_erf( - int x, - ) { - return _bid32_erf( - x, - ); - } - - late final _bid32_erfPtr = - _lookup>('bid32_erf'); - late final _bid32_erf = _bid32_erfPtr.asFunction(); - - int bid32_erfc( - int x, - ) { - return _bid32_erfc( - x, - ); - } - - late final _bid32_erfcPtr = - _lookup>( - 'bid32_erfc'); - late final _bid32_erfc = _bid32_erfcPtr.asFunction(); - - int bid32_exp( - int x, - ) { - return _bid32_exp( - x, - ); - } - - late final _bid32_expPtr = - _lookup>('bid32_exp'); - late final _bid32_exp = _bid32_expPtr.asFunction(); - - int bid32_exp10( - int x, - ) { - return _bid32_exp10( - x, - ); - } - - late final _bid32_exp10Ptr = - _lookup>( - 'bid32_exp10'); - late final _bid32_exp10 = _bid32_exp10Ptr.asFunction(); - - int bid32_exp2( - int x, - ) { - return _bid32_exp2( - x, - ); - } - - late final _bid32_exp2Ptr = - _lookup>( - 'bid32_exp2'); - late final _bid32_exp2 = _bid32_exp2Ptr.asFunction(); - - int bid32_expm1( - int x, - ) { - return _bid32_expm1( - x, - ); - } - - late final _bid32_expm1Ptr = - _lookup>( - 'bid32_expm1'); - late final _bid32_expm1 = _bid32_expm1Ptr.asFunction(); - - int bid32_fdim( - int x, - int y, - ) { - return _bid32_fdim( - x, - y, - ); - } - - late final _bid32_fdimPtr = - _lookup>( - 'bid32_fdim'); - late final _bid32_fdim = _bid32_fdimPtr.asFunction(); - - int bid32_fma( - int x, - int y, - int z, - ) { - return _bid32_fma( - x, - y, - z, - ); - } - - late final _bid32_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT32 Function( - BID_UINT32, BID_UINT32, BID_UINT32)>>('bid32_fma'); - late final _bid32_fma = - _bid32_fmaPtr.asFunction(); - - int bid32_fmod( - int x, - int y, - ) { - return _bid32_fmod( - x, - y, - ); - } - - late final _bid32_fmodPtr = - _lookup>( - 'bid32_fmod'); - late final _bid32_fmod = _bid32_fmodPtr.asFunction(); - - int bid32_frexp( - int x, - ffi.Pointer exp, - ) { - return _bid32_frexp( - x, - exp, - ); - } - - late final _bid32_frexpPtr = _lookup< - ffi.NativeFunction< - BID_UINT32 Function( - BID_UINT32, ffi.Pointer)>>('bid32_frexp'); - late final _bid32_frexp = - _bid32_frexpPtr.asFunction)>(); - - int bid32_from_int32( - int x, - ) { - return _bid32_from_int32( - x, - ); - } - - late final _bid32_from_int32Ptr = - _lookup>( - 'bid32_from_int32'); - late final _bid32_from_int32 = - _bid32_from_int32Ptr.asFunction(); - - int bid32_from_int64( - int x, - ) { - return _bid32_from_int64( - x, - ); - } - - late final _bid32_from_int64Ptr = - _lookup>( - 'bid32_from_int64'); - late final _bid32_from_int64 = - _bid32_from_int64Ptr.asFunction(); - - int bid32_from_string( - ffi.Pointer ps, - ) { - return _bid32_from_string( - ps, - ); - } - - late final _bid32_from_stringPtr = - _lookup)>>( - 'bid32_from_string'); - late final _bid32_from_string = - _bid32_from_stringPtr.asFunction)>(); - - int bid32_from_uint32( - int x, - ) { - return _bid32_from_uint32( - x, - ); - } - - late final _bid32_from_uint32Ptr = - _lookup>( - 'bid32_from_uint32'); - late final _bid32_from_uint32 = - _bid32_from_uint32Ptr.asFunction(); - - int bid32_from_uint64( - int _RND_MODE_PARAM, - ) { - return _bid32_from_uint64( - _RND_MODE_PARAM, - ); - } - - late final _bid32_from_uint64Ptr = - _lookup>( - 'bid32_from_uint64'); - late final _bid32_from_uint64 = - _bid32_from_uint64Ptr.asFunction(); - - int bid32_hypot( - int x, - int y, - ) { - return _bid32_hypot( - x, - y, - ); - } - - late final _bid32_hypotPtr = - _lookup>( - 'bid32_hypot'); - late final _bid32_hypot = - _bid32_hypotPtr.asFunction(); - - int bid32_ilogb( - int x, - ) { - return _bid32_ilogb( - x, - ); - } - - late final _bid32_ilogbPtr = - _lookup>('bid32_ilogb'); - late final _bid32_ilogb = _bid32_ilogbPtr.asFunction(); - - int bid32_inf() { - return _bid32_inf(); - } - - late final _bid32_infPtr = - _lookup>('bid32_inf'); - late final _bid32_inf = _bid32_infPtr.asFunction(); - - int bid32_isCanonical( - int x, - ) { - return _bid32_isCanonical( - x, - ); - } - - late final _bid32_isCanonicalPtr = - _lookup>( - 'bid32_isCanonical'); - late final _bid32_isCanonical = - _bid32_isCanonicalPtr.asFunction(); - - int bid32_isFinite( - int x, - ) { - return _bid32_isFinite( - x, - ); - } - - late final _bid32_isFinitePtr = - _lookup>( - 'bid32_isFinite'); - late final _bid32_isFinite = - _bid32_isFinitePtr.asFunction(); - - int bid32_isInf( - int x, - ) { - return _bid32_isInf( - x, - ); - } - - late final _bid32_isInfPtr = - _lookup>('bid32_isInf'); - late final _bid32_isInf = _bid32_isInfPtr.asFunction(); - - int bid32_isNaN( - int x, - ) { - return _bid32_isNaN( - x, - ); - } - - late final _bid32_isNaNPtr = - _lookup>('bid32_isNaN'); - late final _bid32_isNaN = _bid32_isNaNPtr.asFunction(); - - int bid32_isNormal( - int x, - ) { - return _bid32_isNormal( - x, - ); - } - - late final _bid32_isNormalPtr = - _lookup>( - 'bid32_isNormal'); - late final _bid32_isNormal = - _bid32_isNormalPtr.asFunction(); - - int bid32_isSignaling( - int x, - ) { - return _bid32_isSignaling( - x, - ); - } - - late final _bid32_isSignalingPtr = - _lookup>( - 'bid32_isSignaling'); - late final _bid32_isSignaling = - _bid32_isSignalingPtr.asFunction(); - - int bid32_isSigned( - int x, - ) { - return _bid32_isSigned( - x, - ); - } - - late final _bid32_isSignedPtr = - _lookup>( - 'bid32_isSigned'); - late final _bid32_isSigned = - _bid32_isSignedPtr.asFunction(); - - int bid32_isSubnormal( - int x, - ) { - return _bid32_isSubnormal( - x, - ); - } - - late final _bid32_isSubnormalPtr = - _lookup>( - 'bid32_isSubnormal'); - late final _bid32_isSubnormal = - _bid32_isSubnormalPtr.asFunction(); - - int bid32_isZero( - int x, - ) { - return _bid32_isZero( - x, - ); - } - - late final _bid32_isZeroPtr = - _lookup>('bid32_isZero'); - late final _bid32_isZero = _bid32_isZeroPtr.asFunction(); - - int bid32_ldexp( - int x, - int n, - ) { - return _bid32_ldexp( - x, - n, - ); - } - - late final _bid32_ldexpPtr = - _lookup>( - 'bid32_ldexp'); - late final _bid32_ldexp = - _bid32_ldexpPtr.asFunction(); - - int bid32_lgamma( - int x, - ) { - return _bid32_lgamma( - x, - ); - } - - late final _bid32_lgammaPtr = - _lookup>( - 'bid32_lgamma'); - late final _bid32_lgamma = _bid32_lgammaPtr.asFunction(); - - int bid32_llquantexp( - int x, - ) { - return _bid32_llquantexp( - x, - ); - } - - late final _bid32_llquantexpPtr = - _lookup>( - 'bid32_llquantexp'); - late final _bid32_llquantexp = - _bid32_llquantexpPtr.asFunction(); - - int bid32_llrint( - int x, - ) { - return _bid32_llrint( - x, - ); - } - - late final _bid32_llrintPtr = - _lookup>( - 'bid32_llrint'); - late final _bid32_llrint = _bid32_llrintPtr.asFunction(); - - int bid32_llround( - int x, - ) { - return _bid32_llround( - x, - ); - } - - late final _bid32_llroundPtr = - _lookup>( - 'bid32_llround'); - late final _bid32_llround = _bid32_llroundPtr.asFunction(); - - int bid32_log( - int x, - ) { - return _bid32_log( - x, - ); - } - - late final _bid32_logPtr = - _lookup>('bid32_log'); - late final _bid32_log = _bid32_logPtr.asFunction(); - - int bid32_log10( - int x, - ) { - return _bid32_log10( - x, - ); - } - - late final _bid32_log10Ptr = - _lookup>( - 'bid32_log10'); - late final _bid32_log10 = _bid32_log10Ptr.asFunction(); - - int bid32_log1p( - int x, - ) { - return _bid32_log1p( - x, - ); - } - - late final _bid32_log1pPtr = - _lookup>( - 'bid32_log1p'); - late final _bid32_log1p = _bid32_log1pPtr.asFunction(); - - int bid32_log2( - int x, - ) { - return _bid32_log2( - x, - ); - } - - late final _bid32_log2Ptr = - _lookup>( - 'bid32_log2'); - late final _bid32_log2 = _bid32_log2Ptr.asFunction(); - - int bid32_logb( - int x, - ) { - return _bid32_logb( - x, - ); - } - - late final _bid32_logbPtr = - _lookup>( - 'bid32_logb'); - late final _bid32_logb = _bid32_logbPtr.asFunction(); - - int bid32_lrint( - int x, - ) { - return _bid32_lrint( - x, - ); - } - - late final _bid32_lrintPtr = - _lookup>('bid32_lrint'); - late final _bid32_lrint = _bid32_lrintPtr.asFunction(); - - int bid32_lround( - int x, - ) { - return _bid32_lround( - x, - ); - } - - late final _bid32_lroundPtr = - _lookup>( - 'bid32_lround'); - late final _bid32_lround = _bid32_lroundPtr.asFunction(); - - int bid32_maxnum( - int x, - int y, - ) { - return _bid32_maxnum( - x, - y, - ); - } - - late final _bid32_maxnumPtr = - _lookup>( - 'bid32_maxnum'); - late final _bid32_maxnum = - _bid32_maxnumPtr.asFunction(); - - int bid32_maxnum_mag( - int x, - int y, - ) { - return _bid32_maxnum_mag( - x, - y, - ); - } - - late final _bid32_maxnum_magPtr = - _lookup>( - 'bid32_maxnum_mag'); - late final _bid32_maxnum_mag = - _bid32_maxnum_magPtr.asFunction(); - - int bid32_minnum( - int x, - int y, - ) { - return _bid32_minnum( - x, - y, - ); - } - - late final _bid32_minnumPtr = - _lookup>( - 'bid32_minnum'); - late final _bid32_minnum = - _bid32_minnumPtr.asFunction(); - - int bid32_minnum_mag( - int x, - int y, - ) { - return _bid32_minnum_mag( - x, - y, - ); - } - - late final _bid32_minnum_magPtr = - _lookup>( - 'bid32_minnum_mag'); - late final _bid32_minnum_mag = - _bid32_minnum_magPtr.asFunction(); - - int bid32_modf( - int x, - ffi.Pointer y, - ) { - return _bid32_modf( - x, - y, - ); - } - - late final _bid32_modfPtr = _lookup< - ffi.NativeFunction< - BID_UINT32 Function( - BID_UINT32, ffi.Pointer)>>('bid32_modf'); - late final _bid32_modf = - _bid32_modfPtr.asFunction)>(); - - int bid32_mul( - int x, - int y, - ) { - return _bid32_mul( - x, - y, - ); - } - - late final _bid32_mulPtr = - _lookup>( - 'bid32_mul'); - late final _bid32_mul = _bid32_mulPtr.asFunction(); - - int bid32_nan( - ffi.Pointer tagp, - ) { - return _bid32_nan( - tagp, - ); - } - - late final _bid32_nanPtr = - _lookup)>>( - 'bid32_nan'); - late final _bid32_nan = - _bid32_nanPtr.asFunction)>(); - - int bid32_nearbyint( - int x, - ) { - return _bid32_nearbyint( - x, - ); - } - - late final _bid32_nearbyintPtr = - _lookup>( - 'bid32_nearbyint'); - late final _bid32_nearbyint = - _bid32_nearbyintPtr.asFunction(); - - int bid32_negate( - int x, - ) { - return _bid32_negate( - x, - ); - } - - late final _bid32_negatePtr = - _lookup>( - 'bid32_negate'); - late final _bid32_negate = _bid32_negatePtr.asFunction(); - - int bid32_nextafter( - int x, - int y, - ) { - return _bid32_nextafter( - x, - y, - ); - } - - late final _bid32_nextafterPtr = - _lookup>( - 'bid32_nextafter'); - late final _bid32_nextafter = - _bid32_nextafterPtr.asFunction(); - - int bid32_nextdown( - int x, - ) { - return _bid32_nextdown( - x, - ); - } - - late final _bid32_nextdownPtr = - _lookup>( - 'bid32_nextdown'); - late final _bid32_nextdown = - _bid32_nextdownPtr.asFunction(); - - int bid32_nexttoward( - int x, - BID_UINT128 y, - ) { - return _bid32_nexttoward( - x, - y, - ); - } - - late final _bid32_nexttowardPtr = - _lookup>( - 'bid32_nexttoward'); - late final _bid32_nexttoward = - _bid32_nexttowardPtr.asFunction(); - - int bid32_nextup( - int x, - ) { - return _bid32_nextup( - x, - ); - } - - late final _bid32_nextupPtr = - _lookup>( - 'bid32_nextup'); - late final _bid32_nextup = _bid32_nextupPtr.asFunction(); - - int bid32_pow( - int x, - int y, - ) { - return _bid32_pow( - x, - y, - ); - } - - late final _bid32_powPtr = - _lookup>( - 'bid32_pow'); - late final _bid32_pow = _bid32_powPtr.asFunction(); - - int bid32_quantexp( - int x, - ) { - return _bid32_quantexp( - x, - ); - } - - late final _bid32_quantexpPtr = - _lookup>( - 'bid32_quantexp'); - late final _bid32_quantexp = - _bid32_quantexpPtr.asFunction(); - - int bid32_quantize( - int x, - int y, - ) { - return _bid32_quantize( - x, - y, - ); - } - - late final _bid32_quantizePtr = - _lookup>( - 'bid32_quantize'); - late final _bid32_quantize = - _bid32_quantizePtr.asFunction(); - - int bid32_quantum( - int x, - ) { - return _bid32_quantum( - x, - ); - } - - late final _bid32_quantumPtr = - _lookup>( - 'bid32_quantum'); - late final _bid32_quantum = _bid32_quantumPtr.asFunction(); - - int bid32_quiet_equal( - int x, - int y, - ) { - return _bid32_quiet_equal( - x, - y, - ); - } - - late final _bid32_quiet_equalPtr = - _lookup>( - 'bid32_quiet_equal'); - late final _bid32_quiet_equal = - _bid32_quiet_equalPtr.asFunction(); - - int bid32_quiet_greater( - int x, - int y, - ) { - return _bid32_quiet_greater( - x, - y, - ); - } - - late final _bid32_quiet_greaterPtr = - _lookup>( - 'bid32_quiet_greater'); - late final _bid32_quiet_greater = - _bid32_quiet_greaterPtr.asFunction(); - - int bid32_quiet_greater_equal( - int x, - int y, - ) { - return _bid32_quiet_greater_equal( - x, - y, - ); - } - - late final _bid32_quiet_greater_equalPtr = - _lookup>( - 'bid32_quiet_greater_equal'); - late final _bid32_quiet_greater_equal = - _bid32_quiet_greater_equalPtr.asFunction(); - - int bid32_quiet_greater_unordered( - int x, - int y, - ) { - return _bid32_quiet_greater_unordered( - x, - y, - ); - } - - late final _bid32_quiet_greater_unorderedPtr = - _lookup>( - 'bid32_quiet_greater_unordered'); - late final _bid32_quiet_greater_unordered = - _bid32_quiet_greater_unorderedPtr.asFunction(); - - int bid32_quiet_less( - int x, - int y, - ) { - return _bid32_quiet_less( - x, - y, - ); - } - - late final _bid32_quiet_lessPtr = - _lookup>( - 'bid32_quiet_less'); - late final _bid32_quiet_less = - _bid32_quiet_lessPtr.asFunction(); - - int bid32_quiet_less_equal( - int x, - int y, - ) { - return _bid32_quiet_less_equal( - x, - y, - ); - } - - late final _bid32_quiet_less_equalPtr = - _lookup>( - 'bid32_quiet_less_equal'); - late final _bid32_quiet_less_equal = - _bid32_quiet_less_equalPtr.asFunction(); - - int bid32_quiet_less_unordered( - int x, - int y, - ) { - return _bid32_quiet_less_unordered( - x, - y, - ); - } - - late final _bid32_quiet_less_unorderedPtr = - _lookup>( - 'bid32_quiet_less_unordered'); - late final _bid32_quiet_less_unordered = - _bid32_quiet_less_unorderedPtr.asFunction(); - - int bid32_quiet_not_equal( - int x, - int y, - ) { - return _bid32_quiet_not_equal( - x, - y, - ); - } - - late final _bid32_quiet_not_equalPtr = - _lookup>( - 'bid32_quiet_not_equal'); - late final _bid32_quiet_not_equal = - _bid32_quiet_not_equalPtr.asFunction(); - - int bid32_quiet_not_greater( - int x, - int y, - ) { - return _bid32_quiet_not_greater( - x, - y, - ); - } - - late final _bid32_quiet_not_greaterPtr = - _lookup>( - 'bid32_quiet_not_greater'); - late final _bid32_quiet_not_greater = - _bid32_quiet_not_greaterPtr.asFunction(); - - int bid32_quiet_not_less( - int x, - int y, - ) { - return _bid32_quiet_not_less( - x, - y, - ); - } - - late final _bid32_quiet_not_lessPtr = - _lookup>( - 'bid32_quiet_not_less'); - late final _bid32_quiet_not_less = - _bid32_quiet_not_lessPtr.asFunction(); - - int bid32_quiet_ordered( - int x, - int y, - ) { - return _bid32_quiet_ordered( - x, - y, - ); - } - - late final _bid32_quiet_orderedPtr = - _lookup>( - 'bid32_quiet_ordered'); - late final _bid32_quiet_ordered = - _bid32_quiet_orderedPtr.asFunction(); - - int bid32_quiet_unordered( - int x, - int y, - ) { - return _bid32_quiet_unordered( - x, - y, - ); - } - - late final _bid32_quiet_unorderedPtr = - _lookup>( - 'bid32_quiet_unordered'); - late final _bid32_quiet_unordered = - _bid32_quiet_unorderedPtr.asFunction(); - - int bid32_radix( - int x, - ) { - return _bid32_radix( - x, - ); - } - - late final _bid32_radixPtr = - _lookup>('bid32_radix'); - late final _bid32_radix = _bid32_radixPtr.asFunction(); - - int bid32_rem( - int x, - int y, - ) { - return _bid32_rem( - x, - y, - ); - } - - late final _bid32_remPtr = - _lookup>( - 'bid32_rem'); - late final _bid32_rem = _bid32_remPtr.asFunction(); - - int bid32_round_integral_exact( - int x, - ) { - return _bid32_round_integral_exact( - x, - ); - } - - late final _bid32_round_integral_exactPtr = - _lookup>( - 'bid32_round_integral_exact'); - late final _bid32_round_integral_exact = - _bid32_round_integral_exactPtr.asFunction(); - - int bid32_round_integral_nearest_away( - int x, - ) { - return _bid32_round_integral_nearest_away( - x, - ); - } - - late final _bid32_round_integral_nearest_awayPtr = - _lookup>( - 'bid32_round_integral_nearest_away'); - late final _bid32_round_integral_nearest_away = - _bid32_round_integral_nearest_awayPtr.asFunction(); - - int bid32_round_integral_nearest_even( - int x, - ) { - return _bid32_round_integral_nearest_even( - x, - ); - } - - late final _bid32_round_integral_nearest_evenPtr = - _lookup>( - 'bid32_round_integral_nearest_even'); - late final _bid32_round_integral_nearest_even = - _bid32_round_integral_nearest_evenPtr.asFunction(); - - int bid32_round_integral_negative( - int x, - ) { - return _bid32_round_integral_negative( - x, - ); - } - - late final _bid32_round_integral_negativePtr = - _lookup>( - 'bid32_round_integral_negative'); - late final _bid32_round_integral_negative = - _bid32_round_integral_negativePtr.asFunction(); - - int bid32_round_integral_positive( - int x, - ) { - return _bid32_round_integral_positive( - x, - ); - } - - late final _bid32_round_integral_positivePtr = - _lookup>( - 'bid32_round_integral_positive'); - late final _bid32_round_integral_positive = - _bid32_round_integral_positivePtr.asFunction(); - - int bid32_round_integral_zero( - int x, - ) { - return _bid32_round_integral_zero( - x, - ); - } - - late final _bid32_round_integral_zeroPtr = - _lookup>( - 'bid32_round_integral_zero'); - late final _bid32_round_integral_zero = - _bid32_round_integral_zeroPtr.asFunction(); - - int bid32_sameQuantum( - int x, - int y, - ) { - return _bid32_sameQuantum( - x, - y, - ); - } - - late final _bid32_sameQuantumPtr = - _lookup>( - 'bid32_sameQuantum'); - late final _bid32_sameQuantum = - _bid32_sameQuantumPtr.asFunction(); - - int bid32_scalbln( - int x, - int n, - ) { - return _bid32_scalbln( - x, - n, - ); - } - - late final _bid32_scalblnPtr = - _lookup>( - 'bid32_scalbln'); - late final _bid32_scalbln = - _bid32_scalblnPtr.asFunction(); - - int bid32_scalbn( - int x, - int n, - ) { - return _bid32_scalbn( - x, - n, - ); - } - - late final _bid32_scalbnPtr = - _lookup>( - 'bid32_scalbn'); - late final _bid32_scalbn = - _bid32_scalbnPtr.asFunction(); - - int bid32_signaling_greater( - int x, - int y, - ) { - return _bid32_signaling_greater( - x, - y, - ); - } - - late final _bid32_signaling_greaterPtr = - _lookup>( - 'bid32_signaling_greater'); - late final _bid32_signaling_greater = - _bid32_signaling_greaterPtr.asFunction(); - - int bid32_signaling_greater_equal( - int x, - int y, - ) { - return _bid32_signaling_greater_equal( - x, - y, - ); - } - - late final _bid32_signaling_greater_equalPtr = - _lookup>( - 'bid32_signaling_greater_equal'); - late final _bid32_signaling_greater_equal = - _bid32_signaling_greater_equalPtr.asFunction(); - - int bid32_signaling_greater_unordered( - int x, - int y, - ) { - return _bid32_signaling_greater_unordered( - x, - y, - ); - } - - late final _bid32_signaling_greater_unorderedPtr = - _lookup>( - 'bid32_signaling_greater_unordered'); - late final _bid32_signaling_greater_unordered = - _bid32_signaling_greater_unorderedPtr - .asFunction(); - - int bid32_signaling_less( - int x, - int y, - ) { - return _bid32_signaling_less( - x, - y, - ); - } - - late final _bid32_signaling_lessPtr = - _lookup>( - 'bid32_signaling_less'); - late final _bid32_signaling_less = - _bid32_signaling_lessPtr.asFunction(); - - int bid32_signaling_less_equal( - int x, - int y, - ) { - return _bid32_signaling_less_equal( - x, - y, - ); - } - - late final _bid32_signaling_less_equalPtr = - _lookup>( - 'bid32_signaling_less_equal'); - late final _bid32_signaling_less_equal = - _bid32_signaling_less_equalPtr.asFunction(); - - int bid32_signaling_less_unordered( - int x, - int y, - ) { - return _bid32_signaling_less_unordered( - x, - y, - ); - } - - late final _bid32_signaling_less_unorderedPtr = - _lookup>( - 'bid32_signaling_less_unordered'); - late final _bid32_signaling_less_unordered = - _bid32_signaling_less_unorderedPtr.asFunction(); - - int bid32_signaling_not_greater( - int x, - int y, - ) { - return _bid32_signaling_not_greater( - x, - y, - ); - } - - late final _bid32_signaling_not_greaterPtr = - _lookup>( - 'bid32_signaling_not_greater'); - late final _bid32_signaling_not_greater = - _bid32_signaling_not_greaterPtr.asFunction(); - - int bid32_signaling_not_less( - int x, - int y, - ) { - return _bid32_signaling_not_less( - x, - y, - ); - } - - late final _bid32_signaling_not_lessPtr = - _lookup>( - 'bid32_signaling_not_less'); - late final _bid32_signaling_not_less = - _bid32_signaling_not_lessPtr.asFunction(); - - int bid32_sin( - int x, - ) { - return _bid32_sin( - x, - ); - } - - late final _bid32_sinPtr = - _lookup>('bid32_sin'); - late final _bid32_sin = _bid32_sinPtr.asFunction(); - - int bid32_sinh( - int x, - ) { - return _bid32_sinh( - x, - ); - } - - late final _bid32_sinhPtr = - _lookup>( - 'bid32_sinh'); - late final _bid32_sinh = _bid32_sinhPtr.asFunction(); - - int bid32_sqrt( - int x, - ) { - return _bid32_sqrt( - x, - ); - } - - late final _bid32_sqrtPtr = - _lookup>( - 'bid32_sqrt'); - late final _bid32_sqrt = _bid32_sqrtPtr.asFunction(); - - int bid32_sub( - int x, - int y, - ) { - return _bid32_sub( - x, - y, - ); - } - - late final _bid32_subPtr = - _lookup>( - 'bid32_sub'); - late final _bid32_sub = _bid32_subPtr.asFunction(); - - int bid32_tan( - int x, - ) { - return _bid32_tan( - x, - ); - } - - late final _bid32_tanPtr = - _lookup>('bid32_tan'); - late final _bid32_tan = _bid32_tanPtr.asFunction(); - - int bid32_tanh( - int x, - ) { - return _bid32_tanh( - x, - ); - } - - late final _bid32_tanhPtr = - _lookup>( - 'bid32_tanh'); - late final _bid32_tanh = _bid32_tanhPtr.asFunction(); - - int bid32_tgamma( - int x, - ) { - return _bid32_tgamma( - x, - ); - } - - late final _bid32_tgammaPtr = - _lookup>( - 'bid32_tgamma'); - late final _bid32_tgamma = _bid32_tgammaPtr.asFunction(); - - BID_UINT128 bid32_to_bid128( - int x, - ) { - return _bid32_to_bid128( - x, - ); - } - - late final _bid32_to_bid128Ptr = - _lookup>( - 'bid32_to_bid128'); - late final _bid32_to_bid128 = - _bid32_to_bid128Ptr.asFunction(); - - int bid32_to_bid64( - int x, - ) { - return _bid32_to_bid64( - x, - ); - } - - late final _bid32_to_bid64Ptr = - _lookup>( - 'bid32_to_bid64'); - late final _bid32_to_bid64 = - _bid32_to_bid64Ptr.asFunction(); - - BID_UINT128 bid32_to_binary128( - int x, - ) { - return _bid32_to_binary128( - x, - ); - } - - late final _bid32_to_binary128Ptr = - _lookup>( - 'bid32_to_binary128'); - late final _bid32_to_binary128 = - _bid32_to_binary128Ptr.asFunction(); - - double bid32_to_binary32( - int x, - ) { - return _bid32_to_binary32( - x, - ); - } - - late final _bid32_to_binary32Ptr = - _lookup>( - 'bid32_to_binary32'); - late final _bid32_to_binary32 = - _bid32_to_binary32Ptr.asFunction(); - - double bid32_to_binary64( - int x, - ) { - return _bid32_to_binary64( - x, - ); - } - - late final _bid32_to_binary64Ptr = - _lookup>( - 'bid32_to_binary64'); - late final _bid32_to_binary64 = - _bid32_to_binary64Ptr.asFunction(); - - int bid32_to_int16_ceil( - int x, - ) { - return _bid32_to_int16_ceil( - x, - ); - } - - late final _bid32_to_int16_ceilPtr = - _lookup>( - 'bid32_to_int16_ceil'); - late final _bid32_to_int16_ceil = - _bid32_to_int16_ceilPtr.asFunction(); - - int bid32_to_int16_floor( - int x, - ) { - return _bid32_to_int16_floor( - x, - ); - } - - late final _bid32_to_int16_floorPtr = - _lookup>( - 'bid32_to_int16_floor'); - late final _bid32_to_int16_floor = - _bid32_to_int16_floorPtr.asFunction(); - - int bid32_to_int16_int( - int x, - ) { - return _bid32_to_int16_int( - x, - ); - } - - late final _bid32_to_int16_intPtr = - _lookup>( - 'bid32_to_int16_int'); - late final _bid32_to_int16_int = - _bid32_to_int16_intPtr.asFunction(); - - int bid32_to_int16_rnint( - int x, - ) { - return _bid32_to_int16_rnint( - x, - ); - } - - late final _bid32_to_int16_rnintPtr = - _lookup>( - 'bid32_to_int16_rnint'); - late final _bid32_to_int16_rnint = - _bid32_to_int16_rnintPtr.asFunction(); - - int bid32_to_int16_rninta( - int x, - ) { - return _bid32_to_int16_rninta( - x, - ); - } - - late final _bid32_to_int16_rnintaPtr = - _lookup>( - 'bid32_to_int16_rninta'); - late final _bid32_to_int16_rninta = - _bid32_to_int16_rnintaPtr.asFunction(); - - int bid32_to_int16_xceil( - int x, - ) { - return _bid32_to_int16_xceil( - x, - ); - } - - late final _bid32_to_int16_xceilPtr = - _lookup>( - 'bid32_to_int16_xceil'); - late final _bid32_to_int16_xceil = - _bid32_to_int16_xceilPtr.asFunction(); - - int bid32_to_int16_xfloor( - int x, - ) { - return _bid32_to_int16_xfloor( - x, - ); - } - - late final _bid32_to_int16_xfloorPtr = - _lookup>( - 'bid32_to_int16_xfloor'); - late final _bid32_to_int16_xfloor = - _bid32_to_int16_xfloorPtr.asFunction(); - - int bid32_to_int16_xint( - int x, - ) { - return _bid32_to_int16_xint( - x, - ); - } - - late final _bid32_to_int16_xintPtr = - _lookup>( - 'bid32_to_int16_xint'); - late final _bid32_to_int16_xint = - _bid32_to_int16_xintPtr.asFunction(); - - int bid32_to_int16_xrnint( - int x, - ) { - return _bid32_to_int16_xrnint( - x, - ); - } - - late final _bid32_to_int16_xrnintPtr = - _lookup>( - 'bid32_to_int16_xrnint'); - late final _bid32_to_int16_xrnint = - _bid32_to_int16_xrnintPtr.asFunction(); - - int bid32_to_int16_xrninta( - int x, - ) { - return _bid32_to_int16_xrninta( - x, - ); - } - - late final _bid32_to_int16_xrnintaPtr = - _lookup>( - 'bid32_to_int16_xrninta'); - late final _bid32_to_int16_xrninta = - _bid32_to_int16_xrnintaPtr.asFunction(); - - int bid32_to_int32_ceil( - int x, - ) { - return _bid32_to_int32_ceil( - x, - ); - } - - late final _bid32_to_int32_ceilPtr = - _lookup>( - 'bid32_to_int32_ceil'); - late final _bid32_to_int32_ceil = - _bid32_to_int32_ceilPtr.asFunction(); - - int bid32_to_int32_floor( - int x, - ) { - return _bid32_to_int32_floor( - x, - ); - } - - late final _bid32_to_int32_floorPtr = - _lookup>( - 'bid32_to_int32_floor'); - late final _bid32_to_int32_floor = - _bid32_to_int32_floorPtr.asFunction(); - - int bid32_to_int32_int( - int x, - ) { - return _bid32_to_int32_int( - x, - ); - } - - late final _bid32_to_int32_intPtr = - _lookup>( - 'bid32_to_int32_int'); - late final _bid32_to_int32_int = - _bid32_to_int32_intPtr.asFunction(); - - int bid32_to_int32_rnint( - int x, - ) { - return _bid32_to_int32_rnint( - x, - ); - } - - late final _bid32_to_int32_rnintPtr = - _lookup>( - 'bid32_to_int32_rnint'); - late final _bid32_to_int32_rnint = - _bid32_to_int32_rnintPtr.asFunction(); - - int bid32_to_int32_rninta( - int x, - ) { - return _bid32_to_int32_rninta( - x, - ); - } - - late final _bid32_to_int32_rnintaPtr = - _lookup>( - 'bid32_to_int32_rninta'); - late final _bid32_to_int32_rninta = - _bid32_to_int32_rnintaPtr.asFunction(); - - int bid32_to_int32_xceil( - int x, - ) { - return _bid32_to_int32_xceil( - x, - ); - } - - late final _bid32_to_int32_xceilPtr = - _lookup>( - 'bid32_to_int32_xceil'); - late final _bid32_to_int32_xceil = - _bid32_to_int32_xceilPtr.asFunction(); - - int bid32_to_int32_xfloor( - int x, - ) { - return _bid32_to_int32_xfloor( - x, - ); - } - - late final _bid32_to_int32_xfloorPtr = - _lookup>( - 'bid32_to_int32_xfloor'); - late final _bid32_to_int32_xfloor = - _bid32_to_int32_xfloorPtr.asFunction(); - - int bid32_to_int32_xint( - int x, - ) { - return _bid32_to_int32_xint( - x, - ); - } - - late final _bid32_to_int32_xintPtr = - _lookup>( - 'bid32_to_int32_xint'); - late final _bid32_to_int32_xint = - _bid32_to_int32_xintPtr.asFunction(); - - int bid32_to_int32_xrnint( - int x, - ) { - return _bid32_to_int32_xrnint( - x, - ); - } - - late final _bid32_to_int32_xrnintPtr = - _lookup>( - 'bid32_to_int32_xrnint'); - late final _bid32_to_int32_xrnint = - _bid32_to_int32_xrnintPtr.asFunction(); - - int bid32_to_int32_xrninta( - int x, - ) { - return _bid32_to_int32_xrninta( - x, - ); - } - - late final _bid32_to_int32_xrnintaPtr = - _lookup>( - 'bid32_to_int32_xrninta'); - late final _bid32_to_int32_xrninta = - _bid32_to_int32_xrnintaPtr.asFunction(); - - int bid32_to_int64_ceil( - int x, - ) { - return _bid32_to_int64_ceil( - x, - ); - } - - late final _bid32_to_int64_ceilPtr = - _lookup>( - 'bid32_to_int64_ceil'); - late final _bid32_to_int64_ceil = - _bid32_to_int64_ceilPtr.asFunction(); - - int bid32_to_int64_floor( - int x, - ) { - return _bid32_to_int64_floor( - x, - ); - } - - late final _bid32_to_int64_floorPtr = - _lookup>( - 'bid32_to_int64_floor'); - late final _bid32_to_int64_floor = - _bid32_to_int64_floorPtr.asFunction(); - - int bid32_to_int64_int( - int x, - ) { - return _bid32_to_int64_int( - x, - ); - } - - late final _bid32_to_int64_intPtr = - _lookup>( - 'bid32_to_int64_int'); - late final _bid32_to_int64_int = - _bid32_to_int64_intPtr.asFunction(); - - int bid32_to_int64_rnint( - int x, - ) { - return _bid32_to_int64_rnint( - x, - ); - } - - late final _bid32_to_int64_rnintPtr = - _lookup>( - 'bid32_to_int64_rnint'); - late final _bid32_to_int64_rnint = - _bid32_to_int64_rnintPtr.asFunction(); - - int bid32_to_int64_rninta( - int x, - ) { - return _bid32_to_int64_rninta( - x, - ); - } - - late final _bid32_to_int64_rnintaPtr = - _lookup>( - 'bid32_to_int64_rninta'); - late final _bid32_to_int64_rninta = - _bid32_to_int64_rnintaPtr.asFunction(); - - int bid32_to_int64_xceil( - int x, - ) { - return _bid32_to_int64_xceil( - x, - ); - } - - late final _bid32_to_int64_xceilPtr = - _lookup>( - 'bid32_to_int64_xceil'); - late final _bid32_to_int64_xceil = - _bid32_to_int64_xceilPtr.asFunction(); - - int bid32_to_int64_xfloor( - int x, - ) { - return _bid32_to_int64_xfloor( - x, - ); - } - - late final _bid32_to_int64_xfloorPtr = - _lookup>( - 'bid32_to_int64_xfloor'); - late final _bid32_to_int64_xfloor = - _bid32_to_int64_xfloorPtr.asFunction(); - - int bid32_to_int64_xint( - int x, - ) { - return _bid32_to_int64_xint( - x, - ); - } - - late final _bid32_to_int64_xintPtr = - _lookup>( - 'bid32_to_int64_xint'); - late final _bid32_to_int64_xint = - _bid32_to_int64_xintPtr.asFunction(); - - int bid32_to_int64_xrnint( - int x, - ) { - return _bid32_to_int64_xrnint( - x, - ); - } - - late final _bid32_to_int64_xrnintPtr = - _lookup>( - 'bid32_to_int64_xrnint'); - late final _bid32_to_int64_xrnint = - _bid32_to_int64_xrnintPtr.asFunction(); - - int bid32_to_int64_xrninta( - int x, - ) { - return _bid32_to_int64_xrninta( - x, - ); - } - - late final _bid32_to_int64_xrnintaPtr = - _lookup>( - 'bid32_to_int64_xrninta'); - late final _bid32_to_int64_xrninta = - _bid32_to_int64_xrnintaPtr.asFunction(); - - int bid32_to_int8_ceil( - int x, - ) { - return _bid32_to_int8_ceil( - x, - ); - } - - late final _bid32_to_int8_ceilPtr = - _lookup>( - 'bid32_to_int8_ceil'); - late final _bid32_to_int8_ceil = - _bid32_to_int8_ceilPtr.asFunction(); - - int bid32_to_int8_floor( - int x, - ) { - return _bid32_to_int8_floor( - x, - ); - } - - late final _bid32_to_int8_floorPtr = - _lookup>( - 'bid32_to_int8_floor'); - late final _bid32_to_int8_floor = - _bid32_to_int8_floorPtr.asFunction(); - - int bid32_to_int8_int( - int x, - ) { - return _bid32_to_int8_int( - x, - ); - } - - late final _bid32_to_int8_intPtr = - _lookup>( - 'bid32_to_int8_int'); - late final _bid32_to_int8_int = - _bid32_to_int8_intPtr.asFunction(); - - int bid32_to_int8_rnint( - int x, - ) { - return _bid32_to_int8_rnint( - x, - ); - } - - late final _bid32_to_int8_rnintPtr = - _lookup>( - 'bid32_to_int8_rnint'); - late final _bid32_to_int8_rnint = - _bid32_to_int8_rnintPtr.asFunction(); - - int bid32_to_int8_rninta( - int x, - ) { - return _bid32_to_int8_rninta( - x, - ); - } - - late final _bid32_to_int8_rnintaPtr = - _lookup>( - 'bid32_to_int8_rninta'); - late final _bid32_to_int8_rninta = - _bid32_to_int8_rnintaPtr.asFunction(); - - int bid32_to_int8_xceil( - int x, - ) { - return _bid32_to_int8_xceil( - x, - ); - } - - late final _bid32_to_int8_xceilPtr = - _lookup>( - 'bid32_to_int8_xceil'); - late final _bid32_to_int8_xceil = - _bid32_to_int8_xceilPtr.asFunction(); - - int bid32_to_int8_xfloor( - int x, - ) { - return _bid32_to_int8_xfloor( - x, - ); - } - - late final _bid32_to_int8_xfloorPtr = - _lookup>( - 'bid32_to_int8_xfloor'); - late final _bid32_to_int8_xfloor = - _bid32_to_int8_xfloorPtr.asFunction(); - - int bid32_to_int8_xint( - int x, - ) { - return _bid32_to_int8_xint( - x, - ); - } - - late final _bid32_to_int8_xintPtr = - _lookup>( - 'bid32_to_int8_xint'); - late final _bid32_to_int8_xint = - _bid32_to_int8_xintPtr.asFunction(); - - int bid32_to_int8_xrnint( - int x, - ) { - return _bid32_to_int8_xrnint( - x, - ); - } - - late final _bid32_to_int8_xrnintPtr = - _lookup>( - 'bid32_to_int8_xrnint'); - late final _bid32_to_int8_xrnint = - _bid32_to_int8_xrnintPtr.asFunction(); - - int bid32_to_int8_xrninta( - int x, - ) { - return _bid32_to_int8_xrninta( - x, - ); - } - - late final _bid32_to_int8_xrnintaPtr = - _lookup>( - 'bid32_to_int8_xrninta'); - late final _bid32_to_int8_xrninta = - _bid32_to_int8_xrnintaPtr.asFunction(); - - void bid32_to_string( - ffi.Pointer ps, - int x, - ) { - return _bid32_to_string( - ps, - x, - ); - } - - late final _bid32_to_stringPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, BID_UINT32)>>('bid32_to_string'); - late final _bid32_to_string = _bid32_to_stringPtr - .asFunction, int)>(); - - int bid32_to_uint16_ceil( - int x, - ) { - return _bid32_to_uint16_ceil( - x, - ); - } - - late final _bid32_to_uint16_ceilPtr = - _lookup>( - 'bid32_to_uint16_ceil'); - late final _bid32_to_uint16_ceil = - _bid32_to_uint16_ceilPtr.asFunction(); - - int bid32_to_uint16_floor( - int x, - ) { - return _bid32_to_uint16_floor( - x, - ); - } - - late final _bid32_to_uint16_floorPtr = - _lookup>( - 'bid32_to_uint16_floor'); - late final _bid32_to_uint16_floor = - _bid32_to_uint16_floorPtr.asFunction(); - - int bid32_to_uint16_int( - int x, - ) { - return _bid32_to_uint16_int( - x, - ); - } - - late final _bid32_to_uint16_intPtr = - _lookup>( - 'bid32_to_uint16_int'); - late final _bid32_to_uint16_int = - _bid32_to_uint16_intPtr.asFunction(); - - int bid32_to_uint16_rnint( - int x, - ) { - return _bid32_to_uint16_rnint( - x, - ); - } - - late final _bid32_to_uint16_rnintPtr = - _lookup>( - 'bid32_to_uint16_rnint'); - late final _bid32_to_uint16_rnint = - _bid32_to_uint16_rnintPtr.asFunction(); - - int bid32_to_uint16_rninta( - int x, - ) { - return _bid32_to_uint16_rninta( - x, - ); - } - - late final _bid32_to_uint16_rnintaPtr = - _lookup>( - 'bid32_to_uint16_rninta'); - late final _bid32_to_uint16_rninta = - _bid32_to_uint16_rnintaPtr.asFunction(); - - int bid32_to_uint16_xceil( - int x, - ) { - return _bid32_to_uint16_xceil( - x, - ); - } - - late final _bid32_to_uint16_xceilPtr = - _lookup>( - 'bid32_to_uint16_xceil'); - late final _bid32_to_uint16_xceil = - _bid32_to_uint16_xceilPtr.asFunction(); - - int bid32_to_uint16_xfloor( - int x, - ) { - return _bid32_to_uint16_xfloor( - x, - ); - } - - late final _bid32_to_uint16_xfloorPtr = - _lookup>( - 'bid32_to_uint16_xfloor'); - late final _bid32_to_uint16_xfloor = - _bid32_to_uint16_xfloorPtr.asFunction(); - - int bid32_to_uint16_xint( - int x, - ) { - return _bid32_to_uint16_xint( - x, - ); - } - - late final _bid32_to_uint16_xintPtr = - _lookup>( - 'bid32_to_uint16_xint'); - late final _bid32_to_uint16_xint = - _bid32_to_uint16_xintPtr.asFunction(); - - int bid32_to_uint16_xrnint( - int x, - ) { - return _bid32_to_uint16_xrnint( - x, - ); - } - - late final _bid32_to_uint16_xrnintPtr = - _lookup>( - 'bid32_to_uint16_xrnint'); - late final _bid32_to_uint16_xrnint = - _bid32_to_uint16_xrnintPtr.asFunction(); - - int bid32_to_uint16_xrninta( - int x, - ) { - return _bid32_to_uint16_xrninta( - x, - ); - } - - late final _bid32_to_uint16_xrnintaPtr = - _lookup>( - 'bid32_to_uint16_xrninta'); - late final _bid32_to_uint16_xrninta = - _bid32_to_uint16_xrnintaPtr.asFunction(); - - int bid32_to_uint32_ceil( - int x, - ) { - return _bid32_to_uint32_ceil( - x, - ); - } - - late final _bid32_to_uint32_ceilPtr = - _lookup>( - 'bid32_to_uint32_ceil'); - late final _bid32_to_uint32_ceil = - _bid32_to_uint32_ceilPtr.asFunction(); - - int bid32_to_uint32_floor( - int x, - ) { - return _bid32_to_uint32_floor( - x, - ); - } - - late final _bid32_to_uint32_floorPtr = - _lookup>( - 'bid32_to_uint32_floor'); - late final _bid32_to_uint32_floor = - _bid32_to_uint32_floorPtr.asFunction(); - - int bid32_to_uint32_int( - int x, - ) { - return _bid32_to_uint32_int( - x, - ); - } - - late final _bid32_to_uint32_intPtr = - _lookup>( - 'bid32_to_uint32_int'); - late final _bid32_to_uint32_int = - _bid32_to_uint32_intPtr.asFunction(); - - int bid32_to_uint32_rnint( - int x, - ) { - return _bid32_to_uint32_rnint( - x, - ); - } - - late final _bid32_to_uint32_rnintPtr = - _lookup>( - 'bid32_to_uint32_rnint'); - late final _bid32_to_uint32_rnint = - _bid32_to_uint32_rnintPtr.asFunction(); - - int bid32_to_uint32_rninta( - int x, - ) { - return _bid32_to_uint32_rninta( - x, - ); - } - - late final _bid32_to_uint32_rnintaPtr = - _lookup>( - 'bid32_to_uint32_rninta'); - late final _bid32_to_uint32_rninta = - _bid32_to_uint32_rnintaPtr.asFunction(); - - int bid32_to_uint32_xceil( - int x, - ) { - return _bid32_to_uint32_xceil( - x, - ); - } - - late final _bid32_to_uint32_xceilPtr = - _lookup>( - 'bid32_to_uint32_xceil'); - late final _bid32_to_uint32_xceil = - _bid32_to_uint32_xceilPtr.asFunction(); - - int bid32_to_uint32_xfloor( - int x, - ) { - return _bid32_to_uint32_xfloor( - x, - ); - } - - late final _bid32_to_uint32_xfloorPtr = - _lookup>( - 'bid32_to_uint32_xfloor'); - late final _bid32_to_uint32_xfloor = - _bid32_to_uint32_xfloorPtr.asFunction(); - - int bid32_to_uint32_xint( - int x, - ) { - return _bid32_to_uint32_xint( - x, - ); - } - - late final _bid32_to_uint32_xintPtr = - _lookup>( - 'bid32_to_uint32_xint'); - late final _bid32_to_uint32_xint = - _bid32_to_uint32_xintPtr.asFunction(); - - int bid32_to_uint32_xrnint( - int x, - ) { - return _bid32_to_uint32_xrnint( - x, - ); - } - - late final _bid32_to_uint32_xrnintPtr = - _lookup>( - 'bid32_to_uint32_xrnint'); - late final _bid32_to_uint32_xrnint = - _bid32_to_uint32_xrnintPtr.asFunction(); - - int bid32_to_uint32_xrninta( - int x, - ) { - return _bid32_to_uint32_xrninta( - x, - ); - } - - late final _bid32_to_uint32_xrnintaPtr = - _lookup>( - 'bid32_to_uint32_xrninta'); - late final _bid32_to_uint32_xrninta = - _bid32_to_uint32_xrnintaPtr.asFunction(); - - int bid32_to_uint64_ceil( - int x, - ) { - return _bid32_to_uint64_ceil( - x, - ); - } - - late final _bid32_to_uint64_ceilPtr = - _lookup>( - 'bid32_to_uint64_ceil'); - late final _bid32_to_uint64_ceil = - _bid32_to_uint64_ceilPtr.asFunction(); - - int bid32_to_uint64_floor( - int x, - ) { - return _bid32_to_uint64_floor( - x, - ); - } - - late final _bid32_to_uint64_floorPtr = - _lookup>( - 'bid32_to_uint64_floor'); - late final _bid32_to_uint64_floor = - _bid32_to_uint64_floorPtr.asFunction(); - - int bid32_to_uint64_int( - int x, - ) { - return _bid32_to_uint64_int( - x, - ); - } - - late final _bid32_to_uint64_intPtr = - _lookup>( - 'bid32_to_uint64_int'); - late final _bid32_to_uint64_int = - _bid32_to_uint64_intPtr.asFunction(); - - int bid32_to_uint64_rnint( - int x, - ) { - return _bid32_to_uint64_rnint( - x, - ); - } - - late final _bid32_to_uint64_rnintPtr = - _lookup>( - 'bid32_to_uint64_rnint'); - late final _bid32_to_uint64_rnint = - _bid32_to_uint64_rnintPtr.asFunction(); - - int bid32_to_uint64_rninta( - int x, - ) { - return _bid32_to_uint64_rninta( - x, - ); - } - - late final _bid32_to_uint64_rnintaPtr = - _lookup>( - 'bid32_to_uint64_rninta'); - late final _bid32_to_uint64_rninta = - _bid32_to_uint64_rnintaPtr.asFunction(); - - int bid32_to_uint64_xceil( - int x, - ) { - return _bid32_to_uint64_xceil( - x, - ); - } - - late final _bid32_to_uint64_xceilPtr = - _lookup>( - 'bid32_to_uint64_xceil'); - late final _bid32_to_uint64_xceil = - _bid32_to_uint64_xceilPtr.asFunction(); - - int bid32_to_uint64_xfloor( - int x, - ) { - return _bid32_to_uint64_xfloor( - x, - ); - } - - late final _bid32_to_uint64_xfloorPtr = - _lookup>( - 'bid32_to_uint64_xfloor'); - late final _bid32_to_uint64_xfloor = - _bid32_to_uint64_xfloorPtr.asFunction(); - - int bid32_to_uint64_xint( - int x, - ) { - return _bid32_to_uint64_xint( - x, - ); - } - - late final _bid32_to_uint64_xintPtr = - _lookup>( - 'bid32_to_uint64_xint'); - late final _bid32_to_uint64_xint = - _bid32_to_uint64_xintPtr.asFunction(); - - int bid32_to_uint64_xrnint( - int x, - ) { - return _bid32_to_uint64_xrnint( - x, - ); - } - - late final _bid32_to_uint64_xrnintPtr = - _lookup>( - 'bid32_to_uint64_xrnint'); - late final _bid32_to_uint64_xrnint = - _bid32_to_uint64_xrnintPtr.asFunction(); - - int bid32_to_uint64_xrninta( - int x, - ) { - return _bid32_to_uint64_xrninta( - x, - ); - } - - late final _bid32_to_uint64_xrnintaPtr = - _lookup>( - 'bid32_to_uint64_xrninta'); - late final _bid32_to_uint64_xrninta = - _bid32_to_uint64_xrnintaPtr.asFunction(); - - int bid32_to_uint8_ceil( - int x, - ) { - return _bid32_to_uint8_ceil( - x, - ); - } - - late final _bid32_to_uint8_ceilPtr = - _lookup>( - 'bid32_to_uint8_ceil'); - late final _bid32_to_uint8_ceil = - _bid32_to_uint8_ceilPtr.asFunction(); - - int bid32_to_uint8_floor( - int x, - ) { - return _bid32_to_uint8_floor( - x, - ); - } - - late final _bid32_to_uint8_floorPtr = - _lookup>( - 'bid32_to_uint8_floor'); - late final _bid32_to_uint8_floor = - _bid32_to_uint8_floorPtr.asFunction(); - - int bid32_to_uint8_int( - int x, - ) { - return _bid32_to_uint8_int( - x, - ); - } - - late final _bid32_to_uint8_intPtr = - _lookup>( - 'bid32_to_uint8_int'); - late final _bid32_to_uint8_int = - _bid32_to_uint8_intPtr.asFunction(); - - int bid32_to_uint8_rnint( - int x, - ) { - return _bid32_to_uint8_rnint( - x, - ); - } - - late final _bid32_to_uint8_rnintPtr = - _lookup>( - 'bid32_to_uint8_rnint'); - late final _bid32_to_uint8_rnint = - _bid32_to_uint8_rnintPtr.asFunction(); - - int bid32_to_uint8_rninta( - int x, - ) { - return _bid32_to_uint8_rninta( - x, - ); - } - - late final _bid32_to_uint8_rnintaPtr = - _lookup>( - 'bid32_to_uint8_rninta'); - late final _bid32_to_uint8_rninta = - _bid32_to_uint8_rnintaPtr.asFunction(); - - int bid32_to_uint8_xceil( - int x, - ) { - return _bid32_to_uint8_xceil( - x, - ); - } - - late final _bid32_to_uint8_xceilPtr = - _lookup>( - 'bid32_to_uint8_xceil'); - late final _bid32_to_uint8_xceil = - _bid32_to_uint8_xceilPtr.asFunction(); - - int bid32_to_uint8_xfloor( - int x, - ) { - return _bid32_to_uint8_xfloor( - x, - ); - } - - late final _bid32_to_uint8_xfloorPtr = - _lookup>( - 'bid32_to_uint8_xfloor'); - late final _bid32_to_uint8_xfloor = - _bid32_to_uint8_xfloorPtr.asFunction(); - - int bid32_to_uint8_xint( - int x, - ) { - return _bid32_to_uint8_xint( - x, - ); - } - - late final _bid32_to_uint8_xintPtr = - _lookup>( - 'bid32_to_uint8_xint'); - late final _bid32_to_uint8_xint = - _bid32_to_uint8_xintPtr.asFunction(); - - int bid32_to_uint8_xrnint( - int x, - ) { - return _bid32_to_uint8_xrnint( - x, - ); - } - - late final _bid32_to_uint8_xrnintPtr = - _lookup>( - 'bid32_to_uint8_xrnint'); - late final _bid32_to_uint8_xrnint = - _bid32_to_uint8_xrnintPtr.asFunction(); - - int bid32_to_uint8_xrninta( - int x, - ) { - return _bid32_to_uint8_xrninta( - x, - ); - } - - late final _bid32_to_uint8_xrnintaPtr = - _lookup>( - 'bid32_to_uint8_xrninta'); - late final _bid32_to_uint8_xrninta = - _bid32_to_uint8_xrnintaPtr.asFunction(); - - int bid32_totalOrder( - int x, - int y, - ) { - return _bid32_totalOrder( - x, - y, - ); - } - - late final _bid32_totalOrderPtr = - _lookup>( - 'bid32_totalOrder'); - late final _bid32_totalOrder = - _bid32_totalOrderPtr.asFunction(); - - int bid32_totalOrderMag( - int x, - int y, - ) { - return _bid32_totalOrderMag( - x, - y, - ); - } - - late final _bid32_totalOrderMagPtr = - _lookup>( - 'bid32_totalOrderMag'); - late final _bid32_totalOrderMag = - _bid32_totalOrderMagPtr.asFunction(); - - int bid64_abs( - int x, - ) { - return _bid64_abs( - x, - ); - } - - late final _bid64_absPtr = - _lookup>('bid64_abs'); - late final _bid64_abs = _bid64_absPtr.asFunction(); - - int bid64_acos( - int x, - ) { - return _bid64_acos( - x, - ); - } - - late final _bid64_acosPtr = - _lookup>( - 'bid64_acos'); - late final _bid64_acos = _bid64_acosPtr.asFunction(); - - int bid64_acosh( - int x, - ) { - return _bid64_acosh( - x, - ); - } - - late final _bid64_acoshPtr = - _lookup>( - 'bid64_acosh'); - late final _bid64_acosh = _bid64_acoshPtr.asFunction(); - - int bid64_add( - int x, - int y, - ) { - return _bid64_add( - x, - y, - ); - } - - late final _bid64_addPtr = - _lookup>( - 'bid64_add'); - late final _bid64_add = _bid64_addPtr.asFunction(); - - int bid64_asin( - int x, - ) { - return _bid64_asin( - x, - ); - } - - late final _bid64_asinPtr = - _lookup>( - 'bid64_asin'); - late final _bid64_asin = _bid64_asinPtr.asFunction(); - - int bid64_asinh( - int x, - ) { - return _bid64_asinh( - x, - ); - } - - late final _bid64_asinhPtr = - _lookup>( - 'bid64_asinh'); - late final _bid64_asinh = _bid64_asinhPtr.asFunction(); - - int bid64_atan( - int x, - ) { - return _bid64_atan( - x, - ); - } - - late final _bid64_atanPtr = - _lookup>( - 'bid64_atan'); - late final _bid64_atan = _bid64_atanPtr.asFunction(); - - int bid64_atan2( - int x, - int y, - ) { - return _bid64_atan2( - x, - y, - ); - } - - late final _bid64_atan2Ptr = - _lookup>( - 'bid64_atan2'); - late final _bid64_atan2 = - _bid64_atan2Ptr.asFunction(); - - int bid64_atanh( - int x, - ) { - return _bid64_atanh( - x, - ); - } - - late final _bid64_atanhPtr = - _lookup>( - 'bid64_atanh'); - late final _bid64_atanh = _bid64_atanhPtr.asFunction(); - - int bid64_cbrt( - int x, - ) { - return _bid64_cbrt( - x, - ); - } - - late final _bid64_cbrtPtr = - _lookup>( - 'bid64_cbrt'); - late final _bid64_cbrt = _bid64_cbrtPtr.asFunction(); - - int bid64_class( - int x, - ) { - return _bid64_class( - x, - ); - } - - late final _bid64_classPtr = - _lookup>('bid64_class'); - late final _bid64_class = _bid64_classPtr.asFunction(); - - int bid64_copy( - int x, - ) { - return _bid64_copy( - x, - ); - } - - late final _bid64_copyPtr = - _lookup>( - 'bid64_copy'); - late final _bid64_copy = _bid64_copyPtr.asFunction(); - - int bid64_copySign( - int x, - int y, - ) { - return _bid64_copySign( - x, - y, - ); - } - - late final _bid64_copySignPtr = - _lookup>( - 'bid64_copySign'); - late final _bid64_copySign = - _bid64_copySignPtr.asFunction(); - - int bid64_cos( - int x, - ) { - return _bid64_cos( - x, - ); - } - - late final _bid64_cosPtr = - _lookup>('bid64_cos'); - late final _bid64_cos = _bid64_cosPtr.asFunction(); - - int bid64_cosh( - int x, - ) { - return _bid64_cosh( - x, - ); - } - - late final _bid64_coshPtr = - _lookup>( - 'bid64_cosh'); - late final _bid64_cosh = _bid64_coshPtr.asFunction(); - - int bid64_div( - int x, - int y, - ) { - return _bid64_div( - x, - y, - ); - } - - late final _bid64_divPtr = - _lookup>( - 'bid64_div'); - late final _bid64_div = _bid64_divPtr.asFunction(); - - int bid64_erf( - int x, - ) { - return _bid64_erf( - x, - ); - } - - late final _bid64_erfPtr = - _lookup>('bid64_erf'); - late final _bid64_erf = _bid64_erfPtr.asFunction(); - - int bid64_erfc( - int x, - ) { - return _bid64_erfc( - x, - ); - } - - late final _bid64_erfcPtr = - _lookup>( - 'bid64_erfc'); - late final _bid64_erfc = _bid64_erfcPtr.asFunction(); - - int bid64_exp( - int x, - ) { - return _bid64_exp( - x, - ); - } - - late final _bid64_expPtr = - _lookup>('bid64_exp'); - late final _bid64_exp = _bid64_expPtr.asFunction(); - - int bid64_exp10( - int x, - ) { - return _bid64_exp10( - x, - ); - } - - late final _bid64_exp10Ptr = - _lookup>( - 'bid64_exp10'); - late final _bid64_exp10 = _bid64_exp10Ptr.asFunction(); - - int bid64_exp2( - int x, - ) { - return _bid64_exp2( - x, - ); - } - - late final _bid64_exp2Ptr = - _lookup>( - 'bid64_exp2'); - late final _bid64_exp2 = _bid64_exp2Ptr.asFunction(); - - int bid64_expm1( - int x, - ) { - return _bid64_expm1( - x, - ); - } - - late final _bid64_expm1Ptr = - _lookup>( - 'bid64_expm1'); - late final _bid64_expm1 = _bid64_expm1Ptr.asFunction(); - - int bid64_fdim( - int x, - int y, - ) { - return _bid64_fdim( - x, - y, - ); - } - - late final _bid64_fdimPtr = - _lookup>( - 'bid64_fdim'); - late final _bid64_fdim = _bid64_fdimPtr.asFunction(); - - int bid64_fma( - int x, - int y, - int z, - ) { - return _bid64_fma( - x, - y, - z, - ); - } - - late final _bid64_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT64, BID_UINT64, BID_UINT64)>>('bid64_fma'); - late final _bid64_fma = - _bid64_fmaPtr.asFunction(); - - int bid64_fmod( - int x, - int y, - ) { - return _bid64_fmod( - x, - y, - ); - } - - late final _bid64_fmodPtr = - _lookup>( - 'bid64_fmod'); - late final _bid64_fmod = _bid64_fmodPtr.asFunction(); - - int bid64_frexp( - int x, - ffi.Pointer exp, - ) { - return _bid64_frexp( - x, - exp, - ); - } - - late final _bid64_frexpPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT64, ffi.Pointer)>>('bid64_frexp'); - late final _bid64_frexp = - _bid64_frexpPtr.asFunction)>(); - - int bid64_from_int32( - int x, - ) { - return _bid64_from_int32( - x, - ); - } - - late final _bid64_from_int32Ptr = - _lookup>( - 'bid64_from_int32'); - late final _bid64_from_int32 = - _bid64_from_int32Ptr.asFunction(); - - int bid64_from_int64( - int x, - ) { - return _bid64_from_int64( - x, - ); - } - - late final _bid64_from_int64Ptr = - _lookup>( - 'bid64_from_int64'); - late final _bid64_from_int64 = - _bid64_from_int64Ptr.asFunction(); - - int bid64_from_string( - ffi.Pointer ps, - ) { - return _bid64_from_string( - ps, - ); - } - - late final _bid64_from_stringPtr = - _lookup)>>( - 'bid64_from_string'); - late final _bid64_from_string = - _bid64_from_stringPtr.asFunction)>(); - - int bid64_from_uint32( - int x, - ) { - return _bid64_from_uint32( - x, - ); - } - - late final _bid64_from_uint32Ptr = - _lookup>( - 'bid64_from_uint32'); - late final _bid64_from_uint32 = - _bid64_from_uint32Ptr.asFunction(); - - int bid64_from_uint64( - int _RND_MODE_PARAM, - ) { - return _bid64_from_uint64( - _RND_MODE_PARAM, - ); - } - - late final _bid64_from_uint64Ptr = - _lookup>( - 'bid64_from_uint64'); - late final _bid64_from_uint64 = - _bid64_from_uint64Ptr.asFunction(); - - int bid64_hypot( - int x, - int y, - ) { - return _bid64_hypot( - x, - y, - ); - } - - late final _bid64_hypotPtr = - _lookup>( - 'bid64_hypot'); - late final _bid64_hypot = - _bid64_hypotPtr.asFunction(); - - int bid64_ilogb( - int x, - ) { - return _bid64_ilogb( - x, - ); - } - - late final _bid64_ilogbPtr = - _lookup>('bid64_ilogb'); - late final _bid64_ilogb = _bid64_ilogbPtr.asFunction(); - - int bid64_inf() { - return _bid64_inf(); - } - - late final _bid64_infPtr = - _lookup>('bid64_inf'); - late final _bid64_inf = _bid64_infPtr.asFunction(); - - int bid64_isCanonical( - int x, - ) { - return _bid64_isCanonical( - x, - ); - } - - late final _bid64_isCanonicalPtr = - _lookup>( - 'bid64_isCanonical'); - late final _bid64_isCanonical = - _bid64_isCanonicalPtr.asFunction(); - - int bid64_isFinite( - int x, - ) { - return _bid64_isFinite( - x, - ); - } - - late final _bid64_isFinitePtr = - _lookup>( - 'bid64_isFinite'); - late final _bid64_isFinite = - _bid64_isFinitePtr.asFunction(); - - int bid64_isInf( - int x, - ) { - return _bid64_isInf( - x, - ); - } - - late final _bid64_isInfPtr = - _lookup>('bid64_isInf'); - late final _bid64_isInf = _bid64_isInfPtr.asFunction(); - - int bid64_isNaN( - int x, - ) { - return _bid64_isNaN( - x, - ); - } - - late final _bid64_isNaNPtr = - _lookup>('bid64_isNaN'); - late final _bid64_isNaN = _bid64_isNaNPtr.asFunction(); - - int bid64_isNormal( - int x, - ) { - return _bid64_isNormal( - x, - ); - } - - late final _bid64_isNormalPtr = - _lookup>( - 'bid64_isNormal'); - late final _bid64_isNormal = - _bid64_isNormalPtr.asFunction(); - - int bid64_isSignaling( - int x, - ) { - return _bid64_isSignaling( - x, - ); - } - - late final _bid64_isSignalingPtr = - _lookup>( - 'bid64_isSignaling'); - late final _bid64_isSignaling = - _bid64_isSignalingPtr.asFunction(); - - int bid64_isSigned( - int x, - ) { - return _bid64_isSigned( - x, - ); - } - - late final _bid64_isSignedPtr = - _lookup>( - 'bid64_isSigned'); - late final _bid64_isSigned = - _bid64_isSignedPtr.asFunction(); - - int bid64_isSubnormal( - int x, - ) { - return _bid64_isSubnormal( - x, - ); - } - - late final _bid64_isSubnormalPtr = - _lookup>( - 'bid64_isSubnormal'); - late final _bid64_isSubnormal = - _bid64_isSubnormalPtr.asFunction(); - - int bid64_isZero( - int x, - ) { - return _bid64_isZero( - x, - ); - } - - late final _bid64_isZeroPtr = - _lookup>('bid64_isZero'); - late final _bid64_isZero = _bid64_isZeroPtr.asFunction(); - - int bid64_ldexp( - int x, - int n, - ) { - return _bid64_ldexp( - x, - n, - ); - } - - late final _bid64_ldexpPtr = - _lookup>( - 'bid64_ldexp'); - late final _bid64_ldexp = - _bid64_ldexpPtr.asFunction(); - - int bid64_lgamma( - int x, - ) { - return _bid64_lgamma( - x, - ); - } - - late final _bid64_lgammaPtr = - _lookup>( - 'bid64_lgamma'); - late final _bid64_lgamma = _bid64_lgammaPtr.asFunction(); - - int bid64_llquantexp( - int x, - ) { - return _bid64_llquantexp( - x, - ); - } - - late final _bid64_llquantexpPtr = - _lookup>( - 'bid64_llquantexp'); - late final _bid64_llquantexp = - _bid64_llquantexpPtr.asFunction(); - - int bid64_llrint( - int x, - ) { - return _bid64_llrint( - x, - ); - } - - late final _bid64_llrintPtr = - _lookup>( - 'bid64_llrint'); - late final _bid64_llrint = _bid64_llrintPtr.asFunction(); - - int bid64_llround( - int x, - ) { - return _bid64_llround( - x, - ); - } - - late final _bid64_llroundPtr = - _lookup>( - 'bid64_llround'); - late final _bid64_llround = _bid64_llroundPtr.asFunction(); - - int bid64_log( - int x, - ) { - return _bid64_log( - x, - ); - } - - late final _bid64_logPtr = - _lookup>('bid64_log'); - late final _bid64_log = _bid64_logPtr.asFunction(); - - int bid64_log10( - int x, - ) { - return _bid64_log10( - x, - ); - } - - late final _bid64_log10Ptr = - _lookup>( - 'bid64_log10'); - late final _bid64_log10 = _bid64_log10Ptr.asFunction(); - - int bid64_log1p( - int x, - ) { - return _bid64_log1p( - x, - ); - } - - late final _bid64_log1pPtr = - _lookup>( - 'bid64_log1p'); - late final _bid64_log1p = _bid64_log1pPtr.asFunction(); - - int bid64_log2( - int x, - ) { - return _bid64_log2( - x, - ); - } - - late final _bid64_log2Ptr = - _lookup>( - 'bid64_log2'); - late final _bid64_log2 = _bid64_log2Ptr.asFunction(); - - int bid64_logb( - int x, - ) { - return _bid64_logb( - x, - ); - } - - late final _bid64_logbPtr = - _lookup>( - 'bid64_logb'); - late final _bid64_logb = _bid64_logbPtr.asFunction(); - - int bid64_lrint( - int x, - ) { - return _bid64_lrint( - x, - ); - } - - late final _bid64_lrintPtr = - _lookup>('bid64_lrint'); - late final _bid64_lrint = _bid64_lrintPtr.asFunction(); - - int bid64_lround( - int x, - ) { - return _bid64_lround( - x, - ); - } - - late final _bid64_lroundPtr = - _lookup>( - 'bid64_lround'); - late final _bid64_lround = _bid64_lroundPtr.asFunction(); - - int bid64_maxnum( - int x, - int y, - ) { - return _bid64_maxnum( - x, - y, - ); - } - - late final _bid64_maxnumPtr = - _lookup>( - 'bid64_maxnum'); - late final _bid64_maxnum = - _bid64_maxnumPtr.asFunction(); - - int bid64_maxnum_mag( - int x, - int y, - ) { - return _bid64_maxnum_mag( - x, - y, - ); - } - - late final _bid64_maxnum_magPtr = - _lookup>( - 'bid64_maxnum_mag'); - late final _bid64_maxnum_mag = - _bid64_maxnum_magPtr.asFunction(); - - int bid64_minnum( - int x, - int y, - ) { - return _bid64_minnum( - x, - y, - ); - } - - late final _bid64_minnumPtr = - _lookup>( - 'bid64_minnum'); - late final _bid64_minnum = - _bid64_minnumPtr.asFunction(); - - int bid64_minnum_mag( - int x, - int y, - ) { - return _bid64_minnum_mag( - x, - y, - ); - } - - late final _bid64_minnum_magPtr = - _lookup>( - 'bid64_minnum_mag'); - late final _bid64_minnum_mag = - _bid64_minnum_magPtr.asFunction(); - - int bid64_modf( - int x, - ffi.Pointer y, - ) { - return _bid64_modf( - x, - y, - ); - } - - late final _bid64_modfPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT64, ffi.Pointer)>>('bid64_modf'); - late final _bid64_modf = - _bid64_modfPtr.asFunction)>(); - - int bid64_mul( - int x, - int y, - ) { - return _bid64_mul( - x, - y, - ); - } - - late final _bid64_mulPtr = - _lookup>( - 'bid64_mul'); - late final _bid64_mul = _bid64_mulPtr.asFunction(); - - int bid64_nan( - ffi.Pointer tagp, - ) { - return _bid64_nan( - tagp, - ); - } - - late final _bid64_nanPtr = - _lookup)>>( - 'bid64_nan'); - late final _bid64_nan = - _bid64_nanPtr.asFunction)>(); - - int bid64_nearbyint( - int x, - ) { - return _bid64_nearbyint( - x, - ); - } - - late final _bid64_nearbyintPtr = - _lookup>( - 'bid64_nearbyint'); - late final _bid64_nearbyint = - _bid64_nearbyintPtr.asFunction(); - - int bid64_negate( - int x, - ) { - return _bid64_negate( - x, - ); - } - - late final _bid64_negatePtr = - _lookup>( - 'bid64_negate'); - late final _bid64_negate = _bid64_negatePtr.asFunction(); - - int bid64_nextafter( - int x, - int y, - ) { - return _bid64_nextafter( - x, - y, - ); - } - - late final _bid64_nextafterPtr = - _lookup>( - 'bid64_nextafter'); - late final _bid64_nextafter = - _bid64_nextafterPtr.asFunction(); - - int bid64_nextdown( - int x, - ) { - return _bid64_nextdown( - x, - ); - } - - late final _bid64_nextdownPtr = - _lookup>( - 'bid64_nextdown'); - late final _bid64_nextdown = - _bid64_nextdownPtr.asFunction(); - - int bid64_nexttoward( - int x, - BID_UINT128 y, - ) { - return _bid64_nexttoward( - x, - y, - ); - } - - late final _bid64_nexttowardPtr = - _lookup>( - 'bid64_nexttoward'); - late final _bid64_nexttoward = - _bid64_nexttowardPtr.asFunction(); - - int bid64_nextup( - int x, - ) { - return _bid64_nextup( - x, - ); - } - - late final _bid64_nextupPtr = - _lookup>( - 'bid64_nextup'); - late final _bid64_nextup = _bid64_nextupPtr.asFunction(); - - int bid64_pow( - int x, - int y, - ) { - return _bid64_pow( - x, - y, - ); - } - - late final _bid64_powPtr = - _lookup>( - 'bid64_pow'); - late final _bid64_pow = _bid64_powPtr.asFunction(); - - int bid64_quantexp( - int x, - ) { - return _bid64_quantexp( - x, - ); - } - - late final _bid64_quantexpPtr = - _lookup>( - 'bid64_quantexp'); - late final _bid64_quantexp = - _bid64_quantexpPtr.asFunction(); - - int bid64_quantize( - int x, - int y, - ) { - return _bid64_quantize( - x, - y, - ); - } - - late final _bid64_quantizePtr = - _lookup>( - 'bid64_quantize'); - late final _bid64_quantize = - _bid64_quantizePtr.asFunction(); - - int bid64_quantum( - int x, - ) { - return _bid64_quantum( - x, - ); - } - - late final _bid64_quantumPtr = - _lookup>( - 'bid64_quantum'); - late final _bid64_quantum = _bid64_quantumPtr.asFunction(); - - int bid64_quiet_equal( - int x, - int y, - ) { - return _bid64_quiet_equal( - x, - y, - ); - } - - late final _bid64_quiet_equalPtr = - _lookup>( - 'bid64_quiet_equal'); - late final _bid64_quiet_equal = - _bid64_quiet_equalPtr.asFunction(); - - int bid64_quiet_greater( - int x, - int y, - ) { - return _bid64_quiet_greater( - x, - y, - ); - } - - late final _bid64_quiet_greaterPtr = - _lookup>( - 'bid64_quiet_greater'); - late final _bid64_quiet_greater = - _bid64_quiet_greaterPtr.asFunction(); - - int bid64_quiet_greater_equal( - int x, - int y, - ) { - return _bid64_quiet_greater_equal( - x, - y, - ); - } - - late final _bid64_quiet_greater_equalPtr = - _lookup>( - 'bid64_quiet_greater_equal'); - late final _bid64_quiet_greater_equal = - _bid64_quiet_greater_equalPtr.asFunction(); - - int bid64_quiet_greater_unordered( - int x, - int y, - ) { - return _bid64_quiet_greater_unordered( - x, - y, - ); - } - - late final _bid64_quiet_greater_unorderedPtr = - _lookup>( - 'bid64_quiet_greater_unordered'); - late final _bid64_quiet_greater_unordered = - _bid64_quiet_greater_unorderedPtr.asFunction(); - - int bid64_quiet_less( - int x, - int y, - ) { - return _bid64_quiet_less( - x, - y, - ); - } - - late final _bid64_quiet_lessPtr = - _lookup>( - 'bid64_quiet_less'); - late final _bid64_quiet_less = - _bid64_quiet_lessPtr.asFunction(); - - int bid64_quiet_less_equal( - int x, - int y, - ) { - return _bid64_quiet_less_equal( - x, - y, - ); - } - - late final _bid64_quiet_less_equalPtr = - _lookup>( - 'bid64_quiet_less_equal'); - late final _bid64_quiet_less_equal = - _bid64_quiet_less_equalPtr.asFunction(); - - int bid64_quiet_less_unordered( - int x, - int y, - ) { - return _bid64_quiet_less_unordered( - x, - y, - ); - } - - late final _bid64_quiet_less_unorderedPtr = - _lookup>( - 'bid64_quiet_less_unordered'); - late final _bid64_quiet_less_unordered = - _bid64_quiet_less_unorderedPtr.asFunction(); - - int bid64_quiet_not_equal( - int x, - int y, - ) { - return _bid64_quiet_not_equal( - x, - y, - ); - } - - late final _bid64_quiet_not_equalPtr = - _lookup>( - 'bid64_quiet_not_equal'); - late final _bid64_quiet_not_equal = - _bid64_quiet_not_equalPtr.asFunction(); - - int bid64_quiet_not_greater( - int x, - int y, - ) { - return _bid64_quiet_not_greater( - x, - y, - ); - } - - late final _bid64_quiet_not_greaterPtr = - _lookup>( - 'bid64_quiet_not_greater'); - late final _bid64_quiet_not_greater = - _bid64_quiet_not_greaterPtr.asFunction(); - - int bid64_quiet_not_less( - int x, - int y, - ) { - return _bid64_quiet_not_less( - x, - y, - ); - } - - late final _bid64_quiet_not_lessPtr = - _lookup>( - 'bid64_quiet_not_less'); - late final _bid64_quiet_not_less = - _bid64_quiet_not_lessPtr.asFunction(); - - int bid64_quiet_ordered( - int x, - int y, - ) { - return _bid64_quiet_ordered( - x, - y, - ); - } - - late final _bid64_quiet_orderedPtr = - _lookup>( - 'bid64_quiet_ordered'); - late final _bid64_quiet_ordered = - _bid64_quiet_orderedPtr.asFunction(); - - int bid64_quiet_unordered( - int x, - int y, - ) { - return _bid64_quiet_unordered( - x, - y, - ); - } - - late final _bid64_quiet_unorderedPtr = - _lookup>( - 'bid64_quiet_unordered'); - late final _bid64_quiet_unordered = - _bid64_quiet_unorderedPtr.asFunction(); - - int bid64_radix( - int x, - ) { - return _bid64_radix( - x, - ); - } - - late final _bid64_radixPtr = - _lookup>('bid64_radix'); - late final _bid64_radix = _bid64_radixPtr.asFunction(); - - int bid64_rem( - int x, - int y, - ) { - return _bid64_rem( - x, - y, - ); - } - - late final _bid64_remPtr = - _lookup>( - 'bid64_rem'); - late final _bid64_rem = _bid64_remPtr.asFunction(); - - int bid64_round_integral_exact( - int x, - ) { - return _bid64_round_integral_exact( - x, - ); - } - - late final _bid64_round_integral_exactPtr = - _lookup>( - 'bid64_round_integral_exact'); - late final _bid64_round_integral_exact = - _bid64_round_integral_exactPtr.asFunction(); - - int bid64_round_integral_nearest_away( - int x, - ) { - return _bid64_round_integral_nearest_away( - x, - ); - } - - late final _bid64_round_integral_nearest_awayPtr = - _lookup>( - 'bid64_round_integral_nearest_away'); - late final _bid64_round_integral_nearest_away = - _bid64_round_integral_nearest_awayPtr.asFunction(); - - int bid64_round_integral_nearest_even( - int x, - ) { - return _bid64_round_integral_nearest_even( - x, - ); - } - - late final _bid64_round_integral_nearest_evenPtr = - _lookup>( - 'bid64_round_integral_nearest_even'); - late final _bid64_round_integral_nearest_even = - _bid64_round_integral_nearest_evenPtr.asFunction(); - - int bid64_round_integral_negative( - int x, - ) { - return _bid64_round_integral_negative( - x, - ); - } - - late final _bid64_round_integral_negativePtr = - _lookup>( - 'bid64_round_integral_negative'); - late final _bid64_round_integral_negative = - _bid64_round_integral_negativePtr.asFunction(); - - int bid64_round_integral_positive( - int x, - ) { - return _bid64_round_integral_positive( - x, - ); - } - - late final _bid64_round_integral_positivePtr = - _lookup>( - 'bid64_round_integral_positive'); - late final _bid64_round_integral_positive = - _bid64_round_integral_positivePtr.asFunction(); - - int bid64_round_integral_zero( - int x, - ) { - return _bid64_round_integral_zero( - x, - ); - } - - late final _bid64_round_integral_zeroPtr = - _lookup>( - 'bid64_round_integral_zero'); - late final _bid64_round_integral_zero = - _bid64_round_integral_zeroPtr.asFunction(); - - int bid64_sameQuantum( - int x, - int y, - ) { - return _bid64_sameQuantum( - x, - y, - ); - } - - late final _bid64_sameQuantumPtr = - _lookup>( - 'bid64_sameQuantum'); - late final _bid64_sameQuantum = - _bid64_sameQuantumPtr.asFunction(); - - int bid64_scalbln( - int x, - int n, - ) { - return _bid64_scalbln( - x, - n, - ); - } - - late final _bid64_scalblnPtr = - _lookup>( - 'bid64_scalbln'); - late final _bid64_scalbln = - _bid64_scalblnPtr.asFunction(); - - int bid64_scalbn( - int x, - int n, - ) { - return _bid64_scalbn( - x, - n, - ); - } - - late final _bid64_scalbnPtr = - _lookup>( - 'bid64_scalbn'); - late final _bid64_scalbn = - _bid64_scalbnPtr.asFunction(); - - int bid64_signaling_greater( - int x, - int y, - ) { - return _bid64_signaling_greater( - x, - y, - ); - } - - late final _bid64_signaling_greaterPtr = - _lookup>( - 'bid64_signaling_greater'); - late final _bid64_signaling_greater = - _bid64_signaling_greaterPtr.asFunction(); - - int bid64_signaling_greater_equal( - int x, - int y, - ) { - return _bid64_signaling_greater_equal( - x, - y, - ); - } - - late final _bid64_signaling_greater_equalPtr = - _lookup>( - 'bid64_signaling_greater_equal'); - late final _bid64_signaling_greater_equal = - _bid64_signaling_greater_equalPtr.asFunction(); - - int bid64_signaling_greater_unordered( - int x, - int y, - ) { - return _bid64_signaling_greater_unordered( - x, - y, - ); - } - - late final _bid64_signaling_greater_unorderedPtr = - _lookup>( - 'bid64_signaling_greater_unordered'); - late final _bid64_signaling_greater_unordered = - _bid64_signaling_greater_unorderedPtr - .asFunction(); - - int bid64_signaling_less( - int x, - int y, - ) { - return _bid64_signaling_less( - x, - y, - ); - } - - late final _bid64_signaling_lessPtr = - _lookup>( - 'bid64_signaling_less'); - late final _bid64_signaling_less = - _bid64_signaling_lessPtr.asFunction(); - - int bid64_signaling_less_equal( - int x, - int y, - ) { - return _bid64_signaling_less_equal( - x, - y, - ); - } - - late final _bid64_signaling_less_equalPtr = - _lookup>( - 'bid64_signaling_less_equal'); - late final _bid64_signaling_less_equal = - _bid64_signaling_less_equalPtr.asFunction(); - - int bid64_signaling_less_unordered( - int x, - int y, - ) { - return _bid64_signaling_less_unordered( - x, - y, - ); - } - - late final _bid64_signaling_less_unorderedPtr = - _lookup>( - 'bid64_signaling_less_unordered'); - late final _bid64_signaling_less_unordered = - _bid64_signaling_less_unorderedPtr.asFunction(); - - int bid64_signaling_not_greater( - int x, - int y, - ) { - return _bid64_signaling_not_greater( - x, - y, - ); - } - - late final _bid64_signaling_not_greaterPtr = - _lookup>( - 'bid64_signaling_not_greater'); - late final _bid64_signaling_not_greater = - _bid64_signaling_not_greaterPtr.asFunction(); - - int bid64_signaling_not_less( - int x, - int y, - ) { - return _bid64_signaling_not_less( - x, - y, - ); - } - - late final _bid64_signaling_not_lessPtr = - _lookup>( - 'bid64_signaling_not_less'); - late final _bid64_signaling_not_less = - _bid64_signaling_not_lessPtr.asFunction(); - - int bid64_sin( - int x, - ) { - return _bid64_sin( - x, - ); - } - - late final _bid64_sinPtr = - _lookup>('bid64_sin'); - late final _bid64_sin = _bid64_sinPtr.asFunction(); - - int bid64_sinh( - int x, - ) { - return _bid64_sinh( - x, - ); - } - - late final _bid64_sinhPtr = - _lookup>( - 'bid64_sinh'); - late final _bid64_sinh = _bid64_sinhPtr.asFunction(); - - int bid64_sqrt( - int x, - ) { - return _bid64_sqrt( - x, - ); - } - - late final _bid64_sqrtPtr = - _lookup>( - 'bid64_sqrt'); - late final _bid64_sqrt = _bid64_sqrtPtr.asFunction(); - - int bid64_sub( - int x, - int y, - ) { - return _bid64_sub( - x, - y, - ); - } - - late final _bid64_subPtr = - _lookup>( - 'bid64_sub'); - late final _bid64_sub = _bid64_subPtr.asFunction(); - - int bid64_tan( - int x, - ) { - return _bid64_tan( - x, - ); - } - - late final _bid64_tanPtr = - _lookup>('bid64_tan'); - late final _bid64_tan = _bid64_tanPtr.asFunction(); - - int bid64_tanh( - int x, - ) { - return _bid64_tanh( - x, - ); - } - - late final _bid64_tanhPtr = - _lookup>( - 'bid64_tanh'); - late final _bid64_tanh = _bid64_tanhPtr.asFunction(); - - int bid64_tgamma( - int x, - ) { - return _bid64_tgamma( - x, - ); - } - - late final _bid64_tgammaPtr = - _lookup>( - 'bid64_tgamma'); - late final _bid64_tgamma = _bid64_tgammaPtr.asFunction(); - - BID_UINT128 bid64_to_bid128( - int x, - ) { - return _bid64_to_bid128( - x, - ); - } - - late final _bid64_to_bid128Ptr = - _lookup>( - 'bid64_to_bid128'); - late final _bid64_to_bid128 = - _bid64_to_bid128Ptr.asFunction(); - - int bid64_to_bid32( - int x, - ) { - return _bid64_to_bid32( - x, - ); - } - - late final _bid64_to_bid32Ptr = - _lookup>( - 'bid64_to_bid32'); - late final _bid64_to_bid32 = - _bid64_to_bid32Ptr.asFunction(); - - BID_UINT128 bid64_to_binary128( - int x, - ) { - return _bid64_to_binary128( - x, - ); - } - - late final _bid64_to_binary128Ptr = - _lookup>( - 'bid64_to_binary128'); - late final _bid64_to_binary128 = - _bid64_to_binary128Ptr.asFunction(); - - double bid64_to_binary32( - int x, - ) { - return _bid64_to_binary32( - x, - ); - } - - late final _bid64_to_binary32Ptr = - _lookup>( - 'bid64_to_binary32'); - late final _bid64_to_binary32 = - _bid64_to_binary32Ptr.asFunction(); - - double bid64_to_binary64( - int x, - ) { - return _bid64_to_binary64( - x, - ); - } - - late final _bid64_to_binary64Ptr = - _lookup>( - 'bid64_to_binary64'); - late final _bid64_to_binary64 = - _bid64_to_binary64Ptr.asFunction(); - - int bid64_to_int16_ceil( - int x, - ) { - return _bid64_to_int16_ceil( - x, - ); - } - - late final _bid64_to_int16_ceilPtr = - _lookup>( - 'bid64_to_int16_ceil'); - late final _bid64_to_int16_ceil = - _bid64_to_int16_ceilPtr.asFunction(); - - int bid64_to_int16_floor( - int x, - ) { - return _bid64_to_int16_floor( - x, - ); - } - - late final _bid64_to_int16_floorPtr = - _lookup>( - 'bid64_to_int16_floor'); - late final _bid64_to_int16_floor = - _bid64_to_int16_floorPtr.asFunction(); - - int bid64_to_int16_int( - int x, - ) { - return _bid64_to_int16_int( - x, - ); - } - - late final _bid64_to_int16_intPtr = - _lookup>( - 'bid64_to_int16_int'); - late final _bid64_to_int16_int = - _bid64_to_int16_intPtr.asFunction(); - - int bid64_to_int16_rnint( - int x, - ) { - return _bid64_to_int16_rnint( - x, - ); - } - - late final _bid64_to_int16_rnintPtr = - _lookup>( - 'bid64_to_int16_rnint'); - late final _bid64_to_int16_rnint = - _bid64_to_int16_rnintPtr.asFunction(); - - int bid64_to_int16_rninta( - int x, - ) { - return _bid64_to_int16_rninta( - x, - ); - } - - late final _bid64_to_int16_rnintaPtr = - _lookup>( - 'bid64_to_int16_rninta'); - late final _bid64_to_int16_rninta = - _bid64_to_int16_rnintaPtr.asFunction(); - - int bid64_to_int16_xceil( - int x, - ) { - return _bid64_to_int16_xceil( - x, - ); - } - - late final _bid64_to_int16_xceilPtr = - _lookup>( - 'bid64_to_int16_xceil'); - late final _bid64_to_int16_xceil = - _bid64_to_int16_xceilPtr.asFunction(); - - int bid64_to_int16_xfloor( - int x, - ) { - return _bid64_to_int16_xfloor( - x, - ); - } - - late final _bid64_to_int16_xfloorPtr = - _lookup>( - 'bid64_to_int16_xfloor'); - late final _bid64_to_int16_xfloor = - _bid64_to_int16_xfloorPtr.asFunction(); - - int bid64_to_int16_xint( - int x, - ) { - return _bid64_to_int16_xint( - x, - ); - } - - late final _bid64_to_int16_xintPtr = - _lookup>( - 'bid64_to_int16_xint'); - late final _bid64_to_int16_xint = - _bid64_to_int16_xintPtr.asFunction(); - - int bid64_to_int16_xrnint( - int x, - ) { - return _bid64_to_int16_xrnint( - x, - ); - } - - late final _bid64_to_int16_xrnintPtr = - _lookup>( - 'bid64_to_int16_xrnint'); - late final _bid64_to_int16_xrnint = - _bid64_to_int16_xrnintPtr.asFunction(); - - int bid64_to_int16_xrninta( - int x, - ) { - return _bid64_to_int16_xrninta( - x, - ); - } - - late final _bid64_to_int16_xrnintaPtr = - _lookup>( - 'bid64_to_int16_xrninta'); - late final _bid64_to_int16_xrninta = - _bid64_to_int16_xrnintaPtr.asFunction(); - - int bid64_to_int32_ceil( - int x, - ) { - return _bid64_to_int32_ceil( - x, - ); - } - - late final _bid64_to_int32_ceilPtr = - _lookup>( - 'bid64_to_int32_ceil'); - late final _bid64_to_int32_ceil = - _bid64_to_int32_ceilPtr.asFunction(); - - int bid64_to_int32_floor( - int x, - ) { - return _bid64_to_int32_floor( - x, - ); - } - - late final _bid64_to_int32_floorPtr = - _lookup>( - 'bid64_to_int32_floor'); - late final _bid64_to_int32_floor = - _bid64_to_int32_floorPtr.asFunction(); - - int bid64_to_int32_int( - int x, - ) { - return _bid64_to_int32_int( - x, - ); - } - - late final _bid64_to_int32_intPtr = - _lookup>( - 'bid64_to_int32_int'); - late final _bid64_to_int32_int = - _bid64_to_int32_intPtr.asFunction(); - - int bid64_to_int32_rnint( - int x, - ) { - return _bid64_to_int32_rnint( - x, - ); - } - - late final _bid64_to_int32_rnintPtr = - _lookup>( - 'bid64_to_int32_rnint'); - late final _bid64_to_int32_rnint = - _bid64_to_int32_rnintPtr.asFunction(); - - int bid64_to_int32_rninta( - int x, - ) { - return _bid64_to_int32_rninta( - x, - ); - } - - late final _bid64_to_int32_rnintaPtr = - _lookup>( - 'bid64_to_int32_rninta'); - late final _bid64_to_int32_rninta = - _bid64_to_int32_rnintaPtr.asFunction(); - - int bid64_to_int32_xceil( - int x, - ) { - return _bid64_to_int32_xceil( - x, - ); - } - - late final _bid64_to_int32_xceilPtr = - _lookup>( - 'bid64_to_int32_xceil'); - late final _bid64_to_int32_xceil = - _bid64_to_int32_xceilPtr.asFunction(); - - int bid64_to_int32_xfloor( - int x, - ) { - return _bid64_to_int32_xfloor( - x, - ); - } - - late final _bid64_to_int32_xfloorPtr = - _lookup>( - 'bid64_to_int32_xfloor'); - late final _bid64_to_int32_xfloor = - _bid64_to_int32_xfloorPtr.asFunction(); - - int bid64_to_int32_xint( - int x, - ) { - return _bid64_to_int32_xint( - x, - ); - } - - late final _bid64_to_int32_xintPtr = - _lookup>( - 'bid64_to_int32_xint'); - late final _bid64_to_int32_xint = - _bid64_to_int32_xintPtr.asFunction(); - - int bid64_to_int32_xrnint( - int x, - ) { - return _bid64_to_int32_xrnint( - x, - ); - } - - late final _bid64_to_int32_xrnintPtr = - _lookup>( - 'bid64_to_int32_xrnint'); - late final _bid64_to_int32_xrnint = - _bid64_to_int32_xrnintPtr.asFunction(); - - int bid64_to_int32_xrninta( - int x, - ) { - return _bid64_to_int32_xrninta( - x, - ); - } - - late final _bid64_to_int32_xrnintaPtr = - _lookup>( - 'bid64_to_int32_xrninta'); - late final _bid64_to_int32_xrninta = - _bid64_to_int32_xrnintaPtr.asFunction(); - - int bid64_to_int64_ceil( - int x, - ) { - return _bid64_to_int64_ceil( - x, - ); - } - - late final _bid64_to_int64_ceilPtr = - _lookup>( - 'bid64_to_int64_ceil'); - late final _bid64_to_int64_ceil = - _bid64_to_int64_ceilPtr.asFunction(); - - int bid64_to_int64_floor( - int x, - ) { - return _bid64_to_int64_floor( - x, - ); - } - - late final _bid64_to_int64_floorPtr = - _lookup>( - 'bid64_to_int64_floor'); - late final _bid64_to_int64_floor = - _bid64_to_int64_floorPtr.asFunction(); - - int bid64_to_int64_int( - int x, - ) { - return _bid64_to_int64_int( - x, - ); - } - - late final _bid64_to_int64_intPtr = - _lookup>( - 'bid64_to_int64_int'); - late final _bid64_to_int64_int = - _bid64_to_int64_intPtr.asFunction(); - - int bid64_to_int64_rnint( - int x, - ) { - return _bid64_to_int64_rnint( - x, - ); - } - - late final _bid64_to_int64_rnintPtr = - _lookup>( - 'bid64_to_int64_rnint'); - late final _bid64_to_int64_rnint = - _bid64_to_int64_rnintPtr.asFunction(); - - int bid64_to_int64_rninta( - int x, - ) { - return _bid64_to_int64_rninta( - x, - ); - } - - late final _bid64_to_int64_rnintaPtr = - _lookup>( - 'bid64_to_int64_rninta'); - late final _bid64_to_int64_rninta = - _bid64_to_int64_rnintaPtr.asFunction(); - - int bid64_to_int64_xceil( - int x, - ) { - return _bid64_to_int64_xceil( - x, - ); - } - - late final _bid64_to_int64_xceilPtr = - _lookup>( - 'bid64_to_int64_xceil'); - late final _bid64_to_int64_xceil = - _bid64_to_int64_xceilPtr.asFunction(); - - int bid64_to_int64_xfloor( - int x, - ) { - return _bid64_to_int64_xfloor( - x, - ); - } - - late final _bid64_to_int64_xfloorPtr = - _lookup>( - 'bid64_to_int64_xfloor'); - late final _bid64_to_int64_xfloor = - _bid64_to_int64_xfloorPtr.asFunction(); - - int bid64_to_int64_xint( - int x, - ) { - return _bid64_to_int64_xint( - x, - ); - } - - late final _bid64_to_int64_xintPtr = - _lookup>( - 'bid64_to_int64_xint'); - late final _bid64_to_int64_xint = - _bid64_to_int64_xintPtr.asFunction(); - - int bid64_to_int64_xrnint( - int x, - ) { - return _bid64_to_int64_xrnint( - x, - ); - } - - late final _bid64_to_int64_xrnintPtr = - _lookup>( - 'bid64_to_int64_xrnint'); - late final _bid64_to_int64_xrnint = - _bid64_to_int64_xrnintPtr.asFunction(); - - int bid64_to_int64_xrninta( - int x, - ) { - return _bid64_to_int64_xrninta( - x, - ); - } - - late final _bid64_to_int64_xrnintaPtr = - _lookup>( - 'bid64_to_int64_xrninta'); - late final _bid64_to_int64_xrninta = - _bid64_to_int64_xrnintaPtr.asFunction(); - - int bid64_to_int8_ceil( - int x, - ) { - return _bid64_to_int8_ceil( - x, - ); - } - - late final _bid64_to_int8_ceilPtr = - _lookup>( - 'bid64_to_int8_ceil'); - late final _bid64_to_int8_ceil = - _bid64_to_int8_ceilPtr.asFunction(); - - int bid64_to_int8_floor( - int x, - ) { - return _bid64_to_int8_floor( - x, - ); - } - - late final _bid64_to_int8_floorPtr = - _lookup>( - 'bid64_to_int8_floor'); - late final _bid64_to_int8_floor = - _bid64_to_int8_floorPtr.asFunction(); - - int bid64_to_int8_int( - int x, - ) { - return _bid64_to_int8_int( - x, - ); - } - - late final _bid64_to_int8_intPtr = - _lookup>( - 'bid64_to_int8_int'); - late final _bid64_to_int8_int = - _bid64_to_int8_intPtr.asFunction(); - - int bid64_to_int8_rnint( - int x, - ) { - return _bid64_to_int8_rnint( - x, - ); - } - - late final _bid64_to_int8_rnintPtr = - _lookup>( - 'bid64_to_int8_rnint'); - late final _bid64_to_int8_rnint = - _bid64_to_int8_rnintPtr.asFunction(); - - int bid64_to_int8_rninta( - int x, - ) { - return _bid64_to_int8_rninta( - x, - ); - } - - late final _bid64_to_int8_rnintaPtr = - _lookup>( - 'bid64_to_int8_rninta'); - late final _bid64_to_int8_rninta = - _bid64_to_int8_rnintaPtr.asFunction(); - - int bid64_to_int8_xceil( - int x, - ) { - return _bid64_to_int8_xceil( - x, - ); - } - - late final _bid64_to_int8_xceilPtr = - _lookup>( - 'bid64_to_int8_xceil'); - late final _bid64_to_int8_xceil = - _bid64_to_int8_xceilPtr.asFunction(); - - int bid64_to_int8_xfloor( - int x, - ) { - return _bid64_to_int8_xfloor( - x, - ); - } - - late final _bid64_to_int8_xfloorPtr = - _lookup>( - 'bid64_to_int8_xfloor'); - late final _bid64_to_int8_xfloor = - _bid64_to_int8_xfloorPtr.asFunction(); - - int bid64_to_int8_xint( - int x, - ) { - return _bid64_to_int8_xint( - x, - ); - } - - late final _bid64_to_int8_xintPtr = - _lookup>( - 'bid64_to_int8_xint'); - late final _bid64_to_int8_xint = - _bid64_to_int8_xintPtr.asFunction(); - - int bid64_to_int8_xrnint( - int x, - ) { - return _bid64_to_int8_xrnint( - x, - ); - } - - late final _bid64_to_int8_xrnintPtr = - _lookup>( - 'bid64_to_int8_xrnint'); - late final _bid64_to_int8_xrnint = - _bid64_to_int8_xrnintPtr.asFunction(); - - int bid64_to_int8_xrninta( - int x, - ) { - return _bid64_to_int8_xrninta( - x, - ); - } - - late final _bid64_to_int8_xrnintaPtr = - _lookup>( - 'bid64_to_int8_xrninta'); - late final _bid64_to_int8_xrninta = - _bid64_to_int8_xrnintaPtr.asFunction(); - - void bid64_to_string( - ffi.Pointer ps, - int x, - ) { - return _bid64_to_string( - ps, - x, - ); - } - - late final _bid64_to_stringPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, BID_UINT64)>>('bid64_to_string'); - late final _bid64_to_string = _bid64_to_stringPtr - .asFunction, int)>(); - - int bid64_to_uint16_ceil( - int x, - ) { - return _bid64_to_uint16_ceil( - x, - ); - } - - late final _bid64_to_uint16_ceilPtr = - _lookup>( - 'bid64_to_uint16_ceil'); - late final _bid64_to_uint16_ceil = - _bid64_to_uint16_ceilPtr.asFunction(); - - int bid64_to_uint16_floor( - int x, - ) { - return _bid64_to_uint16_floor( - x, - ); - } - - late final _bid64_to_uint16_floorPtr = - _lookup>( - 'bid64_to_uint16_floor'); - late final _bid64_to_uint16_floor = - _bid64_to_uint16_floorPtr.asFunction(); - - int bid64_to_uint16_int( - int x, - ) { - return _bid64_to_uint16_int( - x, - ); - } - - late final _bid64_to_uint16_intPtr = - _lookup>( - 'bid64_to_uint16_int'); - late final _bid64_to_uint16_int = - _bid64_to_uint16_intPtr.asFunction(); - - int bid64_to_uint16_rnint( - int x, - ) { - return _bid64_to_uint16_rnint( - x, - ); - } - - late final _bid64_to_uint16_rnintPtr = - _lookup>( - 'bid64_to_uint16_rnint'); - late final _bid64_to_uint16_rnint = - _bid64_to_uint16_rnintPtr.asFunction(); - - int bid64_to_uint16_rninta( - int x, - ) { - return _bid64_to_uint16_rninta( - x, - ); - } - - late final _bid64_to_uint16_rnintaPtr = - _lookup>( - 'bid64_to_uint16_rninta'); - late final _bid64_to_uint16_rninta = - _bid64_to_uint16_rnintaPtr.asFunction(); - - int bid64_to_uint16_xceil( - int x, - ) { - return _bid64_to_uint16_xceil( - x, - ); - } - - late final _bid64_to_uint16_xceilPtr = - _lookup>( - 'bid64_to_uint16_xceil'); - late final _bid64_to_uint16_xceil = - _bid64_to_uint16_xceilPtr.asFunction(); - - int bid64_to_uint16_xfloor( - int x, - ) { - return _bid64_to_uint16_xfloor( - x, - ); - } - - late final _bid64_to_uint16_xfloorPtr = - _lookup>( - 'bid64_to_uint16_xfloor'); - late final _bid64_to_uint16_xfloor = - _bid64_to_uint16_xfloorPtr.asFunction(); - - int bid64_to_uint16_xint( - int x, - ) { - return _bid64_to_uint16_xint( - x, - ); - } - - late final _bid64_to_uint16_xintPtr = - _lookup>( - 'bid64_to_uint16_xint'); - late final _bid64_to_uint16_xint = - _bid64_to_uint16_xintPtr.asFunction(); - - int bid64_to_uint16_xrnint( - int x, - ) { - return _bid64_to_uint16_xrnint( - x, - ); - } - - late final _bid64_to_uint16_xrnintPtr = - _lookup>( - 'bid64_to_uint16_xrnint'); - late final _bid64_to_uint16_xrnint = - _bid64_to_uint16_xrnintPtr.asFunction(); - - int bid64_to_uint16_xrninta( - int x, - ) { - return _bid64_to_uint16_xrninta( - x, - ); - } - - late final _bid64_to_uint16_xrnintaPtr = - _lookup>( - 'bid64_to_uint16_xrninta'); - late final _bid64_to_uint16_xrninta = - _bid64_to_uint16_xrnintaPtr.asFunction(); - - int bid64_to_uint32_ceil( - int x, - ) { - return _bid64_to_uint32_ceil( - x, - ); - } - - late final _bid64_to_uint32_ceilPtr = - _lookup>( - 'bid64_to_uint32_ceil'); - late final _bid64_to_uint32_ceil = - _bid64_to_uint32_ceilPtr.asFunction(); - - int bid64_to_uint32_floor( - int x, - ) { - return _bid64_to_uint32_floor( - x, - ); - } - - late final _bid64_to_uint32_floorPtr = - _lookup>( - 'bid64_to_uint32_floor'); - late final _bid64_to_uint32_floor = - _bid64_to_uint32_floorPtr.asFunction(); - - int bid64_to_uint32_int( - int x, - ) { - return _bid64_to_uint32_int( - x, - ); - } - - late final _bid64_to_uint32_intPtr = - _lookup>( - 'bid64_to_uint32_int'); - late final _bid64_to_uint32_int = - _bid64_to_uint32_intPtr.asFunction(); - - int bid64_to_uint32_rnint( - int x, - ) { - return _bid64_to_uint32_rnint( - x, - ); - } - - late final _bid64_to_uint32_rnintPtr = - _lookup>( - 'bid64_to_uint32_rnint'); - late final _bid64_to_uint32_rnint = - _bid64_to_uint32_rnintPtr.asFunction(); - - int bid64_to_uint32_rninta( - int x, - ) { - return _bid64_to_uint32_rninta( - x, - ); - } - - late final _bid64_to_uint32_rnintaPtr = - _lookup>( - 'bid64_to_uint32_rninta'); - late final _bid64_to_uint32_rninta = - _bid64_to_uint32_rnintaPtr.asFunction(); - - int bid64_to_uint32_xceil( - int x, - ) { - return _bid64_to_uint32_xceil( - x, - ); - } - - late final _bid64_to_uint32_xceilPtr = - _lookup>( - 'bid64_to_uint32_xceil'); - late final _bid64_to_uint32_xceil = - _bid64_to_uint32_xceilPtr.asFunction(); - - int bid64_to_uint32_xfloor( - int x, - ) { - return _bid64_to_uint32_xfloor( - x, - ); - } - - late final _bid64_to_uint32_xfloorPtr = - _lookup>( - 'bid64_to_uint32_xfloor'); - late final _bid64_to_uint32_xfloor = - _bid64_to_uint32_xfloorPtr.asFunction(); - - int bid64_to_uint32_xint( - int x, - ) { - return _bid64_to_uint32_xint( - x, - ); - } - - late final _bid64_to_uint32_xintPtr = - _lookup>( - 'bid64_to_uint32_xint'); - late final _bid64_to_uint32_xint = - _bid64_to_uint32_xintPtr.asFunction(); - - int bid64_to_uint32_xrnint( - int x, - ) { - return _bid64_to_uint32_xrnint( - x, - ); - } - - late final _bid64_to_uint32_xrnintPtr = - _lookup>( - 'bid64_to_uint32_xrnint'); - late final _bid64_to_uint32_xrnint = - _bid64_to_uint32_xrnintPtr.asFunction(); - - int bid64_to_uint32_xrninta( - int x, - ) { - return _bid64_to_uint32_xrninta( - x, - ); - } - - late final _bid64_to_uint32_xrnintaPtr = - _lookup>( - 'bid64_to_uint32_xrninta'); - late final _bid64_to_uint32_xrninta = - _bid64_to_uint32_xrnintaPtr.asFunction(); - - int bid64_to_uint64_ceil( - int x, - ) { - return _bid64_to_uint64_ceil( - x, - ); - } - - late final _bid64_to_uint64_ceilPtr = - _lookup>( - 'bid64_to_uint64_ceil'); - late final _bid64_to_uint64_ceil = - _bid64_to_uint64_ceilPtr.asFunction(); - - int bid64_to_uint64_floor( - int x, - ) { - return _bid64_to_uint64_floor( - x, - ); - } - - late final _bid64_to_uint64_floorPtr = - _lookup>( - 'bid64_to_uint64_floor'); - late final _bid64_to_uint64_floor = - _bid64_to_uint64_floorPtr.asFunction(); - - int bid64_to_uint64_int( - int x, - ) { - return _bid64_to_uint64_int( - x, - ); - } - - late final _bid64_to_uint64_intPtr = - _lookup>( - 'bid64_to_uint64_int'); - late final _bid64_to_uint64_int = - _bid64_to_uint64_intPtr.asFunction(); - - int bid64_to_uint64_rnint( - int x, - ) { - return _bid64_to_uint64_rnint( - x, - ); - } - - late final _bid64_to_uint64_rnintPtr = - _lookup>( - 'bid64_to_uint64_rnint'); - late final _bid64_to_uint64_rnint = - _bid64_to_uint64_rnintPtr.asFunction(); - - int bid64_to_uint64_rninta( - int x, - ) { - return _bid64_to_uint64_rninta( - x, - ); - } - - late final _bid64_to_uint64_rnintaPtr = - _lookup>( - 'bid64_to_uint64_rninta'); - late final _bid64_to_uint64_rninta = - _bid64_to_uint64_rnintaPtr.asFunction(); - - int bid64_to_uint64_xceil( - int x, - ) { - return _bid64_to_uint64_xceil( - x, - ); - } - - late final _bid64_to_uint64_xceilPtr = - _lookup>( - 'bid64_to_uint64_xceil'); - late final _bid64_to_uint64_xceil = - _bid64_to_uint64_xceilPtr.asFunction(); - - int bid64_to_uint64_xfloor( - int x, - ) { - return _bid64_to_uint64_xfloor( - x, - ); - } - - late final _bid64_to_uint64_xfloorPtr = - _lookup>( - 'bid64_to_uint64_xfloor'); - late final _bid64_to_uint64_xfloor = - _bid64_to_uint64_xfloorPtr.asFunction(); - - int bid64_to_uint64_xint( - int x, - ) { - return _bid64_to_uint64_xint( - x, - ); - } - - late final _bid64_to_uint64_xintPtr = - _lookup>( - 'bid64_to_uint64_xint'); - late final _bid64_to_uint64_xint = - _bid64_to_uint64_xintPtr.asFunction(); - - int bid64_to_uint64_xrnint( - int x, - ) { - return _bid64_to_uint64_xrnint( - x, - ); - } - - late final _bid64_to_uint64_xrnintPtr = - _lookup>( - 'bid64_to_uint64_xrnint'); - late final _bid64_to_uint64_xrnint = - _bid64_to_uint64_xrnintPtr.asFunction(); - - int bid64_to_uint64_xrninta( - int x, - ) { - return _bid64_to_uint64_xrninta( - x, - ); - } - - late final _bid64_to_uint64_xrnintaPtr = - _lookup>( - 'bid64_to_uint64_xrninta'); - late final _bid64_to_uint64_xrninta = - _bid64_to_uint64_xrnintaPtr.asFunction(); - - int bid64_to_uint8_ceil( - int x, - ) { - return _bid64_to_uint8_ceil( - x, - ); - } - - late final _bid64_to_uint8_ceilPtr = - _lookup>( - 'bid64_to_uint8_ceil'); - late final _bid64_to_uint8_ceil = - _bid64_to_uint8_ceilPtr.asFunction(); - - int bid64_to_uint8_floor( - int x, - ) { - return _bid64_to_uint8_floor( - x, - ); - } - - late final _bid64_to_uint8_floorPtr = - _lookup>( - 'bid64_to_uint8_floor'); - late final _bid64_to_uint8_floor = - _bid64_to_uint8_floorPtr.asFunction(); - - int bid64_to_uint8_int( - int x, - ) { - return _bid64_to_uint8_int( - x, - ); - } - - late final _bid64_to_uint8_intPtr = - _lookup>( - 'bid64_to_uint8_int'); - late final _bid64_to_uint8_int = - _bid64_to_uint8_intPtr.asFunction(); - - int bid64_to_uint8_rnint( - int x, - ) { - return _bid64_to_uint8_rnint( - x, - ); - } - - late final _bid64_to_uint8_rnintPtr = - _lookup>( - 'bid64_to_uint8_rnint'); - late final _bid64_to_uint8_rnint = - _bid64_to_uint8_rnintPtr.asFunction(); - - int bid64_to_uint8_rninta( - int x, - ) { - return _bid64_to_uint8_rninta( - x, - ); - } - - late final _bid64_to_uint8_rnintaPtr = - _lookup>( - 'bid64_to_uint8_rninta'); - late final _bid64_to_uint8_rninta = - _bid64_to_uint8_rnintaPtr.asFunction(); - - int bid64_to_uint8_xceil( - int x, - ) { - return _bid64_to_uint8_xceil( - x, - ); - } - - late final _bid64_to_uint8_xceilPtr = - _lookup>( - 'bid64_to_uint8_xceil'); - late final _bid64_to_uint8_xceil = - _bid64_to_uint8_xceilPtr.asFunction(); - - int bid64_to_uint8_xfloor( - int x, - ) { - return _bid64_to_uint8_xfloor( - x, - ); - } - - late final _bid64_to_uint8_xfloorPtr = - _lookup>( - 'bid64_to_uint8_xfloor'); - late final _bid64_to_uint8_xfloor = - _bid64_to_uint8_xfloorPtr.asFunction(); - - int bid64_to_uint8_xint( - int x, - ) { - return _bid64_to_uint8_xint( - x, - ); - } - - late final _bid64_to_uint8_xintPtr = - _lookup>( - 'bid64_to_uint8_xint'); - late final _bid64_to_uint8_xint = - _bid64_to_uint8_xintPtr.asFunction(); - - int bid64_to_uint8_xrnint( - int x, - ) { - return _bid64_to_uint8_xrnint( - x, - ); - } - - late final _bid64_to_uint8_xrnintPtr = - _lookup>( - 'bid64_to_uint8_xrnint'); - late final _bid64_to_uint8_xrnint = - _bid64_to_uint8_xrnintPtr.asFunction(); - - int bid64_to_uint8_xrninta( - int x, - ) { - return _bid64_to_uint8_xrninta( - x, - ); - } - - late final _bid64_to_uint8_xrnintaPtr = - _lookup>( - 'bid64_to_uint8_xrninta'); - late final _bid64_to_uint8_xrninta = - _bid64_to_uint8_xrnintaPtr.asFunction(); - - int bid64_totalOrder( - int x, - int y, - ) { - return _bid64_totalOrder( - x, - y, - ); - } - - late final _bid64_totalOrderPtr = - _lookup>( - 'bid64_totalOrder'); - late final _bid64_totalOrder = - _bid64_totalOrderPtr.asFunction(); - - int bid64_totalOrderMag( - int x, - int y, - ) { - return _bid64_totalOrderMag( - x, - y, - ); - } - - late final _bid64_totalOrderMagPtr = - _lookup>( - 'bid64_totalOrderMag'); - late final _bid64_totalOrderMag = - _bid64_totalOrderMagPtr.asFunction(); - - int bid64ddq_fma( - int x, - int y, - BID_UINT128 z, - ) { - return _bid64ddq_fma( - x, - y, - z, - ); - } - - late final _bid64ddq_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT64, BID_UINT64, BID_UINT128)>>('bid64ddq_fma'); - late final _bid64ddq_fma = - _bid64ddq_fmaPtr.asFunction(); - - int bid64dq_add( - int x, - BID_UINT128 y, - ) { - return _bid64dq_add( - x, - y, - ); - } - - late final _bid64dq_addPtr = - _lookup>( - 'bid64dq_add'); - late final _bid64dq_add = - _bid64dq_addPtr.asFunction(); - - int bid64dq_div( - int x, - BID_UINT128 y, - ) { - return _bid64dq_div( - x, - y, - ); - } - - late final _bid64dq_divPtr = - _lookup>( - 'bid64dq_div'); - late final _bid64dq_div = - _bid64dq_divPtr.asFunction(); - - int bid64dq_mul( - int x, - BID_UINT128 y, - ) { - return _bid64dq_mul( - x, - y, - ); - } - - late final _bid64dq_mulPtr = - _lookup>( - 'bid64dq_mul'); - late final _bid64dq_mul = - _bid64dq_mulPtr.asFunction(); - - int bid64dq_sub( - int x, - BID_UINT128 y, - ) { - return _bid64dq_sub( - x, - y, - ); - } - - late final _bid64dq_subPtr = - _lookup>( - 'bid64dq_sub'); - late final _bid64dq_sub = - _bid64dq_subPtr.asFunction(); - - int bid64dqd_fma( - int x, - BID_UINT128 y, - int z, - ) { - return _bid64dqd_fma( - x, - y, - z, - ); - } - - late final _bid64dqd_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT64, BID_UINT128, BID_UINT64)>>('bid64dqd_fma'); - late final _bid64dqd_fma = - _bid64dqd_fmaPtr.asFunction(); - - int bid64dqq_fma( - int x, - BID_UINT128 y, - BID_UINT128 z, - ) { - return _bid64dqq_fma( - x, - y, - z, - ); - } - - late final _bid64dqq_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT64, BID_UINT128, BID_UINT128)>>('bid64dqq_fma'); - late final _bid64dqq_fma = _bid64dqq_fmaPtr - .asFunction(); - - int bid64q_sqrt( - BID_UINT128 x, - ) { - return _bid64q_sqrt( - x, - ); - } - - late final _bid64q_sqrtPtr = - _lookup>( - 'bid64q_sqrt'); - late final _bid64q_sqrt = - _bid64q_sqrtPtr.asFunction(); - - int bid64qd_add( - BID_UINT128 x, - int y, - ) { - return _bid64qd_add( - x, - y, - ); - } - - late final _bid64qd_addPtr = - _lookup>( - 'bid64qd_add'); - late final _bid64qd_add = - _bid64qd_addPtr.asFunction(); - - int bid64qd_div( - BID_UINT128 x, - int y, - ) { - return _bid64qd_div( - x, - y, - ); - } - - late final _bid64qd_divPtr = - _lookup>( - 'bid64qd_div'); - late final _bid64qd_div = - _bid64qd_divPtr.asFunction(); - - int bid64qd_mul( - BID_UINT128 x, - int y, - ) { - return _bid64qd_mul( - x, - y, - ); - } - - late final _bid64qd_mulPtr = - _lookup>( - 'bid64qd_mul'); - late final _bid64qd_mul = - _bid64qd_mulPtr.asFunction(); - - int bid64qd_sub( - BID_UINT128 x, - int y, - ) { - return _bid64qd_sub( - x, - y, - ); - } - - late final _bid64qd_subPtr = - _lookup>( - 'bid64qd_sub'); - late final _bid64qd_sub = - _bid64qd_subPtr.asFunction(); - - int bid64qdd_fma( - BID_UINT128 x, - int y, - int z, - ) { - return _bid64qdd_fma( - x, - y, - z, - ); - } - - late final _bid64qdd_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT128, BID_UINT64, BID_UINT64)>>('bid64qdd_fma'); - late final _bid64qdd_fma = - _bid64qdd_fmaPtr.asFunction(); - - int bid64qdq_fma( - BID_UINT128 x, - int y, - BID_UINT128 z, - ) { - return _bid64qdq_fma( - x, - y, - z, - ); - } - - late final _bid64qdq_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT128, BID_UINT64, BID_UINT128)>>('bid64qdq_fma'); - late final _bid64qdq_fma = _bid64qdq_fmaPtr - .asFunction(); - - int bid64qq_add( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid64qq_add( - x, - y, - ); - } - - late final _bid64qq_addPtr = _lookup< - ffi.NativeFunction>( - 'bid64qq_add'); - late final _bid64qq_add = - _bid64qq_addPtr.asFunction(); - - int bid64qq_div( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid64qq_div( - x, - y, - ); - } - - late final _bid64qq_divPtr = _lookup< - ffi.NativeFunction>( - 'bid64qq_div'); - late final _bid64qq_div = - _bid64qq_divPtr.asFunction(); - - int bid64qq_mul( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid64qq_mul( - x, - y, - ); - } - - late final _bid64qq_mulPtr = _lookup< - ffi.NativeFunction>( - 'bid64qq_mul'); - late final _bid64qq_mul = - _bid64qq_mulPtr.asFunction(); - - int bid64qq_sub( - BID_UINT128 x, - BID_UINT128 y, - ) { - return _bid64qq_sub( - x, - y, - ); - } - - late final _bid64qq_subPtr = _lookup< - ffi.NativeFunction>( - 'bid64qq_sub'); - late final _bid64qq_sub = - _bid64qq_subPtr.asFunction(); - - int bid64qqd_fma( - BID_UINT128 x, - BID_UINT128 y, - int z, - ) { - return _bid64qqd_fma( - x, - y, - z, - ); - } - - late final _bid64qqd_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT128, BID_UINT128, BID_UINT64)>>('bid64qqd_fma'); - late final _bid64qqd_fma = _bid64qqd_fmaPtr - .asFunction(); - - int bid64qqq_fma( - BID_UINT128 x, - BID_UINT128 y, - BID_UINT128 z, - ) { - return _bid64qqq_fma( - x, - y, - z, - ); - } - - late final _bid64qqq_fmaPtr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function( - BID_UINT128, BID_UINT128, BID_UINT128)>>('bid64qqq_fma'); - late final _bid64qqq_fma = _bid64qqq_fmaPtr - .asFunction(); - - BID_UINT128 bid_dpd_to_bid128( - BID_UINT128 px, - ) { - return _bid_dpd_to_bid128( - px, - ); - } - - late final _bid_dpd_to_bid128Ptr = - _lookup>( - 'bid_dpd_to_bid128'); - late final _bid_dpd_to_bid128 = - _bid_dpd_to_bid128Ptr.asFunction(); - - int bid_dpd_to_bid32( - int px, - ) { - return _bid_dpd_to_bid32( - px, - ); - } - - late final _bid_dpd_to_bid32Ptr = - _lookup>( - 'bid_dpd_to_bid32'); - late final _bid_dpd_to_bid32 = - _bid_dpd_to_bid32Ptr.asFunction(); - - int bid_dpd_to_bid64( - int px, - ) { - return _bid_dpd_to_bid64( - px, - ); - } - - late final _bid_dpd_to_bid64Ptr = - _lookup>( - 'bid_dpd_to_bid64'); - late final _bid_dpd_to_bid64 = - _bid_dpd_to_bid64Ptr.asFunction(); - - void bid_feclearexcept( - int excepts, - ) { - return _bid_feclearexcept( - excepts, - ); - } - - late final _bid_feclearexceptPtr = - _lookup>( - 'bid_feclearexcept'); - late final _bid_feclearexcept = - _bid_feclearexceptPtr.asFunction(); - - void bid_fegetexceptflag( - ffi.Pointer flagp, - int excepts, - ) { - return _bid_fegetexceptflag( - flagp, - excepts, - ); - } - - late final _bid_fegetexceptflagPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, ffi.Int)>>('bid_fegetexceptflag'); - late final _bid_fegetexceptflag = _bid_fegetexceptflagPtr - .asFunction, int)>(); - - void bid_feraiseexcept( - int excepts, - ) { - return _bid_feraiseexcept( - excepts, - ); - } - - late final _bid_feraiseexceptPtr = - _lookup>( - 'bid_feraiseexcept'); - late final _bid_feraiseexcept = - _bid_feraiseexceptPtr.asFunction(); - - void bid_fesetexceptflag( - ffi.Pointer flagp, - int excepts, - ) { - return _bid_fesetexceptflag( - flagp, - excepts, - ); - } - - late final _bid_fesetexceptflagPtr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, ffi.Int)>>('bid_fesetexceptflag'); - late final _bid_fesetexceptflag = _bid_fesetexceptflagPtr - .asFunction, int)>(); - - int bid_fetestexcept( - int excepts, - ) { - return _bid_fetestexcept( - excepts, - ); - } - - late final _bid_fetestexceptPtr = - _lookup>( - 'bid_fetestexcept'); - late final _bid_fetestexcept = - _bid_fetestexceptPtr.asFunction(); - - int bid_getDecimalRoundingDirection( - int rnd_mode, - ) { - return _bid_getDecimalRoundingDirection( - rnd_mode, - ); - } - - late final _bid_getDecimalRoundingDirectionPtr = - _lookup>( - 'bid_getDecimalRoundingDirection'); - late final _bid_getDecimalRoundingDirection = - _bid_getDecimalRoundingDirectionPtr.asFunction(); - - int bid_is754() { - return _bid_is754(); - } - - late final _bid_is754Ptr = - _lookup>('bid_is754'); - late final _bid_is754 = _bid_is754Ptr.asFunction(); - - int bid_is754R() { - return _bid_is754R(); - } - - late final _bid_is754RPtr = - _lookup>('bid_is754R'); - late final _bid_is754R = _bid_is754RPtr.asFunction(); - - void bid_lowerFlags( - int flagsmask, - ) { - return _bid_lowerFlags( - flagsmask, - ); - } - - late final _bid_lowerFlagsPtr = - _lookup>('bid_lowerFlags'); - late final _bid_lowerFlags = - _bid_lowerFlagsPtr.asFunction(); - - void bid_restoreFlags( - int flagsvalues, - int flagsmask, - ) { - return _bid_restoreFlags( - flagsvalues, - flagsmask, - ); - } - - late final _bid_restoreFlagsPtr = - _lookup>( - 'bid_restoreFlags'); - late final _bid_restoreFlags = - _bid_restoreFlagsPtr.asFunction(); - - void bid_round128_19_38( - int q, - int x, - BID_UINT128 C, - ffi.Pointer ptr_Cstar, - ffi.Pointer delta_exp, - ffi.Pointer ptr_is_midpoint_lt_even, - ffi.Pointer ptr_is_midpoint_gt_even, - ffi.Pointer ptr_is_inexact_lt_midpoint, - ffi.Pointer ptr_is_inexact_gt_midpoint, - ) { - return _bid_round128_19_38( - q, - x, - C, - ptr_Cstar, - delta_exp, - ptr_is_midpoint_lt_even, - ptr_is_midpoint_gt_even, - ptr_is_inexact_lt_midpoint, - ptr_is_inexact_gt_midpoint, - ); - } - - late final _bid_round128_19_38Ptr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Int, - ffi.Int, - BID_UINT128, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>('bid_round128_19_38'); - late final _bid_round128_19_38 = _bid_round128_19_38Ptr.asFunction< - void Function( - int, - int, - BID_UINT128, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>(); - - void bid_round192_39_57( - int q, - int x, - BID_UINT192 C, - ffi.Pointer ptr_Cstar, - ffi.Pointer delta_exp, - ffi.Pointer ptr_is_midpoint_lt_even, - ffi.Pointer ptr_is_midpoint_gt_even, - ffi.Pointer ptr_is_inexact_lt_midpoint, - ffi.Pointer ptr_is_inexact_gt_midpoint, - ) { - return _bid_round192_39_57( - q, - x, - C, - ptr_Cstar, - delta_exp, - ptr_is_midpoint_lt_even, - ptr_is_midpoint_gt_even, - ptr_is_inexact_lt_midpoint, - ptr_is_inexact_gt_midpoint, - ); - } - - late final _bid_round192_39_57Ptr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Int, - ffi.Int, - BID_UINT192, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>('bid_round192_39_57'); - late final _bid_round192_39_57 = _bid_round192_39_57Ptr.asFunction< - void Function( - int, - int, - BID_UINT192, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>(); - - void bid_round256_58_76( - int q, - int x, - BID_UINT256 C, - ffi.Pointer ptr_Cstar, - ffi.Pointer delta_exp, - ffi.Pointer ptr_is_midpoint_lt_even, - ffi.Pointer ptr_is_midpoint_gt_even, - ffi.Pointer ptr_is_inexact_lt_midpoint, - ffi.Pointer ptr_is_inexact_gt_midpoint, - ) { - return _bid_round256_58_76( - q, - x, - C, - ptr_Cstar, - delta_exp, - ptr_is_midpoint_lt_even, - ptr_is_midpoint_gt_even, - ptr_is_inexact_lt_midpoint, - ptr_is_inexact_gt_midpoint, - ); - } - - late final _bid_round256_58_76Ptr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Int, - ffi.Int, - BID_UINT256, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>('bid_round256_58_76'); - late final _bid_round256_58_76 = _bid_round256_58_76Ptr.asFunction< - void Function( - int, - int, - BID_UINT256, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>(); - - void bid_round64_2_18( - int q, - int x, - int C, - ffi.Pointer ptr_Cstar, - ffi.Pointer delta_exp, - ffi.Pointer ptr_is_midpoint_lt_even, - ffi.Pointer ptr_is_midpoint_gt_even, - ffi.Pointer ptr_is_inexact_lt_midpoint, - ffi.Pointer ptr_is_inexact_gt_midpoint, - ) { - return _bid_round64_2_18( - q, - x, - C, - ptr_Cstar, - delta_exp, - ptr_is_midpoint_lt_even, - ptr_is_midpoint_gt_even, - ptr_is_inexact_lt_midpoint, - ptr_is_inexact_gt_midpoint, - ); - } - - late final _bid_round64_2_18Ptr = _lookup< - ffi.NativeFunction< - ffi.Void Function( - ffi.Int, - ffi.Int, - BID_UINT64, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>('bid_round64_2_18'); - late final _bid_round64_2_18 = _bid_round64_2_18Ptr.asFunction< - void Function( - int, - int, - int, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>(); - - int bid_saveFlags( - int flagsmask, - ) { - return _bid_saveFlags( - flagsmask, - ); - } - - late final _bid_saveFlagsPtr = - _lookup>('bid_saveFlags'); - late final _bid_saveFlags = _bid_saveFlagsPtr.asFunction(); - - int bid_setDecimalRoundingDirection( - int rounding_mode, - ) { - return _bid_setDecimalRoundingDirection( - rounding_mode, - ); - } - - late final _bid_setDecimalRoundingDirectionPtr = - _lookup>( - 'bid_setDecimalRoundingDirection'); - late final _bid_setDecimalRoundingDirection = - _bid_setDecimalRoundingDirectionPtr.asFunction(); - - void bid_signalException( - int flagsmask, - ) { - return _bid_signalException( - flagsmask, - ); - } - - late final _bid_signalExceptionPtr = - _lookup>( - 'bid_signalException'); - late final _bid_signalException = - _bid_signalExceptionPtr.asFunction(); - - BID_UINT128 bid_strtod128( - ffi.Pointer ps_in, - ffi.Pointer> endptr, - ) { - return _bid_strtod128( - ps_in, - endptr, - ); - } - - late final _bid_strtod128Ptr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function(ffi.Pointer, - ffi.Pointer>)>>('bid_strtod128'); - late final _bid_strtod128 = _bid_strtod128Ptr.asFunction< - BID_UINT128 Function( - ffi.Pointer, ffi.Pointer>)>(); - - int bid_strtod32( - ffi.Pointer ps_in, - ffi.Pointer> endptr, - ) { - return _bid_strtod32( - ps_in, - endptr, - ); - } - - late final _bid_strtod32Ptr = _lookup< - ffi.NativeFunction< - BID_UINT32 Function(ffi.Pointer, - ffi.Pointer>)>>('bid_strtod32'); - late final _bid_strtod32 = _bid_strtod32Ptr.asFunction< - int Function( - ffi.Pointer, ffi.Pointer>)>(); - - int bid_strtod64( - ffi.Pointer ps_in, - ffi.Pointer> endptr, - ) { - return _bid_strtod64( - ps_in, - endptr, - ); - } - - late final _bid_strtod64Ptr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function(ffi.Pointer, - ffi.Pointer>)>>('bid_strtod64'); - late final _bid_strtod64 = _bid_strtod64Ptr.asFunction< - int Function( - ffi.Pointer, ffi.Pointer>)>(); - - int bid_testFlags( - int flagsmask, - ) { - return _bid_testFlags( - flagsmask, - ); - } - - late final _bid_testFlagsPtr = - _lookup>('bid_testFlags'); - late final _bid_testFlags = _bid_testFlagsPtr.asFunction(); - - int bid_testSavedFlags( - int savedflags, - int flagsmask, - ) { - return _bid_testSavedFlags( - savedflags, - flagsmask, - ); - } - - late final _bid_testSavedFlagsPtr = - _lookup>( - 'bid_testSavedFlags'); - late final _bid_testSavedFlags = - _bid_testSavedFlagsPtr.asFunction(); - - BID_UINT128 bid_to_dpd128( - BID_UINT128 px, - ) { - return _bid_to_dpd128( - px, - ); - } - - late final _bid_to_dpd128Ptr = - _lookup>( - 'bid_to_dpd128'); - late final _bid_to_dpd128 = - _bid_to_dpd128Ptr.asFunction(); - - int bid_to_dpd32( - int px, - ) { - return _bid_to_dpd32( - px, - ); - } - - late final _bid_to_dpd32Ptr = - _lookup>( - 'bid_to_dpd32'); - late final _bid_to_dpd32 = _bid_to_dpd32Ptr.asFunction(); - - int bid_to_dpd64( - int px, - ) { - return _bid_to_dpd64( - px, - ); - } - - late final _bid_to_dpd64Ptr = - _lookup>( - 'bid_to_dpd64'); - late final _bid_to_dpd64 = _bid_to_dpd64Ptr.asFunction(); - - BID_UINT128 bid_wcstod128( - ffi.Pointer ps_in, - ffi.Pointer> endptr, - ) { - return _bid_wcstod128( - ps_in, - endptr, - ); - } - - late final _bid_wcstod128Ptr = _lookup< - ffi.NativeFunction< - BID_UINT128 Function(ffi.Pointer, - ffi.Pointer>)>>('bid_wcstod128'); - late final _bid_wcstod128 = _bid_wcstod128Ptr.asFunction< - BID_UINT128 Function( - ffi.Pointer, ffi.Pointer>)>(); - - int bid_wcstod32( - ffi.Pointer ps_in, - ffi.Pointer> endptr, - ) { - return _bid_wcstod32( - ps_in, - endptr, - ); - } - - late final _bid_wcstod32Ptr = _lookup< - ffi.NativeFunction< - BID_UINT32 Function(ffi.Pointer, - ffi.Pointer>)>>('bid_wcstod32'); - late final _bid_wcstod32 = _bid_wcstod32Ptr.asFunction< - int Function( - ffi.Pointer, ffi.Pointer>)>(); - - int bid_wcstod64( - ffi.Pointer ps_in, - ffi.Pointer> endptr, - ) { - return _bid_wcstod64( - ps_in, - endptr, - ); - } - - late final _bid_wcstod64Ptr = _lookup< - ffi.NativeFunction< - BID_UINT64 Function(ffi.Pointer, - ffi.Pointer>)>>('bid_wcstod64'); - late final _bid_wcstod64 = _bid_wcstod64Ptr.asFunction< - int Function( - ffi.Pointer, ffi.Pointer>)>(); - - BID_UINT128 binary128_to_bid128( - BID_UINT128 x, - ) { - return _binary128_to_bid128( - x, - ); - } - - late final _binary128_to_bid128Ptr = - _lookup>( - 'binary128_to_bid128'); - late final _binary128_to_bid128 = - _binary128_to_bid128Ptr.asFunction(); - - int binary128_to_bid32( - BID_UINT128 x, - ) { - return _binary128_to_bid32( - x, - ); - } - - late final _binary128_to_bid32Ptr = - _lookup>( - 'binary128_to_bid32'); - late final _binary128_to_bid32 = - _binary128_to_bid32Ptr.asFunction(); - - int binary128_to_bid64( - BID_UINT128 x, - ) { - return _binary128_to_bid64( - x, - ); - } - - late final _binary128_to_bid64Ptr = - _lookup>( - 'binary128_to_bid64'); - late final _binary128_to_bid64 = - _binary128_to_bid64Ptr.asFunction(); - - BID_UINT128 binary32_to_bid128( - double x, - ) { - return _binary32_to_bid128( - x, - ); - } - - late final _binary32_to_bid128Ptr = - _lookup>( - 'binary32_to_bid128'); - late final _binary32_to_bid128 = - _binary32_to_bid128Ptr.asFunction(); - - int binary32_to_bid32( - double x, - ) { - return _binary32_to_bid32( - x, - ); - } - - late final _binary32_to_bid32Ptr = - _lookup>( - 'binary32_to_bid32'); - late final _binary32_to_bid32 = - _binary32_to_bid32Ptr.asFunction(); - - int binary32_to_bid64( - double x, - ) { - return _binary32_to_bid64( - x, - ); - } - - late final _binary32_to_bid64Ptr = - _lookup>( - 'binary32_to_bid64'); - late final _binary32_to_bid64 = - _binary32_to_bid64Ptr.asFunction(); - - BID_UINT128 binary64_to_bid128( - double x, - ) { - return _binary64_to_bid128( - x, - ); - } - - late final _binary64_to_bid128Ptr = - _lookup>( - 'binary64_to_bid128'); - late final _binary64_to_bid128 = - _binary64_to_bid128Ptr.asFunction(); - - int binary64_to_bid32( - double x, - ) { - return _binary64_to_bid32( - x, - ); - } - - late final _binary64_to_bid32Ptr = - _lookup>( - 'binary64_to_bid32'); - late final _binary64_to_bid32 = - _binary64_to_bid32Ptr.asFunction(); - - int binary64_to_bid64( - double x, - ) { - return _binary64_to_bid64( - x, - ); - } - - late final _binary64_to_bid64Ptr = - _lookup>( - 'binary64_to_bid64'); - late final _binary64_to_bid64 = - _binary64_to_bid64Ptr.asFunction(); - /// Add a callback that will be invoked every time the view of this file is updated. /// /// This callback is guaranteed to be invoked before any object or collection change @@ -13057,6 +3182,196 @@ class RealmLibrary { late final _realm_dart_create_scheduler = _realm_dart_create_schedulerPtr .asFunction Function(int, int)>(); + realm_decimal128_t realm_dart_decimal128_add( + realm_decimal128_t x, + realm_decimal128_t y, + ) { + return _realm_dart_decimal128_add( + x, + y, + ); + } + + late final _realm_dart_decimal128_addPtr = _lookup< + ffi.NativeFunction< + realm_decimal128_t Function(realm_decimal128_t, + realm_decimal128_t)>>('realm_dart_decimal128_add'); + late final _realm_dart_decimal128_add = + _realm_dart_decimal128_addPtr.asFunction< + realm_decimal128_t Function( + realm_decimal128_t, realm_decimal128_t)>(); + + realm_decimal128_t realm_dart_decimal128_divide( + realm_decimal128_t x, + realm_decimal128_t y, + ) { + return _realm_dart_decimal128_divide( + x, + y, + ); + } + + late final _realm_dart_decimal128_dividePtr = _lookup< + ffi.NativeFunction< + realm_decimal128_t Function(realm_decimal128_t, + realm_decimal128_t)>>('realm_dart_decimal128_divide'); + late final _realm_dart_decimal128_divide = + _realm_dart_decimal128_dividePtr.asFunction< + realm_decimal128_t Function( + realm_decimal128_t, realm_decimal128_t)>(); + + bool realm_dart_decimal128_equal( + realm_decimal128_t x, + realm_decimal128_t y, + ) { + return _realm_dart_decimal128_equal( + x, + y, + ); + } + + late final _realm_dart_decimal128_equalPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(realm_decimal128_t, + realm_decimal128_t)>>('realm_dart_decimal128_equal'); + late final _realm_dart_decimal128_equal = _realm_dart_decimal128_equalPtr + .asFunction(); + + realm_decimal128_t realm_dart_decimal128_from_int64( + int low, + ) { + return _realm_dart_decimal128_from_int64( + low, + ); + } + + late final _realm_dart_decimal128_from_int64Ptr = + _lookup>( + 'realm_dart_decimal128_from_int64'); + late final _realm_dart_decimal128_from_int64 = + _realm_dart_decimal128_from_int64Ptr + .asFunction(); + + realm_decimal128_t realm_dart_decimal128_from_string( + ffi.Pointer string, + ) { + return _realm_dart_decimal128_from_string( + string, + ); + } + + late final _realm_dart_decimal128_from_stringPtr = _lookup< + ffi.NativeFunction< + realm_decimal128_t Function( + ffi.Pointer)>>('realm_dart_decimal128_from_string'); + late final _realm_dart_decimal128_from_string = + _realm_dart_decimal128_from_stringPtr + .asFunction)>(); + + bool realm_dart_decimal128_greater_than( + realm_decimal128_t x, + realm_decimal128_t y, + ) { + return _realm_dart_decimal128_greater_than( + x, + y, + ); + } + + late final _realm_dart_decimal128_greater_thanPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(realm_decimal128_t, + realm_decimal128_t)>>('realm_dart_decimal128_greater_than'); + late final _realm_dart_decimal128_greater_than = + _realm_dart_decimal128_greater_thanPtr + .asFunction(); + + bool realm_dart_decimal128_less_than( + realm_decimal128_t x, + realm_decimal128_t y, + ) { + return _realm_dart_decimal128_less_than( + x, + y, + ); + } + + late final _realm_dart_decimal128_less_thanPtr = _lookup< + ffi.NativeFunction< + ffi.Bool Function(realm_decimal128_t, + realm_decimal128_t)>>('realm_dart_decimal128_less_than'); + late final _realm_dart_decimal128_less_than = + _realm_dart_decimal128_less_thanPtr + .asFunction(); + + realm_decimal128_t realm_dart_decimal128_multiply( + realm_decimal128_t x, + realm_decimal128_t y, + ) { + return _realm_dart_decimal128_multiply( + x, + y, + ); + } + + late final _realm_dart_decimal128_multiplyPtr = _lookup< + ffi.NativeFunction< + realm_decimal128_t Function(realm_decimal128_t, + realm_decimal128_t)>>('realm_dart_decimal128_multiply'); + late final _realm_dart_decimal128_multiply = + _realm_dart_decimal128_multiplyPtr.asFunction< + realm_decimal128_t Function( + realm_decimal128_t, realm_decimal128_t)>(); + + realm_decimal128_t realm_dart_decimal128_subtract( + realm_decimal128_t x, + realm_decimal128_t y, + ) { + return _realm_dart_decimal128_subtract( + x, + y, + ); + } + + late final _realm_dart_decimal128_subtractPtr = _lookup< + ffi.NativeFunction< + realm_decimal128_t Function(realm_decimal128_t, + realm_decimal128_t)>>('realm_dart_decimal128_subtract'); + late final _realm_dart_decimal128_subtract = + _realm_dart_decimal128_subtractPtr.asFunction< + realm_decimal128_t Function( + realm_decimal128_t, realm_decimal128_t)>(); + + int realm_dart_decimal128_to_int64( + realm_decimal128_t decimal, + ) { + return _realm_dart_decimal128_to_int64( + decimal, + ); + } + + late final _realm_dart_decimal128_to_int64Ptr = + _lookup>( + 'realm_dart_decimal128_to_int64'); + late final _realm_dart_decimal128_to_int64 = + _realm_dart_decimal128_to_int64Ptr + .asFunction(); + + realm_string_t realm_dart_decimal128_to_string( + realm_decimal128_t x, + ) { + return _realm_dart_decimal128_to_string( + x, + ); + } + + late final _realm_dart_decimal128_to_stringPtr = + _lookup>( + 'realm_dart_decimal128_to_string'); + late final _realm_dart_decimal128_to_string = + _realm_dart_decimal128_to_stringPtr + .asFunction(); + void realm_dart_delete_persistent_handle( ffi.Pointer handle, ) { @@ -20341,6 +10656,58 @@ class _SymbolAddresses { ffi.Pointer Function(ffi.Uint64, Dart_Port)>> get realm_dart_create_scheduler => _library._realm_dart_create_schedulerPtr; + ffi.Pointer< + ffi.NativeFunction< + realm_decimal128_t Function( + realm_decimal128_t, realm_decimal128_t)>> + get realm_dart_decimal128_add => _library._realm_dart_decimal128_addPtr; + ffi.Pointer< + ffi.NativeFunction< + realm_decimal128_t Function( + realm_decimal128_t, realm_decimal128_t)>> + get realm_dart_decimal128_divide => + _library._realm_dart_decimal128_dividePtr; + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(realm_decimal128_t, realm_decimal128_t)>> + get realm_dart_decimal128_equal => + _library._realm_dart_decimal128_equalPtr; + ffi.Pointer> + get realm_dart_decimal128_from_int64 => + _library._realm_dart_decimal128_from_int64Ptr; + ffi.Pointer< + ffi.NativeFunction< + realm_decimal128_t Function(ffi.Pointer)>> + get realm_dart_decimal128_from_string => + _library._realm_dart_decimal128_from_stringPtr; + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(realm_decimal128_t, realm_decimal128_t)>> + get realm_dart_decimal128_greater_than => + _library._realm_dart_decimal128_greater_thanPtr; + ffi.Pointer< + ffi.NativeFunction< + ffi.Bool Function(realm_decimal128_t, realm_decimal128_t)>> + get realm_dart_decimal128_less_than => + _library._realm_dart_decimal128_less_thanPtr; + ffi.Pointer< + ffi.NativeFunction< + realm_decimal128_t Function( + realm_decimal128_t, realm_decimal128_t)>> + get realm_dart_decimal128_multiply => + _library._realm_dart_decimal128_multiplyPtr; + ffi.Pointer< + ffi.NativeFunction< + realm_decimal128_t Function( + realm_decimal128_t, realm_decimal128_t)>> + get realm_dart_decimal128_subtract => + _library._realm_dart_decimal128_subtractPtr; + ffi.Pointer> + get realm_dart_decimal128_to_int64 => + _library._realm_dart_decimal128_to_int64Ptr; + ffi.Pointer> + get realm_dart_decimal128_to_string => + _library._realm_dart_decimal128_to_stringPtr; ffi.Pointer)>> get realm_dart_delete_persistent_handle => _library._realm_dart_delete_persistent_handlePtr; @@ -20444,156 +10811,6 @@ class _SymbolAddresses { get realm_release => _library._realm_releasePtr; } -const int BID128_MAXDIGITS = 34; - -const int BID32_MAXDIGITS = 7; - -const int BID64_MAXDIGITS = 16; - -const int BID_BIG_ENDIAN = 0; - -const int BID_DENORMAL_EXCEPTION = 2; - -const int BID_DENORMAL_MODE = 256; - -const int BID_EXACT_STATUS = 0; - -const int BID_FLAG_MASK = 63; - -const String BID_FMT_LLD = '%I64d'; - -const String BID_FMT_LLD16 = '%016I64d'; - -const String BID_FMT_LLU = '%I64u'; - -const String BID_FMT_LLU16 = '%016I64u'; - -const String BID_FMT_LLU4 = '%4I64u'; - -const String BID_FMT_LLX = '%I64x'; - -const String BID_FMT_LLX16 = '%016I64x'; - -const String BID_FMT_X4 = '%04x'; - -const String BID_FMT_X8 = '%08x'; - -const int BID_HAS_GCC_DECIMAL_INTRINSICS = 0; - -const int BID_HIGH_128W = 1; - -const int BID_IEEE_FLAGS = 61; - -const int BID_INEXACT_EXCEPTION = 32; - -const int BID_INEXACT_MODE = 4096; - -const int BID_INVALID_EXCEPTION = 1; - -const int BID_INVALID_MODE = 128; - -const String BID_LD = '%I64d'; - -const String BID_LD16 = '%016I64d'; - -const String BID_LD4 = '%4I64u'; - -const int BID_LOW_128W = 0; - -const String BID_LUD = '%I64u'; - -const String BID_LUD16 = '%016I64u'; - -const String BID_LX = '%I64x'; - -const String BID_LX16 = '%016I64x'; - -const int BID_MODE_MASK = 8064; - -const int BID_OVERFLOW_EXCEPTION = 8; - -const int BID_OVERFLOW_INEXACT_EXCEPTION = 40; - -const int BID_OVERFLOW_MODE = 1024; - -const int BID_RMODE_MASK = 7; - -const int BID_ROUNDING_DOWN = 1; - -const int BID_ROUNDING_TIES_AWAY = 4; - -const int BID_ROUNDING_TO_NEAREST = 0; - -const int BID_ROUNDING_TO_ZERO = 3; - -const int BID_ROUNDING_UP = 2; - -typedef BID_SINT64 = ffi.LongLong; - -const int BID_SIZE_LONG = 4; - -class BID_UINT128 extends ffi.Struct { - @ffi.Array.multi([2]) - external ffi.Array w; -} - -class BID_UINT192 extends ffi.Struct { - @ffi.Array.multi([3]) - external ffi.Array w; -} - -class BID_UINT256 extends ffi.Struct { - @ffi.Array.multi([4]) - external ffi.Array w; -} - -typedef BID_UINT32 = ffi.UnsignedInt; -typedef BID_UINT64 = ffi.UnsignedLongLong; - -const int BID_UNDERFLOW_EXCEPTION = 16; - -const int BID_UNDERFLOW_INEXACT_EXCEPTION = 48; - -const int BID_UNDERFLOW_MODE = 2048; - -const String BID_X4 = '%04x'; - -const String BID_X8 = '%08x'; - -const int BID_ZERO_DIVIDE_EXCEPTION = 4; - -const int BID_ZERO_DIVIDE_MODE = 512; - -const int BINARY_TINY_DETECTION_AFTER_ROUNDING = 1; - -const int DECIMAL_ALTERNATE_EXCEPTION_HANDLING = 0; - -const int DECIMAL_CALL_BY_REFERENCE = 1; - -const int DECIMAL_GLOBAL_EXCEPTION_FLAGS = 0; - -const int DECIMAL_GLOBAL_EXCEPTION_FLAGS_ACCESS_FUNCTIONS = 0; - -const int DECIMAL_GLOBAL_ROUNDING = 1; - -const int DECIMAL_GLOBAL_ROUNDING_ACCESS_FUNCTIONS = 0; - -const int DECIMAL_TINY_DETECTION_AFTER_ROUNDING = 0; - -const int DEC_FE_ALL_EXCEPT = 63; - -const int DEC_FE_DIVBYZERO = 4; - -const int DEC_FE_INEXACT = 32; - -const int DEC_FE_INVALID = 1; - -const int DEC_FE_OVERFLOW = 8; - -const int DEC_FE_UNDERFLOW = 16; - -const int DEC_FE_UNNORMAL = 2; - /// A port is used to send or receive inter-isolate messages typedef Dart_Port = ffi.Int64; @@ -20628,10 +10845,6 @@ class UnnamedUnion1 extends ffi.Union { external ffi.Array data; } -const int __ENABLE_BINARY80__ = 1; - -typedef fexcept_t = ffi.UnsignedShort; - class realm_app extends ffi.Opaque {} class realm_app_config extends ffi.Opaque {} diff --git a/lib/src/native/realm_core.dart b/lib/src/native/realm_core.dart index b34ce1e87..8e6403db3 100644 --- a/lib/src/native/realm_core.dart +++ b/lib/src/native/realm_core.dart @@ -49,6 +49,8 @@ import 'realm_bindings.dart'; late RealmLibrary _realmLib; +late RealmLibrary lib = _realmLib; + final _RealmCore realmCore = _RealmCore(); class _RealmCore { diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index 1fadb181b..86e2c0815 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -23,6 +23,8 @@ #include "realm_dart.h" #include "realm_dart.hpp" +#include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_conf.h" +#include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_functions.h" #if REALM_ARCHITECTURE_ARM32 || REALM_ARCHITECTURE_ARM64 || REALM_ARCHITECTURE_X86_32 || REALM_ARCHITECTURE_X86_64 #if REALM_ARCHITECTURE_ARM32 @@ -148,3 +150,85 @@ RLM_API void realm_set_auto_refresh(realm_t* realm, bool enable){ RLM_API const char* realm_get_library_cpu_arch() { return cpuArch.c_str(); } + +RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string) { + realm_decimal128_t result; + unsigned int flags = 0; + __bid128_from_string((BID_UINT128*)&result, const_cast(string), &flags); + return result; +} + +RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x) { + // This buffer is reused between calls, hence the static keyword + static char buffer[34]; // 34 bytes is the maximum length of a string representation of a decimal128 + unsigned int flags = 0; + __bid128_to_string(buffer, (BID_UINT128*)&x, &flags); + return realm_string_t{buffer, strlen(buffer)}; +} + +RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t x) { + realm_decimal128_t decimal; + unsigned int flags = 0; + __bid128_from_int64((BID_UINT128*)&decimal, (BID_SINT64*)&x); + return decimal; +} + +RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal) { + int64_t result; + unsigned int flags = 0; + __bid128_to_int64_int(&result, (BID_UINT128*)&decimal, &flags); + return result; +} + +RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y) { + realm_decimal128_t result; + unsigned int flags = 0; + __bid128_add((BID_UINT128*)&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); + return result; +} + +RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y) { + realm_decimal128_t result; + unsigned int flags = 0; + __bid128_sub((BID_UINT128*)&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); + return result; +} + +RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y) { + realm_decimal128_t result; + unsigned int flags = 0; + __bid128_mul((BID_UINT128*)&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); + return result; +} + +RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, realm_decimal128_t y) { + realm_decimal128_t result; + unsigned int flags = 0; + __bid128_div((BID_UINT128*)&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); + return result; +} + +RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y) { + int result; + unsigned int flags = 0; + __bid128_quiet_equal(&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); + return result == 1; +} + +RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y) { + int result; + unsigned int flags = 0; + __bid128_quiet_less(&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); + return result == 1; +} + +RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y) { + int result; + unsigned int flags = 0; + __bid128_quiet_greater(&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); + return result == 1; +} + + + + diff --git a/src/realm_dart.h b/src/realm_dart.h index a1c460f1b..351521aa9 100644 --- a/src/realm_dart.h +++ b/src/realm_dart.h @@ -53,4 +53,18 @@ RLM_API const char* realm_dart_library_version(); RLM_API void* realm_attach_finalizer(Dart_Handle handle, void* realmPtr, int size); RLM_API void realm_dettach_finalizer(void* finalizableHandle, Dart_Handle handle); RLM_API void realm_set_auto_refresh(realm_t* realm, bool enable); + +RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string); +RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x); + +RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t low); +RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal); +RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y); +RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y); +RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y); +RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, realm_decimal128_t y); +RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y); +RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y); +RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y); + #endif // REALM_DART_H \ No newline at end of file From 5bf55932dc6e8f93207d247765e451f6a436f18c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Wed, 1 Mar 2023 22:39:32 +0100 Subject: [PATCH 03/30] Add Decimal128 + test --- lib/src/decimal128.dart | 124 +++++++++++++++++++++++++++++ test/decimal128_test.dart | 163 ++++++++++++++++++++++++++++++++++++++ 2 files changed, 287 insertions(+) create mode 100644 lib/src/decimal128.dart create mode 100644 test/decimal128_test.dart diff --git a/lib/src/decimal128.dart b/lib/src/decimal128.dart new file mode 100644 index 000000000..5b0a312f1 --- /dev/null +++ b/lib/src/decimal128.dart @@ -0,0 +1,124 @@ +//////////////////////////////////////////////////////////////////////////////// +// +// Copyright 2023 Realm Inc. +// +// 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. +// +//////////////////////////////////////////////////////////////////////////////// + +import 'dart:convert'; +import 'dart:ffi'; + +import 'package:ffi/ffi.dart'; + +import 'native/realm_bindings.dart'; +import 'native/realm_core.dart'; + +class Decimal128 extends Comparable { + static final zero = Decimal128.fromInt(0); + static final one = Decimal128.fromInt(1); + static final ten = Decimal128.fromInt(10); + + static final nan = Decimal128.parse('+NaN'); + static final infinity = one / zero; // +Inf + static final negativeInfinity = -infinity; + + final realm_decimal128_t _value; + + Decimal128._(this._value); + + static final _validInput = RegExp(r'^[+-]?((\d+\.?\d*|\d*\.?\d+)([eE][+-]?\d+)?|NaN|Inf)$'); + static Decimal128? tryParse(String source) { + if (!_validInput.hasMatch(source)) return null; + return using((arena) { + final result = lib.realm_dart_decimal128_from_string(source.toNativeUtf8(allocator: arena).cast()); + return Decimal128._(result); + }); + } + + factory Decimal128.parse(String source) { + return tryParse(source) ?? (throw FormatException('Invalid Decimal128', source)); + } + + factory Decimal128.fromInt(int value) { + return Decimal128._(lib.realm_dart_decimal128_from_int64(value)); + } + + factory Decimal128.fromDouble(double value) { + return Decimal128.parse(value.toString()); // TODO(kn): Find a way to optimize this + } + + Decimal128 operator +(Decimal128 other) { + return Decimal128._(lib.realm_dart_decimal128_add(_value, other._value)); + } + + Decimal128 operator -(Decimal128 other) { + return Decimal128._(lib.realm_dart_decimal128_subtract(_value, other._value)); + } + + Decimal128 operator *(Decimal128 other) { + return Decimal128._(lib.realm_dart_decimal128_multiply(_value, other._value)); + } + + Decimal128 operator /(Decimal128 other) { + return Decimal128._(lib.realm_dart_decimal128_divide(_value, other._value)); + } + + Decimal128 operator -() => zero - this; + + Decimal128 abs() => this < zero ? -this : this; + + @override + // ignore: hash_and_equals + operator ==(Object other) { + // WARNING: Don't use identical to ensure nan != nan + // if (identical(this, other)) return true; + if (other is Decimal128) { + return lib.realm_dart_decimal128_equal(_value, other._value); + } + return false; + } + + bool operator <(Decimal128 other) { + return lib.realm_dart_decimal128_less_than(_value, other._value); + } + + bool operator <=(Decimal128 other) => compareTo(other) <= 0; + + bool operator >(Decimal128 other) { + return lib.realm_dart_decimal128_greater_than(_value, other._value); + } + + bool operator >=(Decimal128 other) => compareTo(other) >= 0; + + int toInt() => lib.realm_dart_decimal128_to_int64(_value); + + @override + String toString() { + return using((arena) { + final realmString = lib.realm_dart_decimal128_to_string(_value); + return ascii.decode(realmString.data.cast().asTypedList(realmString.size)); + }); + } + + @override + int compareTo(Decimal128 other) { + if (this < other) { + return -1; + } else if (this == other) { + return 0; + } else { + return 1; + } + } +} diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart new file mode 100644 index 000000000..4ad5c30ff --- /dev/null +++ b/test/decimal128_test.dart @@ -0,0 +1,163 @@ +//////////////////////////////////////////////////////////////////////////////// +// +// Copyright 2023 Realm Inc. +// +// 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. +// +//////////////////////////////////////////////////////////////////////////////// + +import 'dart:math'; + +import 'package:meta/meta.dart'; +import 'package:realm_dart/src/decimal128.dart'; +import 'package:test/test.dart'; +import 'package:realm_dart/src/native/realm_core.dart'; +import 'dart:io'; + +const int defaultTimes = 100000; + +@isTest +void repeat(dynamic Function() body, [int times = defaultTimes]) { + for (var i = 0; i < times; ++i) { + body(); + } +} + +void repeatTest(String description, dynamic Function(Decimal128 x, int xInt, Decimal128 y, int yInt) body, [int times = defaultTimes]) { + final r = Random(42); + test('$description ($times variations)', () { + repeat( + () { + var xInt = r.nextInt(1 << 31); // 2^31 ensures multiplication doesn't overflow + final x = Decimal128.fromInt(xInt); + var yInt = r.nextInt(1 << 31); + final y = Decimal128.fromInt(yInt); + + body(x, xInt, y, yInt); + }, + times, + ); + }); +} + +Future main([List? args]) async { + realmCore.nativeLibraryVersion; // ensure initialization + + test('Decimal128.nan', () { + expect(Decimal128.nan, isNot(Decimal128.nan)); + // NaN != NaN so compare as strings + expect(Decimal128.tryParse(Decimal128.nan.toString()).toString(), Decimal128.nan.toString()); + }); + + test('Decimal128.infinity', () { + expect(Decimal128.tryParse(Decimal128.infinity.toString()), Decimal128.infinity); + expect(Decimal128.infinity, Decimal128.one / Decimal128.zero); + expect(Decimal128.infinity, Decimal128.parse('+Inf')); + expect(-Decimal128.infinity, Decimal128.negativeInfinity); + expect(-Decimal128.infinity, Decimal128.parse('-Inf')); + }); + + test('Decimal128.parse throws on invalid input', () { + expect(() => Decimal128.parse(''), throwsFormatException); + expect(() => Decimal128.parse(' 1'), throwsFormatException); + expect(() => Decimal128.parse('a'), throwsFormatException); + expect(() => Decimal128.parse('1a'), throwsFormatException); + expect(() => Decimal128.parse('1.2.3'), throwsFormatException); + }); + + test('Decimal128.tryParse', () { + final inputs = { + '-5352089294466601279674461764E+87': '-5352089294466601279674461764E+87', + '-91.945E0542373228376880240736944': '-Inf', + '.60438002651113181e-0': '+60438002651113181E-17', + '100.0e-999': '+1000E-1000', + '100.0e-9999': '+0E-6176', + '855084089520e34934827269223590848': '+Inf', + 'Inf': '+Inf', + 'NaN': '+NaN', + '': null, + ' 1': null, + 'a': null, + '1a': null, + '1.2.3': null, + '1,0': null, + '1.0': '+10E-1', + }; + for (var entry in inputs.entries) { + final input = entry.key; + final result = entry.value; + expect(Decimal128.tryParse(input)?.toString(), result); + } + }); + + test('Decimal128 divide by zero', () { + expect(Decimal128.one / Decimal128.zero, Decimal128.infinity); + expect(-Decimal128.one / Decimal128.zero, -Decimal128.infinity); + expect(-Decimal128.one / Decimal128.zero, Decimal128.negativeInfinity); + }); + + repeatTest('Decimal128.compareTo + friends', (x, xInt, y, yInt) { + expect(x.compareTo(y), xInt.compareTo(yInt)); + expect(x == y, xInt == yInt); + expect(x < y, xInt < yInt); + expect(x <= y, xInt <= yInt); + expect(x > y, xInt > yInt); + expect(x >= y, xInt >= yInt); + + expect(x.compareTo(x), 0); + expect(x == x, isTrue); + expect(x < x, isFalse); + expect(x <= x, isTrue); + expect(x > x, isFalse); + expect(x >= x, isTrue); + }); + + repeatTest('Decimal128.toInt/fromInt roundtrip', (x, xInt, y, yInt) { + expect(Decimal128.fromInt(x.toInt()), x); + }); + + repeatTest('Decimal128.fromInt/toInt roundtrip', (x, xInt, y, yInt) { + expect(x.toInt(), xInt); + }); + + repeatTest('Decimal128.parse/fromString roundtrip', (x, xInt, y, yInt) { + expect(Decimal128.parse(x.toString()), x); + }); + + repeatTest('Decimal128.add', (x, xInt, y, yInt) { + expect(x + y, Decimal128.fromInt(xInt + yInt)); + }); + + repeatTest('Decimal128.subtract', (x, xInt, y, yInt) { + expect(x - y, Decimal128.fromInt(xInt - yInt)); + }); + + repeatTest('Decimal128.multiply', (x, xInt, y, yInt) { + expect(x * y, Decimal128.fromInt(xInt * yInt)); + }); + + repeatTest('Decimal128 multiply & divide', (x, xInt, y, yInt) { + expect((x * y) / x, y); + expect((x * y) / y, x); + }); + + final epsilon = Decimal128.one / Decimal128.fromInt(1 << 62); + repeatTest('Decimal128 divide', (x, xInt, y, yInt) { + expect((x / y - (Decimal128.one / (y / x))).abs(), lessThan(epsilon)); + }); + + repeatTest('Decimal128.negate', (x, xInt, y, yInt) { + expect((-x).toInt(), -xInt); + expect(-(-x), x); + }); +} From aacb9d04113b6f088096e65a537d98ad7f06d0e3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Wed, 1 Mar 2023 23:20:03 +0100 Subject: [PATCH 04/30] Add Decimal128.abs + more test --- lib/src/decimal128.dart | 2 +- test/decimal128_test.dart | 48 +++++++++++++++++++++++++++++++-------- 2 files changed, 39 insertions(+), 11 deletions(-) diff --git a/lib/src/decimal128.dart b/lib/src/decimal128.dart index 5b0a312f1..6f1a388fe 100644 --- a/lib/src/decimal128.dart +++ b/lib/src/decimal128.dart @@ -37,7 +37,7 @@ class Decimal128 extends Comparable { Decimal128._(this._value); - static final _validInput = RegExp(r'^[+-]?((\d+\.?\d*|\d*\.?\d+)([eE][+-]?\d+)?|NaN|Inf)$'); + static final _validInput = RegExp(r'^[+-]?((\d+\.?\d*|\d*\.?\d+)([eE][+-]?\d+)?|NaN|Inf(inity)?)$'); static Decimal128? tryParse(String source) { if (!_validInput.hasMatch(source)) return null; return using((arena) { diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index 4ad5c30ff..9f8a4335a 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -22,7 +22,6 @@ import 'package:meta/meta.dart'; import 'package:realm_dart/src/decimal128.dart'; import 'package:test/test.dart'; import 'package:realm_dart/src/native/realm_core.dart'; -import 'dart:io'; const int defaultTimes = 100000; @@ -34,7 +33,7 @@ void repeat(dynamic Function() body, [int times = defaultTimes]) { } void repeatTest(String description, dynamic Function(Decimal128 x, int xInt, Decimal128 y, int yInt) body, [int times = defaultTimes]) { - final r = Random(42); + final r = Random(42); // use a fixed seed to make tests deterministic test('$description ($times variations)', () { repeat( () { @@ -60,11 +59,27 @@ Future main([List? args]) async { }); test('Decimal128.infinity', () { + // Test that we mimic the behavior of Dart's double wrt. infinity + expect(double.tryParse(double.infinity.toString()), double.infinity); expect(Decimal128.tryParse(Decimal128.infinity.toString()), Decimal128.infinity); + + expect(double.infinity, 1.0 / 0.0); expect(Decimal128.infinity, Decimal128.one / Decimal128.zero); - expect(Decimal128.infinity, Decimal128.parse('+Inf')); + + expect(double.infinity, double.parse('Infinity')); + expect(Decimal128.infinity, Decimal128.parse('Infinity')); + expect(Decimal128.infinity, Decimal128.parse('Inf')); // special for Decimal128 + + expect(double.infinity, double.parse('+Infinity')); + expect(Decimal128.infinity, Decimal128.parse('+Infinity')); + expect(Decimal128.infinity, Decimal128.parse('+Inf')); // special for Decimal128 + + expect(-double.infinity, double.negativeInfinity); expect(-Decimal128.infinity, Decimal128.negativeInfinity); - expect(-Decimal128.infinity, Decimal128.parse('-Inf')); + + expect(-double.infinity, double.parse('-Infinity')); + expect(-Decimal128.infinity, Decimal128.parse('-Infinity')); + expect(-Decimal128.infinity, Decimal128.parse('-Inf')); // special for Decimal128 }); test('Decimal128.parse throws on invalid input', () { @@ -84,6 +99,9 @@ Future main([List? args]) async { '100.0e-9999': '+0E-6176', '855084089520e34934827269223590848': '+Inf', 'Inf': '+Inf', + 'Infinity': '+Inf', + '+Infinity': '+Inf', + '-Infinity': '-Inf', 'NaN': '+NaN', '': null, ' 1': null, @@ -101,12 +119,18 @@ Future main([List? args]) async { }); test('Decimal128 divide by zero', () { + // Test that we mimic the behavior of Dart's double when dividing by zero + expect(1.0 / 0.0, double.infinity); expect(Decimal128.one / Decimal128.zero, Decimal128.infinity); + + expect(-1.0 / 0.0, -double.infinity); expect(-Decimal128.one / Decimal128.zero, -Decimal128.infinity); + + expect(-1.0 / 0.0, double.negativeInfinity); expect(-Decimal128.one / Decimal128.zero, Decimal128.negativeInfinity); }); - repeatTest('Decimal128.compareTo + friends', (x, xInt, y, yInt) { + repeatTest('Decimal128.compareTo + <, <=, ==, !=, >=, >', (x, xInt, y, yInt) { expect(x.compareTo(y), xInt.compareTo(yInt)); expect(x == y, xInt == yInt); expect(x < y, xInt < yInt); @@ -130,19 +154,19 @@ Future main([List? args]) async { expect(x.toInt(), xInt); }); - repeatTest('Decimal128.parse/fromString roundtrip', (x, xInt, y, yInt) { + repeatTest('Decimal128.toString/parse roundtrip', (x, xInt, y, yInt) { expect(Decimal128.parse(x.toString()), x); }); - repeatTest('Decimal128.add', (x, xInt, y, yInt) { + repeatTest('Decimal128 add', (x, xInt, y, yInt) { expect(x + y, Decimal128.fromInt(xInt + yInt)); }); - repeatTest('Decimal128.subtract', (x, xInt, y, yInt) { + repeatTest('Decimal128 subtract', (x, xInt, y, yInt) { expect(x - y, Decimal128.fromInt(xInt - yInt)); }); - repeatTest('Decimal128.multiply', (x, xInt, y, yInt) { + repeatTest('Decimal128 multiply', (x, xInt, y, yInt) { expect(x * y, Decimal128.fromInt(xInt * yInt)); }); @@ -156,8 +180,12 @@ Future main([List? args]) async { expect((x / y - (Decimal128.one / (y / x))).abs(), lessThan(epsilon)); }); - repeatTest('Decimal128.negate', (x, xInt, y, yInt) { + repeatTest('Decimal128 negate', (x, xInt, y, yInt) { expect((-x).toInt(), -xInt); expect(-(-x), x); }); + + repeatTest('Decimal128.abs', (x, xInt, y, yInt) { + expect(x.abs(), (-x).abs()); + }); } From 8c11209df38e8589627e68ac703cc2f804df2767 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Wed, 1 Mar 2023 23:26:03 +0100 Subject: [PATCH 05/30] More tests --- test/decimal128_test.dart | 13 +++++++++++-- 1 file changed, 11 insertions(+), 2 deletions(-) diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index 9f8a4335a..83c312428 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -37,7 +37,8 @@ void repeatTest(String description, dynamic Function(Decimal128 x, int xInt, Dec test('$description ($times variations)', () { repeat( () { - var xInt = r.nextInt(1 << 31); // 2^31 ensures multiplication doesn't overflow + // 2^31 ensures x * y doesn't overflow + var xInt = r.nextInt(1 << 31); final x = Decimal128.fromInt(xInt); var yInt = r.nextInt(1 << 31); final y = Decimal128.fromInt(yInt); @@ -92,6 +93,7 @@ Future main([List? args]) async { test('Decimal128.tryParse', () { final inputs = { + // input -> canonical output '-5352089294466601279674461764E+87': '-5352089294466601279674461764E+87', '-91.945E0542373228376880240736944': '-Inf', '.60438002651113181e-0': '+60438002651113181E-17', @@ -131,11 +133,17 @@ Future main([List? args]) async { }); repeatTest('Decimal128.compareTo + <, <=, ==, !=, >=, >', (x, xInt, y, yInt) { + expect(x.compareTo(y), -y.compareTo(x)); expect(x.compareTo(y), xInt.compareTo(yInt)); + expect(x == y, y == x); expect(x == y, xInt == yInt); + expect(x < y, y > x); expect(x < y, xInt < yInt); + expect(x <= y, y >= x); expect(x <= y, xInt <= yInt); + expect(x > y, y < x); expect(x > y, xInt > yInt); + expect(x >= y, y <= x); expect(x >= y, xInt >= yInt); expect(x.compareTo(x), 0); @@ -186,6 +194,7 @@ Future main([List? args]) async { }); repeatTest('Decimal128.abs', (x, xInt, y, yInt) { - expect(x.abs(), (-x).abs()); + expect(x.abs(), (-x).abs()); // abs is absolute + expect(x.abs(), x.abs().abs()); // abs is idempotent }); } From 153f9a316e78a57c311de0809f1ccfbb537cb20e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Thu, 2 Mar 2023 14:39:29 +0100 Subject: [PATCH 06/30] Refactor library initialization to be independent of RealmCore --- lib/src/native/realm_core.dart | 51 +++++++++++++--------------------- lib/src/realm_object.dart | 4 +-- test/decimal128_test.dart | 28 +++++++++++-------- 3 files changed, 39 insertions(+), 44 deletions(-) diff --git a/lib/src/native/realm_core.dart b/lib/src/native/realm_core.dart index 8e6403db3..9fb4a6e38 100644 --- a/lib/src/native/realm_core.dart +++ b/lib/src/native/realm_core.dart @@ -47,11 +47,26 @@ import '../user.dart'; import '../set.dart'; import 'realm_bindings.dart'; -late RealmLibrary _realmLib; +const bugInTheSdkMessage = "This is likely a bug in the Realm SDK - please file an issue at https://github.com/realm/realm-dart/issues"; -late RealmLibrary lib = _realmLib; +final _realmLib = () { + final result = RealmLibrary(initRealm()); + nativeLibraryVersion = result.realm_dart_library_version().cast().toDartString(); + if (libraryVersion != nativeLibraryVersion) { + final additionMessage = + isFlutterPlatform ? bugInTheSdkMessage : "Did you forget to run `dart run realm_dart install` after upgrading the realm_dart package?"; + throw RealmException('Realm SDK package version does not match the native library version ($libraryVersion != $nativeLibraryVersion). $additionMessage'); + } + return result; +}(); + +// stamped into the library by the build system (see prepare-release.yml) +const libraryVersion = '1.0.3'; +late String nativeLibraryVersion; + +final lib = _realmLib; -final _RealmCore realmCore = _RealmCore(); +final realmCore = _RealmCore(); class _RealmCore { // From realm.h. Currently not exported from the shared library @@ -61,33 +76,7 @@ class _RealmCore { // ignore: unused_field static const int RLM_INVALID_OBJECT_KEY = -1; - final int encryptionKeySize = 64; - - static Object noopUserdata = Object(); - - final bugInTheSdkMessage = "This is likely a bug in the Realm SDK - please file an issue at https://github.com/realm/realm-dart/issues"; - - // Hide the RealmCore class and make it a singleton - static _RealmCore? _instance; - late final int isolateKey; - - _RealmCore._() { - final lib = initRealm(); - _realmLib = RealmLibrary(lib); - if (libraryVersion != nativeLibraryVersion) { - final additionMessage = - isFlutterPlatform ? bugInTheSdkMessage : "Did you forget to run `dart run realm_dart install` after upgrading the realm_dart package?"; - throw RealmException('Realm SDK package version does not match the native library version ($libraryVersion != $nativeLibraryVersion). $additionMessage'); - } - } - - factory _RealmCore() { - return _instance ??= _RealmCore._(); - } - - // stamped into the library by the build system (see prepare-release.yml) - static const libraryVersion = '1.0.3'; - late String nativeLibraryVersion = _realmLib.realm_dart_library_version().cast().toDartString(); + final encryptionKeySize = 64; // for debugging only. Enable in realm_dart.cpp // void invokeGC() { @@ -1697,7 +1686,7 @@ class _RealmCore { _realmLib.realm_sync_client_config_set_log_level(handle._pointer, Realm.logger.level.toInt()); final logCallback = Pointer.fromFunction)>(_logCallback); - final logCallbackUserdata = _realmLib.realm_dart_userdata_async_new(noopUserdata, logCallback.cast(), scheduler.handle._pointer); + final logCallbackUserdata = _realmLib.realm_dart_userdata_async_new(const Object(), logCallback.cast(), scheduler.handle._pointer); _realmLib.realm_sync_client_config_set_log_callback(handle._pointer, _realmLib.addresses.realm_dart_sync_client_log_callback, logCallbackUserdata.cast(), _realmLib.addresses.realm_dart_userdata_async_free); diff --git a/lib/src/realm_object.dart b/lib/src/realm_object.dart index 08fc8c94c..e983f2cf8 100644 --- a/lib/src/realm_object.dart +++ b/lib/src/realm_object.dart @@ -425,7 +425,7 @@ mixin RealmObjectBase on RealmEntity implements RealmObjectBaseMarker, Finalizab if (invocation.isGetter) { final name = _symbolRegex.firstMatch(invocation.memberName.toString())?.namedGroup("symbolName"); if (name == null) { - throw RealmError("Could not find symbol name for ${invocation.memberName}. ${realmCore.bugInTheSdkMessage}"); + throw RealmError("Could not find symbol name for ${invocation.memberName}. $bugInTheSdkMessage"); } return get(this, name); @@ -434,7 +434,7 @@ mixin RealmObjectBase on RealmEntity implements RealmObjectBaseMarker, Finalizab if (invocation.isSetter) { final name = _symbolRegex.firstMatch(invocation.memberName.toString())?.namedGroup("symbolName"); if (name == null) { - throw RealmError("Could not find symbol name for ${invocation.memberName}. ${realmCore.bugInTheSdkMessage}"); + throw RealmError("Could not find symbol name for ${invocation.memberName}. $bugInTheSdkMessage"); } return set(this, name, invocation.positionalArguments.single); diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index 83c312428..6ceae353e 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -51,8 +51,6 @@ void repeatTest(String description, dynamic Function(Decimal128 x, int xInt, Dec } Future main([List? args]) async { - realmCore.nativeLibraryVersion; // ensure initialization - test('Decimal128.nan', () { expect(Decimal128.nan, isNot(Decimal128.nan)); // NaN != NaN so compare as strings @@ -84,11 +82,17 @@ Future main([List? args]) async { }); test('Decimal128.parse throws on invalid input', () { - expect(() => Decimal128.parse(''), throwsFormatException); - expect(() => Decimal128.parse(' 1'), throwsFormatException); - expect(() => Decimal128.parse('a'), throwsFormatException); - expect(() => Decimal128.parse('1a'), throwsFormatException); - expect(() => Decimal128.parse('1.2.3'), throwsFormatException); + final inputs = [ + '', + ' 1', + 'a', + '1a', + '1.2.3', + '1,0', + ]; + for (var input in inputs) { + expect(() => Decimal128.parse(input), throwsFormatException); + } }); test('Decimal128.tryParse', () { @@ -100,11 +104,13 @@ Future main([List? args]) async { '100.0e-999': '+1000E-1000', '100.0e-9999': '+0E-6176', '855084089520e34934827269223590848': '+Inf', + 'NaN': '+NaN', 'Inf': '+Inf', 'Infinity': '+Inf', '+Infinity': '+Inf', '-Infinity': '-Inf', - 'NaN': '+NaN', + 'Infi': null, + '-Infi': null, '': null, ' 1': null, 'a': null, @@ -115,8 +121,8 @@ Future main([List? args]) async { }; for (var entry in inputs.entries) { final input = entry.key; - final result = entry.value; - expect(Decimal128.tryParse(input)?.toString(), result); + final output = entry.value; + expect(Decimal128.tryParse(input)?.toString(), output); } }); @@ -194,7 +200,7 @@ Future main([List? args]) async { }); repeatTest('Decimal128.abs', (x, xInt, y, yInt) { - expect(x.abs(), (-x).abs()); // abs is absolute + expect(x.abs(), (-x).abs()); expect(x.abs(), x.abs().abs()); // abs is idempotent }); } From 5e19d0e8c1c85b562a672070fe8f1307e51fe967 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Tue, 11 Apr 2023 11:36:03 +0200 Subject: [PATCH 07/30] Ups! --- src/realm_dart.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index 86e2c0815..0e8e17842 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -174,7 +174,7 @@ RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t x) { } RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal) { - int64_t result; + BID_SINT64 result; unsigned int flags = 0; __bid128_to_int64_int(&result, (BID_UINT128*)&decimal, &flags); return result; From b57e37fe1d3dd68896c8b4d010bfc240c0b04c06 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Tue, 11 Apr 2023 12:24:06 +0200 Subject: [PATCH 08/30] Add decimal128 test to flutter driver tests! --- flutter/realm_flutter/tests/test_driver/realm_test.dart | 2 ++ test/decimal128_test.dart | 3 +-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/flutter/realm_flutter/tests/test_driver/realm_test.dart b/flutter/realm_flutter/tests/test_driver/realm_test.dart index 87fbc55d3..8b1083766 100644 --- a/flutter/realm_flutter/tests/test_driver/realm_test.dart +++ b/flutter/realm_flutter/tests/test_driver/realm_test.dart @@ -11,6 +11,7 @@ import '../test/backlinks_test.dart' as backlinks_test; import '../test/client_reset_test.dart' as client_reset_test; import '../test/configuration_test.dart' as configuration_test; import '../test/credentials_test.dart' as credentials_test; +import '../test/decimal128_test.dart' as decimal128_test; import '../test/dynamic_realm_test.dart' as dynamic_realm_test; import '../test/embedded_test.dart' as embedded_test; import '../test/indexed_test.dart' as indexed_test; @@ -36,6 +37,7 @@ Future main(List args) async { await client_reset_test.main(args); await configuration_test.main(args); await credentials_test.main(args); + await decimal128_test.main(args); await dynamic_realm_test.main(args); await embedded_test.main(args); indexed_test.main(args); diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index 6ceae353e..6149bd3ae 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -19,9 +19,8 @@ import 'dart:math'; import 'package:meta/meta.dart'; -import 'package:realm_dart/src/decimal128.dart'; +import '../lib/src/decimal128.dart'; import 'package:test/test.dart'; -import 'package:realm_dart/src/native/realm_core.dart'; const int defaultTimes = 100000; From 906ebc7852e2164fa0f815b041c93504d2f3d389 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Tue, 11 Apr 2023 17:26:51 +0200 Subject: [PATCH 09/30] Use alignas(16) to align realm_decimal_128 on 16 bytes boundary --- ffigen/pubspec.yaml | 2 +- lib/src/native/realm_bindings.dart | 158 +++++++++++++++++------------ src/realm-core | 2 +- 3 files changed, 96 insertions(+), 66 deletions(-) diff --git a/ffigen/pubspec.yaml b/ffigen/pubspec.yaml index d0641f8cd..9a18ea153 100644 --- a/ffigen/pubspec.yaml +++ b/ffigen/pubspec.yaml @@ -8,4 +8,4 @@ environment: sdk: ">=2.17.5 <4.0.0" dev_dependencies: - ffigen: ^6.0.1 \ No newline at end of file + ffigen: ^7.2.10 \ No newline at end of file diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index 2906799d5..e7bfdc03e 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -1,6 +1,7 @@ // AUTO GENERATED FILE, DO NOT EDIT. // // Generated by `package:ffigen`. +// ignore_for_file: type=lint import 'dart:ffi' as ffi; /// Binding for the realm-core C API @@ -10898,22 +10899,24 @@ typedef realm_app_user_apikey_t = realm_app_user_apikey; /// @param error Pointer to an error object if the operation failed, otherwise null if it completed successfully. typedef realm_app_user_completion_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer)>>; + ffi.Void Function( + ffi.Pointer userdata, + ffi.Pointer user, + ffi.Pointer error)>>; /// Generic completion callback for asynchronous Realm App operations. /// /// @param error Pointer to an error object if the operation failed, otherwise null if it completed successfully. typedef realm_app_void_completion_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, ffi.Pointer)>>; -typedef realm_async_begin_write_func_t - = ffi.Pointer)>>; + ffi.Void Function(ffi.Pointer userdata, + ffi.Pointer error)>>; +typedef realm_async_begin_write_func_t = ffi.Pointer< + ffi.NativeFunction userdata)>>; typedef realm_async_commit_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, ffi.Bool, ffi.Pointer)>>; + ffi.Void Function(ffi.Pointer userdata, ffi.Bool error, + ffi.Pointer desc)>>; class realm_async_error extends ffi.Opaque {} @@ -10934,9 +10937,9 @@ class realm_async_open_task extends ffi.Opaque {} typedef realm_async_open_task_completion_func_t = ffi.Pointer< ffi.NativeFunction< ffi.Void Function( - ffi.Pointer, - ffi.Pointer, - ffi.Pointer)>>; + ffi.Pointer userdata, + ffi.Pointer realm, + ffi.Pointer error)>>; class realm_async_open_task_progress_notification_token extends ffi.Opaque {} @@ -11040,7 +11043,8 @@ class realm_dart_userdata_async extends ffi.Opaque {} typedef realm_dart_userdata_async_t = ffi.Pointer; typedef realm_data_initialization_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer, ffi.Pointer)>>; + ffi.Bool Function( + ffi.Pointer userdata, ffi.Pointer realm)>>; class realm_decimal128 extends ffi.Struct { @ffi.Array.multi([2]) @@ -11246,8 +11250,8 @@ abstract class realm_flx_sync_subscription_set_state { typedef realm_flx_sync_subscription_set_t = realm_flx_sync_subscription_set; typedef realm_flx_sync_subscription_t = realm_flx_sync_subscription; -typedef realm_free_userdata_func_t - = ffi.Pointer)>>; +typedef realm_free_userdata_func_t = ffi.Pointer< + ffi.NativeFunction userdata)>>; class realm_http_header extends ffi.Struct { external ffi.Pointer name; @@ -11287,8 +11291,10 @@ class realm_http_request extends ffi.Struct { /// @param request_context Internal state pointer of Core, needed by realm_http_transport_complete_request(). typedef realm_http_request_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer, realm_http_request_t, - ffi.Pointer)>>; + ffi.Void Function( + ffi.Pointer userdata, + realm_http_request_t request, + ffi.Pointer request_context)>>; abstract class realm_http_request_method { static const int RLM_HTTP_REQUEST_METHOD_GET = 0; @@ -11376,8 +11382,8 @@ class realm_list extends ffi.Opaque {} typedef realm_list_t = realm_list; typedef realm_log_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, ffi.Int32, ffi.Pointer)>>; + ffi.Void Function(ffi.Pointer userdata, ffi.Int32 level, + ffi.Pointer message)>>; abstract class realm_log_level { static const int RLM_LOG_LEVEL_ALL = 0; @@ -11393,12 +11399,15 @@ abstract class realm_log_level { typedef realm_migration_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Pointer)>>; + ffi.Bool Function( + ffi.Pointer userdata, + ffi.Pointer old_realm, + ffi.Pointer new_realm, + ffi.Pointer schema)>>; typedef realm_mongodb_callback_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer, realm_string_t, - ffi.Pointer)>>; + ffi.Void Function(ffi.Pointer userdata, realm_string_t bson, + ffi.Pointer app_error)>>; class realm_mongodb_collection extends ffi.Opaque {} @@ -11463,12 +11472,12 @@ typedef realm_on_object_change_func_t = ffi.Pointer< typedef realm_on_object_store_error_callback_t = ffi.Pointer< ffi.NativeFunction< ffi.Bool Function(ffi.Pointer, ffi.Pointer)>>; -typedef realm_on_object_store_thread_callback_t - = ffi.Pointer)>>; -typedef realm_on_realm_change_func_t - = ffi.Pointer)>>; -typedef realm_on_realm_refresh_func_t - = ffi.Pointer)>>; +typedef realm_on_object_store_thread_callback_t = ffi.Pointer< + ffi.NativeFunction userdata)>>; +typedef realm_on_realm_change_func_t = ffi.Pointer< + ffi.NativeFunction userdata)>>; +typedef realm_on_realm_refresh_func_t = ffi.Pointer< + ffi.NativeFunction userdata)>>; /// Callback for realm schema changed notifications. /// @@ -11476,7 +11485,8 @@ typedef realm_on_realm_refresh_func_t /// Preserve it with realm_clone() if you wish to keep it around for longer. typedef realm_on_schema_change_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer, ffi.Pointer)>>; + ffi.Void Function(ffi.Pointer userdata, + ffi.Pointer new_schema)>>; abstract class realm_property_flags { static const int RLM_PROPERTY_NORMAL = 0; @@ -11569,18 +11579,20 @@ typedef realm_return_string_func_t = ffi.Pointer< class realm_scheduler extends ffi.Opaque {} -typedef realm_scheduler_can_deliver_notifications_func_t - = ffi.Pointer)>>; +typedef realm_scheduler_can_deliver_notifications_func_t = ffi.Pointer< + ffi.NativeFunction userdata)>>; typedef realm_scheduler_default_factory_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Pointer Function(ffi.Pointer)>>; -typedef realm_scheduler_is_on_thread_func_t - = ffi.Pointer)>>; + ffi.Pointer Function( + ffi.Pointer userdata)>>; +typedef realm_scheduler_is_on_thread_func_t = ffi.Pointer< + ffi.NativeFunction userdata)>>; typedef realm_scheduler_is_same_as_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer, ffi.Pointer)>>; -typedef realm_scheduler_notify_func_t - = ffi.Pointer)>>; + ffi.Bool Function(ffi.Pointer scheduler_userdata_1, + ffi.Pointer scheduler_userdata_2)>>; +typedef realm_scheduler_notify_func_t = ffi.Pointer< + ffi.NativeFunction userdata)>>; typedef realm_scheduler_t = realm_scheduler; class realm_schema extends ffi.Opaque {} @@ -11610,7 +11622,8 @@ class realm_set extends ffi.Opaque {} typedef realm_set_t = realm_set; typedef realm_should_compact_on_launch_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer, ffi.Uint64, ffi.Uint64)>>; + ffi.Bool Function(ffi.Pointer userdata, + ffi.Uint64 total_bytes, ffi.Uint64 used_bytes)>>; /// Represents a view over a UTF-8 string buffer. The buffer is unowned by this struct. /// @@ -11642,11 +11655,15 @@ class realm_string extends ffi.Struct { typedef realm_string_t = realm_string; typedef realm_sync_after_client_reset_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer, ffi.Pointer, - ffi.Pointer, ffi.Bool)>>; + ffi.Bool Function( + ffi.Pointer userdata, + ffi.Pointer before_realm, + ffi.Pointer after_realm, + ffi.Bool did_recover)>>; typedef realm_sync_before_client_reset_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer, ffi.Pointer)>>; + ffi.Bool Function(ffi.Pointer userdata, + ffi.Pointer before_realm)>>; class realm_sync_client_config extends ffi.Opaque {} @@ -11675,7 +11692,8 @@ abstract class realm_sync_connection_state { typedef realm_sync_connection_state_changed_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer, ffi.Int32, ffi.Int32)>>; + ffi.Void Function(ffi.Pointer userdata, ffi.Int32 old_state, + ffi.Int32 new_state)>>; class realm_sync_error extends ffi.Struct { external realm_sync_error_code_t error_code; @@ -11773,7 +11791,8 @@ class realm_sync_error_user_info extends ffi.Struct { typedef realm_sync_error_user_info_t = realm_sync_error_user_info; typedef realm_sync_on_subscription_state_changed_t = ffi.Pointer< - ffi.NativeFunction, ffi.Int32)>>; + ffi.NativeFunction< + ffi.Void Function(ffi.Pointer userdata, ffi.Int32 state)>>; abstract class realm_sync_progress_direction { static const int RLM_SYNC_PROGRESS_DIRECTION_UPLOAD = 0; @@ -11782,7 +11801,8 @@ abstract class realm_sync_progress_direction { typedef realm_sync_progress_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer, ffi.Uint64, ffi.Uint64)>>; + ffi.Void Function(ffi.Pointer userdata, + ffi.Uint64 transferred_bytes, ffi.Uint64 total_bytes)>>; class realm_sync_session extends ffi.Opaque {} @@ -11823,42 +11843,52 @@ typedef realm_sync_socket_callback_t = realm_sync_socket_callback; typedef realm_sync_socket_connect_func_t = ffi.Pointer< ffi.NativeFunction< realm_sync_socket_websocket_t Function( - ffi.Pointer, - realm_websocket_endpoint_t, - ffi.Pointer)>>; + ffi.Pointer userdata, + realm_websocket_endpoint_t endpoint, + ffi.Pointer realm_websocket_observer)>>; typedef realm_sync_socket_create_timer_func_t = ffi.Pointer< ffi.NativeFunction< - realm_sync_socket_timer_t Function(ffi.Pointer, ffi.Uint64, - ffi.Pointer)>>; + realm_sync_socket_timer_t Function( + ffi.Pointer userdata, + ffi.Uint64 delay_ms, + ffi.Pointer realm_callback)>>; typedef realm_sync_socket_post_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, ffi.Pointer)>>; + ffi.Void Function(ffi.Pointer userdata, + ffi.Pointer realm_callback)>>; typedef realm_sync_socket_t = realm_sync_socket; typedef realm_sync_socket_timer_canceled_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer, realm_sync_socket_timer_t)>>; + ffi.Void Function(ffi.Pointer userdata, + realm_sync_socket_timer_t timer_userdata)>>; typedef realm_sync_socket_timer_free_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer, realm_sync_socket_timer_t)>>; + ffi.Void Function(ffi.Pointer userdata, + realm_sync_socket_timer_t timer_userdata)>>; typedef realm_sync_socket_timer_t = ffi.Pointer; typedef realm_sync_socket_websocket_async_write_func_t = ffi.Pointer< ffi.NativeFunction< ffi.Void Function( - ffi.Pointer, - realm_sync_socket_websocket_t, - ffi.Pointer, - ffi.Size, - ffi.Pointer)>>; + ffi.Pointer userdata, + realm_sync_socket_websocket_t websocket_userdata, + ffi.Pointer data, + ffi.Size size, + ffi.Pointer realm_callback)>>; typedef realm_sync_socket_websocket_free_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, realm_sync_socket_websocket_t)>>; + ffi.Void Function(ffi.Pointer userdata, + realm_sync_socket_websocket_t websocket_userdata)>>; typedef realm_sync_socket_websocket_t = ffi.Pointer; typedef realm_sync_ssl_verify_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer, ffi.Pointer, - ffi.Short, ffi.Pointer, ffi.Size, ffi.Int, ffi.Int)>>; + ffi.Bool Function( + ffi.Pointer userdata, + ffi.Pointer server_address, + ffi.Short server_port, + ffi.Pointer pem_data, + ffi.Size pem_size, + ffi.Int preverify_ok, + ffi.Int depth)>>; /// Callback function invoked by the sync session once it has uploaded or download /// all available changesets. See @a realm_sync_session_wait_for_upload and @@ -11869,8 +11899,8 @@ typedef realm_sync_ssl_verify_func_t = ffi.Pointer< /// @param error Null, if the operation completed successfully. typedef realm_sync_wait_for_completion_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer, ffi.Pointer)>>; + ffi.Void Function(ffi.Pointer userdata, + ffi.Pointer error)>>; typedef realm_t = shared_realm; class realm_thread_safe_reference extends ffi.Opaque {} diff --git a/src/realm-core b/src/realm-core index dd91f5f96..f4c513a3b 160000 --- a/src/realm-core +++ b/src/realm-core @@ -1 +1 @@ -Subproject commit dd91f5f967c4ae89c37e24ab2a0315c31106648f +Subproject commit f4c513a3b76fad5cd8d30a39c7165b1107348e20 From 12cbb010c705e862fae5c25bfcbfb23bb6f22d19 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Wed, 12 Apr 2023 07:38:55 +0200 Subject: [PATCH 10/30] TEST: Downgrade ffigen to 6.0.1 --- ffigen/pubspec.yaml | 2 +- lib/src/native/realm_bindings.dart | 158 ++++++++++++----------------- 2 files changed, 65 insertions(+), 95 deletions(-) diff --git a/ffigen/pubspec.yaml b/ffigen/pubspec.yaml index 9a18ea153..d0641f8cd 100644 --- a/ffigen/pubspec.yaml +++ b/ffigen/pubspec.yaml @@ -8,4 +8,4 @@ environment: sdk: ">=2.17.5 <4.0.0" dev_dependencies: - ffigen: ^7.2.10 \ No newline at end of file + ffigen: ^6.0.1 \ No newline at end of file diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index e7bfdc03e..2906799d5 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -1,7 +1,6 @@ // AUTO GENERATED FILE, DO NOT EDIT. // // Generated by `package:ffigen`. -// ignore_for_file: type=lint import 'dart:ffi' as ffi; /// Binding for the realm-core C API @@ -10899,24 +10898,22 @@ typedef realm_app_user_apikey_t = realm_app_user_apikey; /// @param error Pointer to an error object if the operation failed, otherwise null if it completed successfully. typedef realm_app_user_completion_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer userdata, - ffi.Pointer user, - ffi.Pointer error)>>; + ffi.Void Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer)>>; /// Generic completion callback for asynchronous Realm App operations. /// /// @param error Pointer to an error object if the operation failed, otherwise null if it completed successfully. typedef realm_app_void_completion_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, - ffi.Pointer error)>>; -typedef realm_async_begin_write_func_t = ffi.Pointer< - ffi.NativeFunction userdata)>>; + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>>; +typedef realm_async_begin_write_func_t + = ffi.Pointer)>>; typedef realm_async_commit_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, ffi.Bool error, - ffi.Pointer desc)>>; + ffi.Void Function( + ffi.Pointer, ffi.Bool, ffi.Pointer)>>; class realm_async_error extends ffi.Opaque {} @@ -10937,9 +10934,9 @@ class realm_async_open_task extends ffi.Opaque {} typedef realm_async_open_task_completion_func_t = ffi.Pointer< ffi.NativeFunction< ffi.Void Function( - ffi.Pointer userdata, - ffi.Pointer realm, - ffi.Pointer error)>>; + ffi.Pointer, + ffi.Pointer, + ffi.Pointer)>>; class realm_async_open_task_progress_notification_token extends ffi.Opaque {} @@ -11043,8 +11040,7 @@ class realm_dart_userdata_async extends ffi.Opaque {} typedef realm_dart_userdata_async_t = ffi.Pointer; typedef realm_data_initialization_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function( - ffi.Pointer userdata, ffi.Pointer realm)>>; + ffi.Bool Function(ffi.Pointer, ffi.Pointer)>>; class realm_decimal128 extends ffi.Struct { @ffi.Array.multi([2]) @@ -11250,8 +11246,8 @@ abstract class realm_flx_sync_subscription_set_state { typedef realm_flx_sync_subscription_set_t = realm_flx_sync_subscription_set; typedef realm_flx_sync_subscription_t = realm_flx_sync_subscription; -typedef realm_free_userdata_func_t = ffi.Pointer< - ffi.NativeFunction userdata)>>; +typedef realm_free_userdata_func_t + = ffi.Pointer)>>; class realm_http_header extends ffi.Struct { external ffi.Pointer name; @@ -11291,10 +11287,8 @@ class realm_http_request extends ffi.Struct { /// @param request_context Internal state pointer of Core, needed by realm_http_transport_complete_request(). typedef realm_http_request_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function( - ffi.Pointer userdata, - realm_http_request_t request, - ffi.Pointer request_context)>>; + ffi.Void Function(ffi.Pointer, realm_http_request_t, + ffi.Pointer)>>; abstract class realm_http_request_method { static const int RLM_HTTP_REQUEST_METHOD_GET = 0; @@ -11382,8 +11376,8 @@ class realm_list extends ffi.Opaque {} typedef realm_list_t = realm_list; typedef realm_log_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, ffi.Int32 level, - ffi.Pointer message)>>; + ffi.Void Function( + ffi.Pointer, ffi.Int32, ffi.Pointer)>>; abstract class realm_log_level { static const int RLM_LOG_LEVEL_ALL = 0; @@ -11399,15 +11393,12 @@ abstract class realm_log_level { typedef realm_migration_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function( - ffi.Pointer userdata, - ffi.Pointer old_realm, - ffi.Pointer new_realm, - ffi.Pointer schema)>>; + ffi.Bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Pointer)>>; typedef realm_mongodb_callback_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, realm_string_t bson, - ffi.Pointer app_error)>>; + ffi.Void Function(ffi.Pointer, realm_string_t, + ffi.Pointer)>>; class realm_mongodb_collection extends ffi.Opaque {} @@ -11472,12 +11463,12 @@ typedef realm_on_object_change_func_t = ffi.Pointer< typedef realm_on_object_store_error_callback_t = ffi.Pointer< ffi.NativeFunction< ffi.Bool Function(ffi.Pointer, ffi.Pointer)>>; -typedef realm_on_object_store_thread_callback_t = ffi.Pointer< - ffi.NativeFunction userdata)>>; -typedef realm_on_realm_change_func_t = ffi.Pointer< - ffi.NativeFunction userdata)>>; -typedef realm_on_realm_refresh_func_t = ffi.Pointer< - ffi.NativeFunction userdata)>>; +typedef realm_on_object_store_thread_callback_t + = ffi.Pointer)>>; +typedef realm_on_realm_change_func_t + = ffi.Pointer)>>; +typedef realm_on_realm_refresh_func_t + = ffi.Pointer)>>; /// Callback for realm schema changed notifications. /// @@ -11485,8 +11476,7 @@ typedef realm_on_realm_refresh_func_t = ffi.Pointer< /// Preserve it with realm_clone() if you wish to keep it around for longer. typedef realm_on_schema_change_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, - ffi.Pointer new_schema)>>; + ffi.Void Function(ffi.Pointer, ffi.Pointer)>>; abstract class realm_property_flags { static const int RLM_PROPERTY_NORMAL = 0; @@ -11579,20 +11569,18 @@ typedef realm_return_string_func_t = ffi.Pointer< class realm_scheduler extends ffi.Opaque {} -typedef realm_scheduler_can_deliver_notifications_func_t = ffi.Pointer< - ffi.NativeFunction userdata)>>; +typedef realm_scheduler_can_deliver_notifications_func_t + = ffi.Pointer)>>; typedef realm_scheduler_default_factory_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Pointer Function( - ffi.Pointer userdata)>>; -typedef realm_scheduler_is_on_thread_func_t = ffi.Pointer< - ffi.NativeFunction userdata)>>; + ffi.Pointer Function(ffi.Pointer)>>; +typedef realm_scheduler_is_on_thread_func_t + = ffi.Pointer)>>; typedef realm_scheduler_is_same_as_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer scheduler_userdata_1, - ffi.Pointer scheduler_userdata_2)>>; -typedef realm_scheduler_notify_func_t = ffi.Pointer< - ffi.NativeFunction userdata)>>; + ffi.Bool Function(ffi.Pointer, ffi.Pointer)>>; +typedef realm_scheduler_notify_func_t + = ffi.Pointer)>>; typedef realm_scheduler_t = realm_scheduler; class realm_schema extends ffi.Opaque {} @@ -11622,8 +11610,7 @@ class realm_set extends ffi.Opaque {} typedef realm_set_t = realm_set; typedef realm_should_compact_on_launch_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer userdata, - ffi.Uint64 total_bytes, ffi.Uint64 used_bytes)>>; + ffi.Bool Function(ffi.Pointer, ffi.Uint64, ffi.Uint64)>>; /// Represents a view over a UTF-8 string buffer. The buffer is unowned by this struct. /// @@ -11655,15 +11642,11 @@ class realm_string extends ffi.Struct { typedef realm_string_t = realm_string; typedef realm_sync_after_client_reset_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function( - ffi.Pointer userdata, - ffi.Pointer before_realm, - ffi.Pointer after_realm, - ffi.Bool did_recover)>>; + ffi.Bool Function(ffi.Pointer, ffi.Pointer, + ffi.Pointer, ffi.Bool)>>; typedef realm_sync_before_client_reset_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function(ffi.Pointer userdata, - ffi.Pointer before_realm)>>; + ffi.Bool Function(ffi.Pointer, ffi.Pointer)>>; class realm_sync_client_config extends ffi.Opaque {} @@ -11692,8 +11675,7 @@ abstract class realm_sync_connection_state { typedef realm_sync_connection_state_changed_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, ffi.Int32 old_state, - ffi.Int32 new_state)>>; + ffi.Void Function(ffi.Pointer, ffi.Int32, ffi.Int32)>>; class realm_sync_error extends ffi.Struct { external realm_sync_error_code_t error_code; @@ -11791,8 +11773,7 @@ class realm_sync_error_user_info extends ffi.Struct { typedef realm_sync_error_user_info_t = realm_sync_error_user_info; typedef realm_sync_on_subscription_state_changed_t = ffi.Pointer< - ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, ffi.Int32 state)>>; + ffi.NativeFunction, ffi.Int32)>>; abstract class realm_sync_progress_direction { static const int RLM_SYNC_PROGRESS_DIRECTION_UPLOAD = 0; @@ -11801,8 +11782,7 @@ abstract class realm_sync_progress_direction { typedef realm_sync_progress_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, - ffi.Uint64 transferred_bytes, ffi.Uint64 total_bytes)>>; + ffi.Void Function(ffi.Pointer, ffi.Uint64, ffi.Uint64)>>; class realm_sync_session extends ffi.Opaque {} @@ -11843,52 +11823,42 @@ typedef realm_sync_socket_callback_t = realm_sync_socket_callback; typedef realm_sync_socket_connect_func_t = ffi.Pointer< ffi.NativeFunction< realm_sync_socket_websocket_t Function( - ffi.Pointer userdata, - realm_websocket_endpoint_t endpoint, - ffi.Pointer realm_websocket_observer)>>; + ffi.Pointer, + realm_websocket_endpoint_t, + ffi.Pointer)>>; typedef realm_sync_socket_create_timer_func_t = ffi.Pointer< ffi.NativeFunction< - realm_sync_socket_timer_t Function( - ffi.Pointer userdata, - ffi.Uint64 delay_ms, - ffi.Pointer realm_callback)>>; + realm_sync_socket_timer_t Function(ffi.Pointer, ffi.Uint64, + ffi.Pointer)>>; typedef realm_sync_socket_post_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, - ffi.Pointer realm_callback)>>; + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>>; typedef realm_sync_socket_t = realm_sync_socket; typedef realm_sync_socket_timer_canceled_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, - realm_sync_socket_timer_t timer_userdata)>>; + ffi.Void Function(ffi.Pointer, realm_sync_socket_timer_t)>>; typedef realm_sync_socket_timer_free_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, - realm_sync_socket_timer_t timer_userdata)>>; + ffi.Void Function(ffi.Pointer, realm_sync_socket_timer_t)>>; typedef realm_sync_socket_timer_t = ffi.Pointer; typedef realm_sync_socket_websocket_async_write_func_t = ffi.Pointer< ffi.NativeFunction< ffi.Void Function( - ffi.Pointer userdata, - realm_sync_socket_websocket_t websocket_userdata, - ffi.Pointer data, - ffi.Size size, - ffi.Pointer realm_callback)>>; + ffi.Pointer, + realm_sync_socket_websocket_t, + ffi.Pointer, + ffi.Size, + ffi.Pointer)>>; typedef realm_sync_socket_websocket_free_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, - realm_sync_socket_websocket_t websocket_userdata)>>; + ffi.Void Function( + ffi.Pointer, realm_sync_socket_websocket_t)>>; typedef realm_sync_socket_websocket_t = ffi.Pointer; typedef realm_sync_ssl_verify_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Bool Function( - ffi.Pointer userdata, - ffi.Pointer server_address, - ffi.Short server_port, - ffi.Pointer pem_data, - ffi.Size pem_size, - ffi.Int preverify_ok, - ffi.Int depth)>>; + ffi.Bool Function(ffi.Pointer, ffi.Pointer, + ffi.Short, ffi.Pointer, ffi.Size, ffi.Int, ffi.Int)>>; /// Callback function invoked by the sync session once it has uploaded or download /// all available changesets. See @a realm_sync_session_wait_for_upload and @@ -11899,8 +11869,8 @@ typedef realm_sync_ssl_verify_func_t = ffi.Pointer< /// @param error Null, if the operation completed successfully. typedef realm_sync_wait_for_completion_func_t = ffi.Pointer< ffi.NativeFunction< - ffi.Void Function(ffi.Pointer userdata, - ffi.Pointer error)>>; + ffi.Void Function( + ffi.Pointer, ffi.Pointer)>>; typedef realm_t = shared_realm; class realm_thread_safe_reference extends ffi.Opaque {} From b2a0a51c3620a20c8c2c86e63b703d29c7ff4e84 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Wed, 12 Apr 2023 08:15:32 +0200 Subject: [PATCH 11/30] Remove stale bid_* links --- ffigen/bid_conf.h | 1 - ffigen/bid_functions.h | 1 - 2 files changed, 2 deletions(-) delete mode 120000 ffigen/bid_conf.h delete mode 120000 ffigen/bid_functions.h diff --git a/ffigen/bid_conf.h b/ffigen/bid_conf.h deleted file mode 120000 index b51b75a7c..000000000 --- a/ffigen/bid_conf.h +++ /dev/null @@ -1 +0,0 @@ -../src/realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_conf.h \ No newline at end of file diff --git a/ffigen/bid_functions.h b/ffigen/bid_functions.h deleted file mode 120000 index f61333500..000000000 --- a/ffigen/bid_functions.h +++ /dev/null @@ -1 +0,0 @@ -../src/realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_functions.h \ No newline at end of file From aa71309c8a76453580f6d2438b6bb7147253b84b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Fri, 14 Apr 2023 07:53:11 +0200 Subject: [PATCH 12/30] Sidestep alingment issues by using to_capi/from_capu and copy shit around --- lib/src/decimal128.dart | 2 +- lib/src/native/realm_bindings.dart | 12 ++++++ src/realm-core | 2 +- src/realm_dart.cpp | 64 ++++++++++-------------------- src/realm_dart.h | 1 + test/decimal128_test.dart | 2 +- 6 files changed, 37 insertions(+), 46 deletions(-) diff --git a/lib/src/decimal128.dart b/lib/src/decimal128.dart index 6f1a388fe..2d809b339 100644 --- a/lib/src/decimal128.dart +++ b/lib/src/decimal128.dart @@ -29,7 +29,7 @@ class Decimal128 extends Comparable { static final one = Decimal128.fromInt(1); static final ten = Decimal128.fromInt(10); - static final nan = Decimal128.parse('+NaN'); + static late final nan = Decimal128._(lib.realm_dart_decimal128_nan()); static final infinity = one / zero; // +Inf static final negativeInfinity = -infinity; diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index 2906799d5..0fcc83925 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -3323,6 +3323,16 @@ class RealmLibrary { realm_decimal128_t Function( realm_decimal128_t, realm_decimal128_t)>(); + realm_decimal128_t realm_dart_decimal128_nan() { + return _realm_dart_decimal128_nan(); + } + + late final _realm_dart_decimal128_nanPtr = + _lookup>( + 'realm_dart_decimal128_nan'); + late final _realm_dart_decimal128_nan = + _realm_dart_decimal128_nanPtr.asFunction(); + realm_decimal128_t realm_dart_decimal128_subtract( realm_decimal128_t x, realm_decimal128_t y, @@ -10696,6 +10706,8 @@ class _SymbolAddresses { realm_decimal128_t, realm_decimal128_t)>> get realm_dart_decimal128_multiply => _library._realm_dart_decimal128_multiplyPtr; + ffi.Pointer> + get realm_dart_decimal128_nan => _library._realm_dart_decimal128_nanPtr; ffi.Pointer< ffi.NativeFunction< realm_decimal128_t Function( diff --git a/src/realm-core b/src/realm-core index f4c513a3b..ea4c7cd83 160000 --- a/src/realm-core +++ b/src/realm-core @@ -1 +1 @@ -Subproject commit f4c513a3b76fad5cd8d30a39c7165b1107348e20 +Subproject commit ea4c7cd832448c2d41dd6d8711d87a577af2bac7 diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index 0e8e17842..2a125fd8d 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -25,6 +25,8 @@ #include "realm_dart.hpp" #include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_conf.h" #include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_functions.h" +#include "realm-core/src/realm/object-store/c_api/conversion.hpp" +#include "realm-core/src/realm/decimal128.hpp" #if REALM_ARCHITECTURE_ARM32 || REALM_ARCHITECTURE_ARM64 || REALM_ARCHITECTURE_X86_32 || REALM_ARCHITECTURE_X86_64 #if REALM_ARCHITECTURE_ARM32 @@ -55,6 +57,9 @@ RLM_API void realm_dart_initializeDartApiDL(void* data) { Dart_InitializeApiDL(data); } +using namespace realm; +using namespace realm::c_api; + class WeakHandle { public: WeakHandle(Dart_Handle handle) : m_weakHandle(Dart_NewWeakPersistentHandle_DL(handle, this, 1, finalize_handle)) { @@ -152,13 +157,11 @@ RLM_API const char* realm_get_library_cpu_arch() { } RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string) { - realm_decimal128_t result; - unsigned int flags = 0; - __bid128_from_string((BID_UINT128*)&result, const_cast(string), &flags); - return result; + return to_capi(Decimal128(string)); } RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x) { + auto s = from_capi(x).to_string(); // This buffer is reused between calls, hence the static keyword static char buffer[34]; // 34 bytes is the maximum length of a string representation of a decimal128 unsigned int flags = 0; @@ -166,69 +169,44 @@ RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x) { return realm_string_t{buffer, strlen(buffer)}; } +RLM_API realm_decimal128_t realm_dart_decimal128_nan() { + return to_capi(Decimal128::nan("+NaN")); +} + RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t x) { - realm_decimal128_t decimal; - unsigned int flags = 0; - __bid128_from_int64((BID_UINT128*)&decimal, (BID_SINT64*)&x); - return decimal; + return to_capi(Decimal128(x)); } RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal) { - BID_SINT64 result; - unsigned int flags = 0; - __bid128_to_int64_int(&result, (BID_UINT128*)&decimal, &flags); + int64_t result; + from_capi(decimal).to_int(result); return result; } RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y) { - realm_decimal128_t result; - unsigned int flags = 0; - __bid128_add((BID_UINT128*)&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); - return result; + return to_capi(from_capi(x) + from_capi(y)); } RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y) { - realm_decimal128_t result; - unsigned int flags = 0; - __bid128_sub((BID_UINT128*)&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); - return result; + return to_capi(from_capi(x) - from_capi(y)); } RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y) { - realm_decimal128_t result; - unsigned int flags = 0; - __bid128_mul((BID_UINT128*)&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); - return result; + return to_capi(from_capi(x) * from_capi(y)); } RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, realm_decimal128_t y) { - realm_decimal128_t result; - unsigned int flags = 0; - __bid128_div((BID_UINT128*)&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); - return result; + return to_capi(from_capi(x) / from_capi(y)); } RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y) { - int result; - unsigned int flags = 0; - __bid128_quiet_equal(&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); - return result == 1; + return from_capi(x) == from_capi(y); } RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y) { - int result; - unsigned int flags = 0; - __bid128_quiet_less(&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); - return result == 1; + return from_capi(x) < from_capi(y); } RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y) { - int result; - unsigned int flags = 0; - __bid128_quiet_greater(&result, (BID_UINT128*)&x, (BID_UINT128*)&y, &flags); - return result == 1; + return from_capi(x) > from_capi(y); } - - - - diff --git a/src/realm_dart.h b/src/realm_dart.h index 351521aa9..c5dede77d 100644 --- a/src/realm_dart.h +++ b/src/realm_dart.h @@ -57,6 +57,7 @@ RLM_API void realm_set_auto_refresh(realm_t* realm, bool enable); RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string); RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x); +RLM_API realm_decimal128_t realm_dart_decimal128_nan(); RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t low); RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal); RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y); diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index 6149bd3ae..917e0d648 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -54,7 +54,7 @@ Future main([List? args]) async { expect(Decimal128.nan, isNot(Decimal128.nan)); // NaN != NaN so compare as strings expect(Decimal128.tryParse(Decimal128.nan.toString()).toString(), Decimal128.nan.toString()); - }); + }, skip: 'Realm redefines equality for NaN?!'); test('Decimal128.infinity', () { // Test that we mimic the behavior of Dart's double wrt. infinity From 8c847a6d2eb776194b9c8bbeaf0621ce52ee7536 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Fri, 14 Apr 2023 07:54:30 +0200 Subject: [PATCH 13/30] Use plain v13.6.0 again --- src/realm-core | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/realm-core b/src/realm-core index ea4c7cd83..dd91f5f96 160000 --- a/src/realm-core +++ b/src/realm-core @@ -1 +1 @@ -Subproject commit ea4c7cd832448c2d41dd6d8711d87a577af2bac7 +Subproject commit dd91f5f967c4ae89c37e24ab2a0315c31106648f From 871c503814f5c4e7dd5f50ee2628b845dde214f5 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Fri, 14 Apr 2023 09:07:23 +0200 Subject: [PATCH 14/30] Update CHANGELOG --- CHANGELOG.md | 1 + 1 file changed, 1 insertion(+) diff --git a/CHANGELOG.md b/CHANGELOG.md index a12064eb6..5148e2194 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,6 +20,7 @@ * Added `SyncWebSocketError` and `SyncWebSocketErrorCode` for web socket connection sync errors ([#1182](https://github.com/realm/realm-dart/pull/1182)). * Added `FlexibleSyncConfiguration.shouldCompactCallback` support ([#1204](https://github.com/realm/realm-dart/pull/1204)). * Added `RealmSet.asResults()` ([#1214](https://github.com/realm/realm-dart/pull/1214)). +* Support `Decimal128` datatype ([#1192](https://github.com/realm/realm-dart/pull/1192)). ### Fixed * You may have a crash on Windows if you try to open a file with non-ASCII path (Core upgrade). From c9ef6390e2c86a4215d7b26202f4e81086d49a99 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Fri, 14 Apr 2023 09:28:05 +0200 Subject: [PATCH 15/30] Update doc comments --- lib/src/decimal128.dart | 34 +++++++++++++++++++++++++++++++++- 1 file changed, 33 insertions(+), 1 deletion(-) diff --git a/lib/src/decimal128.dart b/lib/src/decimal128.dart index 2d809b339..fb777f26b 100644 --- a/lib/src/decimal128.dart +++ b/lib/src/decimal128.dart @@ -24,13 +24,24 @@ import 'package:ffi/ffi.dart'; import 'native/realm_bindings.dart'; import 'native/realm_core.dart'; +/// A 128-bit decimal floating point number. class Decimal128 extends Comparable { + /// The value 0. static final zero = Decimal128.fromInt(0); + + /// The value 1. static final one = Decimal128.fromInt(1); + + /// The value 10. static final ten = Decimal128.fromInt(10); - static late final nan = Decimal128._(lib.realm_dart_decimal128_nan()); + /// The value NaN. + static final nan = Decimal128._(lib.realm_dart_decimal128_nan()); + + /// The value +Inf. static final infinity = one / zero; // +Inf + + /// The value -Inf. static final negativeInfinity = -infinity; final realm_decimal128_t _value; @@ -38,6 +49,8 @@ class Decimal128 extends Comparable { Decimal128._(this._value); static final _validInput = RegExp(r'^[+-]?((\d+\.?\d*|\d*\.?\d+)([eE][+-]?\d+)?|NaN|Inf(inity)?)$'); + + /// Parses a string into a [Decimal128]. Returns `null` if the string is not a valid [Decimal128]. static Decimal128? tryParse(String source) { if (!_validInput.hasMatch(source)) return null; return using((arena) { @@ -46,38 +59,48 @@ class Decimal128 extends Comparable { }); } + /// Parses a string into a [Decimal128]. Throws a [FormatException] if the string is not a valid [Decimal128]. factory Decimal128.parse(String source) { return tryParse(source) ?? (throw FormatException('Invalid Decimal128', source)); } + /// Converts a `int` into a [Decimal128]. factory Decimal128.fromInt(int value) { return Decimal128._(lib.realm_dart_decimal128_from_int64(value)); } + /// Converts a `double` into a [Decimal128]. factory Decimal128.fromDouble(double value) { return Decimal128.parse(value.toString()); // TODO(kn): Find a way to optimize this } + /// Adds `this` with `other` and returns a new [Decimal128]. Decimal128 operator +(Decimal128 other) { return Decimal128._(lib.realm_dart_decimal128_add(_value, other._value)); } + /// Subtracts `other` from `this` and returns a new [Decimal128]. Decimal128 operator -(Decimal128 other) { return Decimal128._(lib.realm_dart_decimal128_subtract(_value, other._value)); } + /// Multiplies `this` with `other` and returns a new [Decimal128]. Decimal128 operator *(Decimal128 other) { return Decimal128._(lib.realm_dart_decimal128_multiply(_value, other._value)); } + /// Divides `this` by `other` and returns a new [Decimal128]. Decimal128 operator /(Decimal128 other) { return Decimal128._(lib.realm_dart_decimal128_divide(_value, other._value)); } + /// Negates `this` and returns a new [Decimal128]. Decimal128 operator -() => zero - this; + /// Returns the absolute value of `this`. Decimal128 abs() => this < zero ? -this : this; + /// Returns `true` if `this` and `other` are equal. @override // ignore: hash_and_equals operator ==(Object other) { @@ -89,20 +112,26 @@ class Decimal128 extends Comparable { return false; } + /// Returns `true` if `this` is less than `other`. bool operator <(Decimal128 other) { return lib.realm_dart_decimal128_less_than(_value, other._value); } + /// Returns `true` if `this` is less than or equal to `other`. bool operator <=(Decimal128 other) => compareTo(other) <= 0; + /// Returns `true` if `this` is greater than `other`. bool operator >(Decimal128 other) { return lib.realm_dart_decimal128_greater_than(_value, other._value); } + /// Returns `true` if `this` is greater than or equal to `other`. bool operator >=(Decimal128 other) => compareTo(other) >= 0; + /// Converts `this` to an `int`. Possibly loosing precision. int toInt() => lib.realm_dart_decimal128_to_int64(_value); + /// String representation of `this`. @override String toString() { return using((arena) { @@ -111,6 +140,9 @@ class Decimal128 extends Comparable { }); } + /// Compares `this` to `other`. + /// Note that comparisons of `nan` values are stable, unlike IEEE754. + /// In particular, `nan == nan` is `true`. @override int compareTo(Decimal128 other) { if (this < other) { From 2c121defa713e412af25bc3060c79b601d038d42 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Fri, 14 Apr 2023 12:51:50 +0200 Subject: [PATCH 16/30] Fix comparison behavior to match IEEE754 for NaN values --- lib/src/decimal128.dart | 6 +++--- src/realm_dart.cpp | 12 +++++++++--- test/decimal128_test.dart | 2 +- 3 files changed, 13 insertions(+), 7 deletions(-) diff --git a/lib/src/decimal128.dart b/lib/src/decimal128.dart index fb777f26b..a370222c4 100644 --- a/lib/src/decimal128.dart +++ b/lib/src/decimal128.dart @@ -104,7 +104,7 @@ class Decimal128 extends Comparable { @override // ignore: hash_and_equals operator ==(Object other) { - // WARNING: Don't use identical to ensure nan != nan + // WARNING: Don't use identical to ensure nan != nan, // if (identical(this, other)) return true; if (other is Decimal128) { return lib.realm_dart_decimal128_equal(_value, other._value); @@ -141,8 +141,8 @@ class Decimal128 extends Comparable { } /// Compares `this` to `other`. - /// Note that comparisons of `nan` values are stable, unlike IEEE754. - /// In particular, `nan == nan` is `true`. + /// Note that comparisons of `nan` values follow the IEEE 754 standard. + /// In particular, `nan == nan` is `false`. @override int compareTo(Decimal128 other) { if (this < other) { diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index 2a125fd8d..5e19daa49 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -200,13 +200,19 @@ RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, re } RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y) { - return from_capi(x) == from_capi(y); + auto x_decimal = from_capi(x); + auto y_decimal = from_capi(y); + return !x_decimal.is_nan() && !y_decimal.is_nan() && x_decimal == y_decimal; } RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y) { - return from_capi(x) < from_capi(y); + auto x_decimal = from_capi(x); + auto y_decimal = from_capi(y); + return !x_decimal.is_nan() && !y_decimal.is_nan() && x_decimal < y_decimal; } RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y) { - return from_capi(x) > from_capi(y); + auto x_decimal = from_capi(x); + auto y_decimal = from_capi(y); + return !x_decimal.is_nan() && !y_decimal.is_nan() && x_decimal > y_decimal; } diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index 917e0d648..6149bd3ae 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -54,7 +54,7 @@ Future main([List? args]) async { expect(Decimal128.nan, isNot(Decimal128.nan)); // NaN != NaN so compare as strings expect(Decimal128.tryParse(Decimal128.nan.toString()).toString(), Decimal128.nan.toString()); - }, skip: 'Realm redefines equality for NaN?!'); + }); test('Decimal128.infinity', () { // Test that we mimic the behavior of Dart's double wrt. infinity From 2c36b628c17cb2c1e2affec7f0c365bae9ff8c8e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Fri, 14 Apr 2023 13:06:14 +0200 Subject: [PATCH 17/30] Add Decimal128.isNaN getter --- lib/src/decimal128.dart | 3 +++ lib/src/native/realm_bindings.dart | 17 +++++++++++++++++ src/realm_dart.cpp | 4 ++++ src/realm_dart.h | 1 + test/decimal128_test.dart | 10 ++++++++++ 5 files changed, 35 insertions(+) diff --git a/lib/src/decimal128.dart b/lib/src/decimal128.dart index a370222c4..5736f4d38 100644 --- a/lib/src/decimal128.dart +++ b/lib/src/decimal128.dart @@ -74,6 +74,9 @@ class Decimal128 extends Comparable { return Decimal128.parse(value.toString()); // TODO(kn): Find a way to optimize this } + /// Returns `true` if `this` is NaN. + bool get isNaN => lib.realm_dart_decimal128_is_nan(_value); + /// Adds `this` with `other` and returns a new [Decimal128]. Decimal128 operator +(Decimal128 other) { return Decimal128._(lib.realm_dart_decimal128_add(_value, other._value)); diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index 0fcc83925..ee2a92416 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -3286,6 +3286,20 @@ class RealmLibrary { _realm_dart_decimal128_greater_thanPtr .asFunction(); + bool realm_dart_decimal128_is_nan( + realm_decimal128_t decimal, + ) { + return _realm_dart_decimal128_is_nan( + decimal, + ); + } + + late final _realm_dart_decimal128_is_nanPtr = + _lookup>( + 'realm_dart_decimal128_is_nan'); + late final _realm_dart_decimal128_is_nan = _realm_dart_decimal128_is_nanPtr + .asFunction(); + bool realm_dart_decimal128_less_than( realm_decimal128_t x, realm_decimal128_t y, @@ -10695,6 +10709,9 @@ class _SymbolAddresses { ffi.Bool Function(realm_decimal128_t, realm_decimal128_t)>> get realm_dart_decimal128_greater_than => _library._realm_dart_decimal128_greater_thanPtr; + ffi.Pointer> + get realm_dart_decimal128_is_nan => + _library._realm_dart_decimal128_is_nanPtr; ffi.Pointer< ffi.NativeFunction< ffi.Bool Function(realm_decimal128_t, realm_decimal128_t)>> diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index 5e19daa49..d566ca5a0 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -173,6 +173,10 @@ RLM_API realm_decimal128_t realm_dart_decimal128_nan() { return to_capi(Decimal128::nan("+NaN")); } +RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t decimal) { + return from_capi(decimal).is_nan(); +} + RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t x) { return to_capi(Decimal128(x)); } diff --git a/src/realm_dart.h b/src/realm_dart.h index c5dede77d..cf3896d0e 100644 --- a/src/realm_dart.h +++ b/src/realm_dart.h @@ -58,6 +58,7 @@ RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string) RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x); RLM_API realm_decimal128_t realm_dart_decimal128_nan(); +RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t decimal); RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t low); RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal); RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y); diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index 6149bd3ae..020adc7eb 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -52,6 +52,16 @@ void repeatTest(String description, dynamic Function(Decimal128 x, int xInt, Dec Future main([List? args]) async { test('Decimal128.nan', () { expect(Decimal128.nan, isNot(Decimal128.nan)); + expect(Decimal128.nan, isNot(lessThan(Decimal128.nan))); + expect(Decimal128.nan, isNot(lessThanOrEqualTo(Decimal128.nan))); + expect(Decimal128.nan, isNot(greaterThan(Decimal128.nan))); + expect(Decimal128.nan, isNot(greaterThanOrEqualTo(Decimal128.nan))); + expect(Decimal128.nan.isNaN, isTrue); + expect(Decimal128.zero.isNaN, isFalse); + expect(Decimal128.one.isNaN, isFalse); + expect(Decimal128.ten.isNaN, isFalse); + expect(Decimal128.infinity.isNaN, isFalse); + // NaN != NaN so compare as strings expect(Decimal128.tryParse(Decimal128.nan.toString()).toString(), Decimal128.nan.toString()); }); From 294cb95920791bc645944e88ed0ca5f686bc3fe2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Fri, 14 Apr 2023 14:22:13 +0200 Subject: [PATCH 18/30] Test a few more IEEE754 corners --- test/decimal128_test.dart | 12 ++++++++++++ 1 file changed, 12 insertions(+) diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index 020adc7eb..b82dc0208 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -58,6 +58,7 @@ Future main([List? args]) async { expect(Decimal128.nan, isNot(greaterThanOrEqualTo(Decimal128.nan))); expect(Decimal128.nan.isNaN, isTrue); expect(Decimal128.zero.isNaN, isFalse); + expect((Decimal128.zero / Decimal128.zero).isNaN, isTrue); expect(Decimal128.one.isNaN, isFalse); expect(Decimal128.ten.isNaN, isFalse); expect(Decimal128.infinity.isNaN, isFalse); @@ -147,6 +148,17 @@ Future main([List? args]) async { expect(-Decimal128.one / Decimal128.zero, Decimal128.negativeInfinity); }); + test('Decimal128 IEEE 754-2019 corner cases', () { + expect(double.infinity + 1, double.infinity); + expect(Decimal128.infinity + Decimal128.one, Decimal128.infinity); + + expect(double.infinity * -1, double.negativeInfinity); + expect(Decimal128.infinity * -Decimal128.one, Decimal128.negativeInfinity); + + expect((double.infinity * 0).isNaN, isTrue); + expect((Decimal128.infinity * Decimal128.zero).isNaN, isTrue); + }); + repeatTest('Decimal128.compareTo + <, <=, ==, !=, >=, >', (x, xInt, y, yInt) { expect(x.compareTo(y), -y.compareTo(x)); expect(x.compareTo(y), xInt.compareTo(yInt)); From d804480aeb546a3b0c71b202c1f07c1316040839 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Mon, 17 Apr 2023 14:37:39 +0200 Subject: [PATCH 19/30] Get ieee754 total ordering right in compareTo --- lib/src/decimal128.dart | 14 +---- lib/src/native/realm_bindings.dart | 41 +++++++++++++++ src/realm-core | 2 +- src/realm_dart.cpp | 25 ++++++--- src/realm_dart.h | 2 + test/decimal128_test.dart | 83 +++++++++++++++++++++++++++++- 6 files changed, 144 insertions(+), 23 deletions(-) diff --git a/lib/src/decimal128.dart b/lib/src/decimal128.dart index 5736f4d38..bb9541c5c 100644 --- a/lib/src/decimal128.dart +++ b/lib/src/decimal128.dart @@ -98,7 +98,7 @@ class Decimal128 extends Comparable { } /// Negates `this` and returns a new [Decimal128]. - Decimal128 operator -() => zero - this; + Decimal128 operator -() => Decimal128._(lib.realm_dart_decimal128_negate(_value)); /// Returns the absolute value of `this`. Decimal128 abs() => this < zero ? -this : this; @@ -144,16 +144,6 @@ class Decimal128 extends Comparable { } /// Compares `this` to `other`. - /// Note that comparisons of `nan` values follow the IEEE 754 standard. - /// In particular, `nan == nan` is `false`. @override - int compareTo(Decimal128 other) { - if (this < other) { - return -1; - } else if (this == other) { - return 0; - } else { - return 1; - } - } + int compareTo(Decimal128 other) => lib.realm_dart_decimal128_compare_to(_value, other._value); } diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index ee2a92416..4d54497b1 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -3201,6 +3201,24 @@ class RealmLibrary { realm_decimal128_t Function( realm_decimal128_t, realm_decimal128_t)>(); + int realm_dart_decimal128_compare_to( + realm_decimal128_t x, + realm_decimal128_t y, + ) { + return _realm_dart_decimal128_compare_to( + x, + y, + ); + } + + late final _realm_dart_decimal128_compare_toPtr = _lookup< + ffi.NativeFunction< + ffi.Int Function(realm_decimal128_t, + realm_decimal128_t)>>('realm_dart_decimal128_compare_to'); + late final _realm_dart_decimal128_compare_to = + _realm_dart_decimal128_compare_toPtr + .asFunction(); + realm_decimal128_t realm_dart_decimal128_divide( realm_decimal128_t x, realm_decimal128_t y, @@ -3347,6 +3365,20 @@ class RealmLibrary { late final _realm_dart_decimal128_nan = _realm_dart_decimal128_nanPtr.asFunction(); + realm_decimal128_t realm_dart_decimal128_negate( + realm_decimal128_t decimal, + ) { + return _realm_dart_decimal128_negate( + decimal, + ); + } + + late final _realm_dart_decimal128_negatePtr = _lookup< + ffi.NativeFunction>( + 'realm_dart_decimal128_negate'); + late final _realm_dart_decimal128_negate = _realm_dart_decimal128_negatePtr + .asFunction(); + realm_decimal128_t realm_dart_decimal128_subtract( realm_decimal128_t x, realm_decimal128_t y, @@ -10685,6 +10717,11 @@ class _SymbolAddresses { realm_decimal128_t Function( realm_decimal128_t, realm_decimal128_t)>> get realm_dart_decimal128_add => _library._realm_dart_decimal128_addPtr; + ffi.Pointer< + ffi.NativeFunction< + ffi.Int Function(realm_decimal128_t, realm_decimal128_t)>> + get realm_dart_decimal128_compare_to => + _library._realm_dart_decimal128_compare_toPtr; ffi.Pointer< ffi.NativeFunction< realm_decimal128_t Function( @@ -10725,6 +10762,10 @@ class _SymbolAddresses { _library._realm_dart_decimal128_multiplyPtr; ffi.Pointer> get realm_dart_decimal128_nan => _library._realm_dart_decimal128_nanPtr; + ffi.Pointer< + ffi.NativeFunction> + get realm_dart_decimal128_negate => + _library._realm_dart_decimal128_negatePtr; ffi.Pointer< ffi.NativeFunction< realm_decimal128_t Function( diff --git a/src/realm-core b/src/realm-core index dd91f5f96..653ef5909 160000 --- a/src/realm-core +++ b/src/realm-core @@ -1 +1 @@ -Subproject commit dd91f5f967c4ae89c37e24ab2a0315c31106648f +Subproject commit 653ef5909b0efee54d28d4567fa78a0a57162265 diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index d566ca5a0..93672a5de 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -62,7 +62,7 @@ using namespace realm::c_api; class WeakHandle { public: - WeakHandle(Dart_Handle handle) : m_weakHandle(Dart_NewWeakPersistentHandle_DL(handle, this, 1, finalize_handle)) { + WeakHandle(Dart_Handle handle): m_weakHandle(Dart_NewWeakPersistentHandle_DL(handle, this, 1, finalize_handle)) { } Dart_Handle value() { @@ -136,19 +136,19 @@ RLM_API const char* realm_dart_library_version() { return "1.0.3"; } // } void handle_finalizer(void* isolate_callback_data, void* realmPtr) { - realm_release(realmPtr); + realm_release(realmPtr); } RLM_API void* realm_attach_finalizer(Dart_Handle handle, void* realmPtr, int size) { - return Dart_NewFinalizableHandle_DL(handle, realmPtr, size, handle_finalizer); + return Dart_NewFinalizableHandle_DL(handle, realmPtr, size, handle_finalizer); } RLM_API void realm_dettach_finalizer(void* finalizableHandle, Dart_Handle handle) { - Dart_FinalizableHandle finalHandle = reinterpret_cast(finalizableHandle); - return Dart_DeleteFinalizableHandle_DL(finalHandle, handle); + Dart_FinalizableHandle finalHandle = reinterpret_cast(finalizableHandle); + return Dart_DeleteFinalizableHandle_DL(finalHandle, handle); } -RLM_API void realm_set_auto_refresh(realm_t* realm, bool enable){ +RLM_API void realm_set_auto_refresh(realm_t* realm, bool enable) { (*realm)->set_auto_refresh(enable); } @@ -166,7 +166,7 @@ RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x) { static char buffer[34]; // 34 bytes is the maximum length of a string representation of a decimal128 unsigned int flags = 0; __bid128_to_string(buffer, (BID_UINT128*)&x, &flags); - return realm_string_t{buffer, strlen(buffer)}; + return realm_string_t{ buffer, strlen(buffer) }; } RLM_API realm_decimal128_t realm_dart_decimal128_nan() { @@ -181,12 +181,16 @@ RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t x) { return to_capi(Decimal128(x)); } -RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal) { +RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal) { int64_t result; from_capi(decimal).to_int(result); return result; } +RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t decimal) { + return to_capi(-from_capi(decimal)); +} + RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y) { return to_capi(from_capi(x) + from_capi(y)); } @@ -220,3 +224,8 @@ RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_deci auto y_decimal = from_capi(y); return !x_decimal.is_nan() && !y_decimal.is_nan() && x_decimal > y_decimal; } + +RLM_API int realm_dart_decimal128_compare_to(realm_decimal128_t x, realm_decimal128_t y) { + return from_capi(x).compareTotalOrdering(from_capi(y)); +} + diff --git a/src/realm_dart.h b/src/realm_dart.h index cf3896d0e..596329f9a 100644 --- a/src/realm_dart.h +++ b/src/realm_dart.h @@ -61,6 +61,7 @@ RLM_API realm_decimal128_t realm_dart_decimal128_nan(); RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t decimal); RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t low); RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal); +RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t decimal); RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y); RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y); RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y); @@ -68,5 +69,6 @@ RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, re RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y); RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y); RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y); +RLM_API int realm_dart_decimal128_compare_to(realm_decimal128_t x, realm_decimal128_t y); #endif // REALM_DART_H \ No newline at end of file diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index b82dc0208..a62312610 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -16,6 +16,7 @@ // //////////////////////////////////////////////////////////////////////////////// +import 'dart:io'; import 'dart:math'; import 'package:meta/meta.dart'; @@ -24,13 +25,13 @@ import 'package:test/test.dart'; const int defaultTimes = 100000; -@isTest void repeat(dynamic Function() body, [int times = defaultTimes]) { for (var i = 0; i < times; ++i) { body(); } } +@isTest void repeatTest(String description, dynamic Function(Decimal128 x, int xInt, Decimal128 y, int yInt) body, [int times = defaultTimes]) { final r = Random(42); // use a fixed seed to make tests deterministic test('$description ($times variations)', () { @@ -51,11 +52,55 @@ void repeatTest(String description, dynamic Function(Decimal128 x, int xInt, Dec Future main([List? args]) async { test('Decimal128.nan', () { + // Test that we mimic the behavior of Dart's double wrt. NaN and + // <, <=, >, >=. Unlike compareTo (which define a total order) these + // operators return false for NaN. + expect(0.0, isNot(double.nan)); + expect(0.0, isNot(lessThan(double.nan))); + expect(0.0, isNot(lessThanOrEqualTo(double.nan))); + expect(0.0, isNot(greaterThan(double.nan))); + expect(0.0, isNot(greaterThanOrEqualTo(double.nan))); + + expect(double.nan, isNot(0.0)); + expect(double.nan, isNot(lessThan(0.0))); + expect(double.nan, isNot(lessThanOrEqualTo(0.0))); + expect(double.nan, isNot(greaterThan(0.0))); + expect(double.nan, isNot(greaterThanOrEqualTo(0.0))); + + expect(double.nan, isNot(double.nan)); + expect(double.nan, isNot(lessThan(double.nan))); + expect(double.nan, isNot(lessThanOrEqualTo(double.nan))); + expect(double.nan, isNot(greaterThan(double.nan))); + expect(double.nan, isNot(greaterThanOrEqualTo(double.nan))); + + expect(double.nan.isNaN, isTrue); + expect((0.0).isNaN, isFalse); + expect((0.0 / 0.0).isNaN, isTrue); + expect((1.0).isNaN, isFalse); + expect((10.0).isNaN, isFalse); + expect(double.infinity.isNaN, isFalse); + + // NaN != NaN so compare as strings + expect(Decimal128.tryParse(Decimal128.nan.toString()).toString(), Decimal128.nan.toString()); + + expect(Decimal128.zero, isNot(Decimal128.nan)); + expect(Decimal128.zero, isNot(lessThan(Decimal128.nan))); + expect(Decimal128.zero, isNot(lessThanOrEqualTo(Decimal128.nan))); + expect(Decimal128.zero, isNot(greaterThan(Decimal128.nan))); + expect(Decimal128.zero, isNot(greaterThanOrEqualTo(Decimal128.nan))); + + expect(Decimal128.nan, isNot(Decimal128.zero)); + expect(Decimal128.nan, isNot(lessThan(Decimal128.zero))); + expect(Decimal128.nan, isNot(lessThanOrEqualTo(Decimal128.zero))); + expect(Decimal128.nan, isNot(greaterThan(Decimal128.zero))); + expect(Decimal128.nan, isNot(greaterThanOrEqualTo(Decimal128.zero))); + expect(Decimal128.nan, isNot(Decimal128.nan)); expect(Decimal128.nan, isNot(lessThan(Decimal128.nan))); expect(Decimal128.nan, isNot(lessThanOrEqualTo(Decimal128.nan))); expect(Decimal128.nan, isNot(greaterThan(Decimal128.nan))); expect(Decimal128.nan, isNot(greaterThanOrEqualTo(Decimal128.nan))); + expect(Decimal128.nan.isNaN, isTrue); expect(Decimal128.zero.isNaN, isFalse); expect((Decimal128.zero / Decimal128.zero).isNaN, isTrue); @@ -159,8 +204,42 @@ Future main([List? args]) async { expect((Decimal128.infinity * Decimal128.zero).isNaN, isTrue); }); + test('Decimal128.compareTo is a total ordering', () { + // Test that we mimic the behavior of Dart's double wrt. compareTo in relation + // to IEEE754-2019, ie. +/- NaN, +/- infinity and +/- zero and define a total + // ordering. + expect((-0.0).compareTo(0.0), -1); + expect((0.0).compareTo(-0.0), 1); + expect((0.0).compareTo(0.0), 0); + expect((-0.0).compareTo(-0.0), 0); + + expect(double.negativeInfinity.compareTo(double.infinity), -1); + expect(double.infinity.compareTo(double.negativeInfinity), 1); + expect(double.infinity.compareTo(double.infinity), 0); + expect(double.negativeInfinity.compareTo(double.negativeInfinity), 0); + + expect((1.0).compareTo(double.nan), -1); + expect(double.nan.compareTo(double.nan), 0); + expect(double.nan.compareTo(1.0), 1); + + // .. and now for Decimal128 + expect((-Decimal128.zero).compareTo(Decimal128.zero), -1); + expect(Decimal128.zero.compareTo(-Decimal128.zero), 1); + expect(Decimal128.zero.compareTo(Decimal128.zero), 0); + expect((-Decimal128.zero).compareTo(-Decimal128.zero), 0); + + expect(Decimal128.negativeInfinity.compareTo(Decimal128.infinity), -1); + expect(Decimal128.infinity.compareTo(Decimal128.negativeInfinity), 1); + expect(Decimal128.infinity.compareTo(Decimal128.infinity), 0); + expect(Decimal128.negativeInfinity.compareTo(Decimal128.negativeInfinity), 0); + + expect(Decimal128.one.compareTo(Decimal128.nan), -1); + expect(Decimal128.nan.compareTo(Decimal128.nan), 0); + expect(Decimal128.nan.compareTo(Decimal128.one), 1); + }); + repeatTest('Decimal128.compareTo + <, <=, ==, !=, >=, >', (x, xInt, y, yInt) { - expect(x.compareTo(y), -y.compareTo(x)); + expect(x.compareTo(y), -(y.compareTo(x))); expect(x.compareTo(y), xInt.compareTo(yInt)); expect(x == y, y == x); expect(x == y, xInt == yInt); From b12c0488f1daa047e0f5f03aa4cfd405fe71fbbb Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Thu, 20 Apr 2023 13:29:43 +0200 Subject: [PATCH 20/30] Drop dependency on core for Decimal128 and use IntelRDFPMathLib20U2 lib directly --- lib/src/native/realm_bindings.dart | 12 +-- src/CMakeLists.txt | 1 + src/realm-core | 2 +- src/realm_dart.cpp | 123 ++++++++++++++++++++++------- src/realm_dart.h | 6 +- test/decimal128_test.dart | 1 - 6 files changed, 106 insertions(+), 39 deletions(-) diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index 4d54497b1..88b604018 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -3305,10 +3305,10 @@ class RealmLibrary { .asFunction(); bool realm_dart_decimal128_is_nan( - realm_decimal128_t decimal, + realm_decimal128_t x, ) { return _realm_dart_decimal128_is_nan( - decimal, + x, ); } @@ -3366,10 +3366,10 @@ class RealmLibrary { _realm_dart_decimal128_nanPtr.asFunction(); realm_decimal128_t realm_dart_decimal128_negate( - realm_decimal128_t decimal, + realm_decimal128_t x, ) { return _realm_dart_decimal128_negate( - decimal, + x, ); } @@ -3399,10 +3399,10 @@ class RealmLibrary { realm_decimal128_t, realm_decimal128_t)>(); int realm_dart_decimal128_to_int64( - realm_decimal128_t decimal, + realm_decimal128_t x, ) { return _realm_dart_decimal128_to_int64( - decimal, + x, ); } diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 62a00aad0..413309149 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -11,6 +11,7 @@ set(SOURCES realm_dart.cpp realm_dart_scheduler.cpp realm_dart_sync.cpp + realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid128_noncomp.c ) set(HEADERS diff --git a/src/realm-core b/src/realm-core index 653ef5909..dd91f5f96 160000 --- a/src/realm-core +++ b/src/realm-core @@ -1 +1 @@ -Subproject commit 653ef5909b0efee54d28d4567fa78a0a57162265 +Subproject commit dd91f5f967c4ae89c37e24ab2a0315c31106648f diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index 93672a5de..b226b45c9 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -25,8 +25,6 @@ #include "realm_dart.hpp" #include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_conf.h" #include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_functions.h" -#include "realm-core/src/realm/object-store/c_api/conversion.hpp" -#include "realm-core/src/realm/decimal128.hpp" #if REALM_ARCHITECTURE_ARM32 || REALM_ARCHITECTURE_ARM64 || REALM_ARCHITECTURE_X86_32 || REALM_ARCHITECTURE_X86_64 #if REALM_ARCHITECTURE_ARM32 @@ -156,76 +154,145 @@ RLM_API const char* realm_get_library_cpu_arch() { return cpuArch.c_str(); } +namespace { +realm_decimal128_t to_decimal128(const BID_UINT128& value) +{ + realm_decimal128_t result; + memcpy(&result, &value, sizeof(BID_UINT128)); + return result; +} + +BID_UINT128 to_BID_UINT128(const realm_decimal128_t& value) +{ + BID_UINT128 result; + memcpy(&result, &value, sizeof(BID_UINT128)); + return result; +} +} + RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string) { - return to_capi(Decimal128(string)); + unsigned int flags = 0; + BID_UINT128 result; + bid128_from_string(&result, const_cast(string), &flags); + return to_decimal128(result); } RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x) { - auto s = from_capi(x).to_string(); + auto x_bid = to_BID_UINT128(x); // This buffer is reused between calls, hence the static keyword static char buffer[34]; // 34 bytes is the maximum length of a string representation of a decimal128 unsigned int flags = 0; - __bid128_to_string(buffer, (BID_UINT128*)&x, &flags); + bid128_to_string(buffer, &x_bid, &flags); return realm_string_t{ buffer, strlen(buffer) }; } RLM_API realm_decimal128_t realm_dart_decimal128_nan() { - return to_capi(Decimal128::nan("+NaN")); + BID_UINT128 result; + bid128_nan(&result, "+NaN"); + return to_decimal128(result); } -RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t decimal) { - return from_capi(decimal).is_nan(); +RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t x) { + auto x_bid = to_BID_UINT128(x); + int result; + bid128_isNaN(&result, &x_bid); + return result; } RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t x) { - return to_capi(Decimal128(x)); + BID_UINT128 result; + BID_SINT64 y = x; + bid128_from_int64(&result, &y); + return to_decimal128(result); } -RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal) { - int64_t result; - from_capi(decimal).to_int(result); +RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t x) { + auto x_bid = to_BID_UINT128(x); + BID_SINT64 result; + unsigned int flags = 0; + bid128_to_int64_int(&result, &x_bid, &flags); return result; } -RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t decimal) { - return to_capi(-from_capi(decimal)); +RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t x) { + auto x_bid = to_BID_UINT128(x); + BID_UINT128 result; + bid128_negate(&result, &x_bid); + return to_decimal128(result); } RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y) { - return to_capi(from_capi(x) + from_capi(y)); + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + BID_UINT128 result; + unsigned int flags = 0; + bid128_add(&result, &l, &r, &flags); + return to_decimal128(result); } RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y) { - return to_capi(from_capi(x) - from_capi(y)); + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + BID_UINT128 result; + unsigned int flags = 0; + bid128_sub(&result, &l, &r, &flags); + return to_decimal128(result); } RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y) { - return to_capi(from_capi(x) * from_capi(y)); + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + BID_UINT128 result; + unsigned int flags = 0; + bid128_mul(&result, &l, &r, &flags); + return to_decimal128(result); } RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, realm_decimal128_t y) { - return to_capi(from_capi(x) / from_capi(y)); + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + BID_UINT128 result; + unsigned int flags = 0; + bid128_div(&result, &l, &r, &flags); + return to_decimal128(result); } RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y) { - auto x_decimal = from_capi(x); - auto y_decimal = from_capi(y); - return !x_decimal.is_nan() && !y_decimal.is_nan() && x_decimal == y_decimal; + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + int result; + unsigned int flags = 0; + bid128_quiet_equal(&result, &l, &r, &flags); + return result; } RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y) { - auto x_decimal = from_capi(x); - auto y_decimal = from_capi(y); - return !x_decimal.is_nan() && !y_decimal.is_nan() && x_decimal < y_decimal; + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + int result; + unsigned int flags = 0; + bid128_quiet_less(&result, &l, &r, &flags); + return result; } RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y) { - auto x_decimal = from_capi(x); - auto y_decimal = from_capi(y); - return !x_decimal.is_nan() && !y_decimal.is_nan() && x_decimal > y_decimal; + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + int result; + unsigned int flags = 0; + bid128_quiet_greater(&result, &l, &r, &flags); + return result; } RLM_API int realm_dart_decimal128_compare_to(realm_decimal128_t x, realm_decimal128_t y) { - return from_capi(x).compareTotalOrdering(from_capi(y)); + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + int lr, rl; + bid128_totalOrder(&lr, &l, &r); + bid128_totalOrder(&rl, &r, &l); + if (lr && rl) return 0; + if (lr) return -1; + if (rl) return 1; + return 0; } diff --git a/src/realm_dart.h b/src/realm_dart.h index 596329f9a..42c65941e 100644 --- a/src/realm_dart.h +++ b/src/realm_dart.h @@ -58,10 +58,10 @@ RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string) RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x); RLM_API realm_decimal128_t realm_dart_decimal128_nan(); -RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t decimal); +RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t x); RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t low); -RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t decimal); -RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t decimal); +RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t x); +RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t x); RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y); RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y); RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y); diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index a62312610..020bc1b78 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -16,7 +16,6 @@ // //////////////////////////////////////////////////////////////////////////////// -import 'dart:io'; import 'dart:math'; import 'package:meta/meta.dart'; From 501b244c443350b5985c5d8cbb57653012f7e005 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Thu, 20 Apr 2023 17:01:12 +0200 Subject: [PATCH 21/30] Fix prior (and minor) spelling mistake --- lib/src/native/realm_bindings.dart | 10 +++++----- lib/src/native/realm_core.dart | 2 +- src/realm_dart.cpp | 2 +- src/realm_dart.h | 2 +- 4 files changed, 8 insertions(+), 8 deletions(-) diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index 88b604018..f82cce517 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -3863,21 +3863,21 @@ class RealmLibrary { late final _realm_delete_files = _realm_delete_filesPtr.asFunction< bool Function(ffi.Pointer, ffi.Pointer)>(); - void realm_dettach_finalizer( + void realm_detach_finalizer( ffi.Pointer finalizableHandle, Object handle, ) { - return _realm_dettach_finalizer( + return _realm_detach_finalizer( finalizableHandle, handle, ); } - late final _realm_dettach_finalizerPtr = _lookup< + late final _realm_detach_finalizerPtr = _lookup< ffi.NativeFunction< ffi.Void Function( - ffi.Pointer, ffi.Handle)>>('realm_dettach_finalizer'); - late final _realm_dettach_finalizer = _realm_dettach_finalizerPtr + ffi.Pointer, ffi.Handle)>>('realm_detach_finalizer'); + late final _realm_detach_finalizer = _realm_detach_finalizerPtr .asFunction, Object)>(); /// Subscribe to notifications for this object. diff --git a/lib/src/native/realm_core.dart b/lib/src/native/realm_core.dart index 9fb4a6e38..2d282af7d 100644 --- a/lib/src/native/realm_core.dart +++ b/lib/src/native/realm_core.dart @@ -2559,7 +2559,7 @@ abstract class HandleBase implements Finalizable { _releaseCore(); if (!isUnowned) { - _realmLib.realm_dettach_finalizer(_finalizableHandle, this); + _realmLib.realm_detach_finalizer(_finalizableHandle, this); _realmLib.realm_release(_pointer.cast()); } diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index b226b45c9..a129ff1bc 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -141,7 +141,7 @@ RLM_API void* realm_attach_finalizer(Dart_Handle handle, void* realmPtr, int siz return Dart_NewFinalizableHandle_DL(handle, realmPtr, size, handle_finalizer); } -RLM_API void realm_dettach_finalizer(void* finalizableHandle, Dart_Handle handle) { +RLM_API void realm_detach_finalizer(void* finalizableHandle, Dart_Handle handle) { Dart_FinalizableHandle finalHandle = reinterpret_cast(finalizableHandle); return Dart_DeleteFinalizableHandle_DL(finalHandle, handle); } diff --git a/src/realm_dart.h b/src/realm_dart.h index 42c65941e..e50950af7 100644 --- a/src/realm_dart.h +++ b/src/realm_dart.h @@ -51,7 +51,7 @@ RLM_API const char* realm_dart_library_version(); // RLM_API void realm_dart_gc(); RLM_API void* realm_attach_finalizer(Dart_Handle handle, void* realmPtr, int size); -RLM_API void realm_dettach_finalizer(void* finalizableHandle, Dart_Handle handle); +RLM_API void realm_detach_finalizer(void* finalizableHandle, Dart_Handle handle); RLM_API void realm_set_auto_refresh(realm_t* realm, bool enable); RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string); From c16c2d970622127ce9fae2c10bbcbac15d9c382d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Tue, 2 May 2023 11:19:01 +0200 Subject: [PATCH 22/30] Export Decimal128 class from realm_class.dart --- lib/src/realm_class.dart | 1 + 1 file changed, 1 insertion(+) diff --git a/lib/src/realm_class.dart b/lib/src/realm_class.dart index f22287875..7e54fda54 100644 --- a/lib/src/realm_class.dart +++ b/lib/src/realm_class.dart @@ -88,6 +88,7 @@ export "configuration.dart" SyncWebSocketError, SyncSessionError; export 'credentials.dart' show AuthProviderType, Credentials, EmailPasswordAuthProvider; +export 'decimal128.dart' show Decimal128; export 'list.dart' show RealmList, RealmListOfObject, RealmListChanges, ListExtension; export 'set.dart' show RealmSet, RealmSetChanges; export 'migration.dart' show Migration; From ba9468d93ba2137fa4178924808ed2be5930ba4b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Tue, 2 May 2023 12:11:14 +0200 Subject: [PATCH 23/30] Allow Decimal128 properties on models --- common/lib/src/realm_types.dart | 2 +- generator/lib/src/dart_type_ex.dart | 5 +- generator/lib/src/field_element_ex.dart | 2 +- generator/test/good_test_data/all_types.dart | 4 +- .../test/good_test_data/all_types.expected | 11 ++- lib/src/decimal128.dart | 11 ++- lib/src/native/realm_core.dart | 8 +- test/backlinks_test.dart | 1 - test/dynamic_realm_test.dart | 7 +- test/embedded_test.dart | 4 +- test/realm_object_test.dart | 17 ++-- test/test.dart | 8 ++ test/test.g.dart | 98 ++++++++++++++++++- 13 files changed, 155 insertions(+), 23 deletions(-) diff --git a/common/lib/src/realm_types.dart b/common/lib/src/realm_types.dart index 3ffce22df..3f4e1f57a 100644 --- a/common/lib/src/realm_types.dart +++ b/common/lib/src/realm_types.dart @@ -101,7 +101,7 @@ class RealmStateError extends StateError implements RealmError { } /// @nodoc -class Decimal128 {} // TODO Support decimal128 datatype https://github.com/realm/realm-dart/issues/725 +abstract class Decimal128 {} // TODO Support decimal128 datatype https://github.com/realm/realm-dart/issues/725 /// @nodoc abstract class RealmObjectBaseMarker {} diff --git a/generator/lib/src/dart_type_ex.dart b/generator/lib/src/dart_type_ex.dart index 8c1c6d35f..bb45bead4 100644 --- a/generator/lib/src/dart_type_ex.dart +++ b/generator/lib/src/dart_type_ex.dart @@ -15,7 +15,7 @@ // limitations under the License. // //////////////////////////////////////////////////////////////////////////////// -import 'dart:ffi'; + import 'dart:typed_data'; import 'package:analyzer/dart/element/nullability_suffix.dart'; @@ -29,6 +29,7 @@ import 'type_checkers.dart'; extension DartTypeEx on DartType { bool isExactly() => TypeChecker.fromRuntime(T).isExactlyType(this); + bool isA() => TypeChecker.fromRuntime(T).isAssignableFromType(this); bool get isRealmValue => const TypeChecker.fromRuntime(RealmValue).isAssignableFromType(this); bool get isRealmCollection => realmCollectionType != RealmCollectionType.none; @@ -112,7 +113,7 @@ extension DartTypeEx on DartType { if (isRealmValue) return RealmPropertyType.mixed; if (isExactly()) return RealmPropertyType.timestamp; if (isDartCoreNum || isDartCoreDouble) return RealmPropertyType.double; - if (isExactly()) return RealmPropertyType.decimal128; + if (isA()) return RealmPropertyType.decimal128; if (isRealmModel) return RealmPropertyType.object; if (isDartCoreIterable) return RealmPropertyType.linkingObjects; if (isExactly()) return RealmPropertyType.objectid; diff --git a/generator/lib/src/field_element_ex.dart b/generator/lib/src/field_element_ex.dart index 59ccb2642..bbdf676ef 100644 --- a/generator/lib/src/field_element_ex.dart +++ b/generator/lib/src/field_element_ex.dart @@ -92,7 +92,7 @@ extension FieldElementEx on FieldElement { final backlink = backlinkInfo; // Check for as-of-yet unsupported type - if (type.isDartCoreMap || type.isExactly()) { + if (type.isDartCoreMap) { throw RealmInvalidGenerationSourceError( 'Field type not supported yet', element: this, diff --git a/generator/test/good_test_data/all_types.dart b/generator/test/good_test_data/all_types.dart index 4f86173a8..fde9f6042 100644 --- a/generator/test/good_test_data/all_types.dart +++ b/generator/test/good_test_data/all_types.dart @@ -41,6 +41,8 @@ class _Bar { late RealmValue any; late List manyAny; + + late Decimal128 decimal; } @RealmModel() @@ -50,4 +52,4 @@ class _PrimitiveTypes { late DateTime dateProp; late double doubleProp; late ObjectId objectIdProp; -} \ No newline at end of file +} diff --git a/generator/test/good_test_data/all_types.expected b/generator/test/good_test_data/all_types.expected index 2ba7baa9a..f302dbf41 100644 --- a/generator/test/good_test_data/all_types.expected +++ b/generator/test/good_test_data/all_types.expected @@ -57,7 +57,8 @@ class Bar extends _Bar with RealmEntity, RealmObjectBase, RealmObject { bool aBool, bool another, ObjectId objectId, - Uuid uuid, { + Uuid uuid, + Decimal128 decimal, { Uint8List data = Uint8List(16), DateTime timestamp = DateTime.now(), double aDouble = 0.0, @@ -85,6 +86,7 @@ class Bar extends _Bar with RealmEntity, RealmObjectBase, RealmObject { RealmObjectBase.set(this, 'uuid', uuid); RealmObjectBase.set(this, 'anOptionalString', anOptionalString); RealmObjectBase.set(this, 'any', any); + RealmObjectBase.set(this, 'decimal', decimal); RealmObjectBase.set>(this, 'list', RealmList(list)); RealmObjectBase.set>( this, 'manyAny', RealmList(manyAny)); @@ -167,6 +169,12 @@ class Bar extends _Bar with RealmEntity, RealmObjectBase, RealmObject { set manyAny(covariant RealmList value) => throw RealmUnsupportedSetError(); + @override + Decimal128 get decimal => + RealmObjectBase.get(this, 'decimal') as Decimal128; + @override + set decimal(Decimal128 value) => RealmObjectBase.set(this, 'decimal', value); + @override RealmResults get foos => RealmObjectBase.get(this, 'foos') as RealmResults; @@ -204,6 +212,7 @@ class Bar extends _Bar with RealmEntity, RealmObjectBase, RealmObject { SchemaProperty('any', RealmPropertyType.mixed, optional: true), SchemaProperty('manyAny', RealmPropertyType.mixed, optional: true, collectionType: RealmCollectionType.list), + SchemaProperty('decimal', RealmPropertyType.decimal128), SchemaProperty('foos', RealmPropertyType.linkingObjects, linkOriginProperty: 'bar', collectionType: RealmCollectionType.list, diff --git a/lib/src/decimal128.dart b/lib/src/decimal128.dart index bb9541c5c..24f30b72a 100644 --- a/lib/src/decimal128.dart +++ b/lib/src/decimal128.dart @@ -23,9 +23,10 @@ import 'package:ffi/ffi.dart'; import 'native/realm_bindings.dart'; import 'native/realm_core.dart'; +import 'package:realm_common/realm_common.dart' as common; /// A 128-bit decimal floating point number. -class Decimal128 extends Comparable { +class Decimal128 extends Comparable implements common.Decimal128 { /// The value 0. static final zero = Decimal128.fromInt(0); @@ -147,3 +148,11 @@ class Decimal128 extends Comparable { @override int compareTo(Decimal128 other) => lib.realm_dart_decimal128_compare_to(_value, other._value); } + +extension Decimal128Internal on Decimal128 { + realm_decimal128_t get value => _value; + + static Decimal128 fromNative(realm_decimal128_t value) { + return Decimal128._(value); + } +} diff --git a/lib/src/native/realm_core.dart b/lib/src/native/realm_core.dart index 2d282af7d..c54519e41 100644 --- a/lib/src/native/realm_core.dart +++ b/lib/src/native/realm_core.dart @@ -28,12 +28,13 @@ import 'package:cancellation_token/cancellation_token.dart'; import 'package:ffi/ffi.dart' hide StringUtf8Pointer, StringUtf16Pointer; import 'package:logging/logging.dart'; import 'package:path/path.dart' as path; -import 'package:realm_common/realm_common.dart'; +import 'package:realm_common/realm_common.dart' hide Decimal128; import '../app.dart'; import '../collections.dart'; import '../configuration.dart'; import '../credentials.dart'; +import '../decimal128.dart'; import '../init.dart'; import '../list.dart'; import '../migration.dart'; @@ -2863,6 +2864,9 @@ void _intoRealmValue(Object? value, Pointer realm_value, Allocato realm_value.ref.type = realm_value_type.RLM_TYPE_TIMESTAMP; } else if (value is RealmValue) { return _intoRealmValue(value.value, realm_value, allocator); + } else if (value is Decimal128) { + realm_value.ref.values.decimal128 = value.value; + realm_value.ref.type = realm_value_type.RLM_TYPE_DECIMAL128; } else { throw RealmException("Property type ${value.runtimeType} not supported"); } @@ -2905,6 +2909,8 @@ extension on Pointer { return ObjectId.fromBytes(cast().asTypedList(12)); case realm_value_type.RLM_TYPE_UUID: return Uuid.fromBytes(cast().asTypedList(16).buffer); + case realm_value_type.RLM_TYPE_DECIMAL128: + return Decimal128Internal.fromNative(ref.values.decimal128); default: throw RealmException("realm_value_type ${ref.type} not supported"); } diff --git a/test/backlinks_test.dart b/test/backlinks_test.dart index 9f0650a35..bba22afea 100644 --- a/test/backlinks_test.dart +++ b/test/backlinks_test.dart @@ -16,7 +16,6 @@ // //////////////////////////////////////////////////////////////////////////////// -import 'package:realm_common/realm_common.dart'; import 'package:test/expect.dart'; import '../lib/realm.dart'; diff --git a/test/dynamic_realm_test.dart b/test/dynamic_realm_test.dart index da0370ca3..d5e50397d 100644 --- a/test/dynamic_realm_test.dart +++ b/test/dynamic_realm_test.dart @@ -87,16 +87,17 @@ Future main([List? args]) async { final objectId = ObjectId(); final uuid = Uuid.v4(); - AllTypes _getPopulatedAllTypes() => AllTypes('abc', true, date, -123.456, objectId, uuid, -987, + AllTypes _getPopulatedAllTypes() => AllTypes('abc', true, date, -123.456, objectId, uuid, -987, Decimal128.fromDouble(42), nullableStringProp: 'def', nullableBoolProp: true, nullableDateProp: date, nullableDoubleProp: -123.456, nullableObjectIdProp: objectId, nullableUuidProp: uuid, - nullableIntProp: 123); + nullableIntProp: 123, + nullableDecimalProp: Decimal128.fromDouble(4242)); - AllTypes _getEmptyAllTypes() => AllTypes('', false, DateTime(0).toUtc(), 0, objectId, uuid, 0); + AllTypes _getEmptyAllTypes() => AllTypes('', false, DateTime(0).toUtc(), 0, objectId, uuid, 0, Decimal128.zero); AllCollections _getPopulatedAllCollections() => AllCollections( strings: ['abc', 'def'], diff --git a/test/embedded_test.dart b/test/embedded_test.dart index 9c3bb2eaa..f8c27469e 100644 --- a/test/embedded_test.dart +++ b/test/embedded_test.dart @@ -68,7 +68,7 @@ Future main([List? args]) async { final oid = ObjectId(); final uuid = Uuid.v4(); realm.write(() { - realm.add(ObjectWithEmbedded('abc', singleObject: AllTypesEmbedded('str', true, now, 1.23, oid, uuid, 99))); + realm.add(ObjectWithEmbedded('abc', singleObject: AllTypesEmbedded('str', true, now, 1.23, oid, uuid, 99, Decimal128.ten))); }); final obj = realm.all().single; @@ -81,6 +81,7 @@ Future main([List? args]) async { expect(json, contains('"objectIdProp":"$oid"')); expect(json, contains('"uuidProp":"$uuid"')); expect(json, contains('"intProp":99')); + expect(json, contains('"decimalProp":"10"')); // note the quotes! expect(json, contains('"nullableStringProp":null')); expect(json, contains('"nullableBoolProp":null')); @@ -89,6 +90,7 @@ Future main([List? args]) async { expect(json, contains('"nullableObjectIdProp":null')); expect(json, contains('"nullableUuidProp":null')); expect(json, contains('"nullableIntProp":null')); + expect(json, contains('"nullableDecimalProp":null')); }); test('Embedded object get/set properties', () { diff --git a/test/realm_object_test.dart b/test/realm_object_test.dart index 26e10255d..d115b394d 100644 --- a/test/realm_object_test.dart +++ b/test/realm_object_test.dart @@ -448,7 +448,7 @@ Future main([List? args]) async { final config = Configuration.local([AllTypes.schema]); final realm = getRealm(config); final obj = realm.write(() { - return realm.add(AllTypes('', false, date, 0, ObjectId(), Uuid.v4(), 0)); + return realm.add(AllTypes('', false, date, 0, ObjectId(), Uuid.v4(), 0, Decimal128.one)); }); final json = obj.toJson(); @@ -490,7 +490,7 @@ Future main([List? args]) async { expect(date.isUtc, isFalse); final obj = realm.write(() { - return realm.add(AllTypes('', false, date, 0, ObjectId(), Uuid.v4(), 0)); + return realm.add(AllTypes('', false, date, 0, ObjectId(), Uuid.v4(), 0, Decimal128.one)); }); final json = obj.toJson(); @@ -507,8 +507,8 @@ Future main([List? args]) async { final date = DateTime.now(); realm.write(() { - realm.add(AllTypes('abc', false, date, 0, ObjectId(), Uuid.v4(), 0)); - realm.add(AllTypes('cde', false, DateTime.now().add(Duration(seconds: 1)), 0, ObjectId(), Uuid.v4(), 0)); + realm.add(AllTypes('abc', false, date, 0, ObjectId(), Uuid.v4(), 0, Decimal128.one)); + realm.add(AllTypes('cde', false, DateTime.now().add(Duration(seconds: 1)), 0, ObjectId(), Uuid.v4(), 0, Decimal128.one)); }); var results = realm.all().query('dateProp = \$0', [date]); @@ -525,9 +525,9 @@ Future main([List? args]) async { final date3 = date1.subtract(Duration(microseconds: 1)); realm.write(() { - realm.add(AllTypes('1', false, date1, 0, ObjectId(), Uuid.v4(), 0)); - realm.add(AllTypes('2', false, date2, 0, ObjectId(), Uuid.v4(), 0)); - realm.add(AllTypes('3', false, date3, 0, ObjectId(), Uuid.v4(), 0)); + realm.add(AllTypes('1', false, date1, 0, ObjectId(), Uuid.v4(), 0, Decimal128.one)); + realm.add(AllTypes('2', false, date2, 0, ObjectId(), Uuid.v4(), 0, Decimal128.one)); + realm.add(AllTypes('3', false, date3, 0, ObjectId(), Uuid.v4(), 0, Decimal128.one)); }); final lessThan1 = realm.all().query('dateProp < \$0', [date1]); @@ -552,7 +552,7 @@ Future main([List? args]) async { var uuid = Uuid.v4(); final object = realm.write(() { - return realm.add(AllTypes('cde', false, date, 0.1, objectId, uuid, 4)); + return realm.add(AllTypes('cde', false, date, 0.1, objectId, uuid, 4, Decimal128.ten)); }); expect(object.stringProp, 'cde'); @@ -562,6 +562,7 @@ Future main([List? args]) async { expect(object.objectIdProp, objectId); expect(object.uuidProp, uuid); expect(object.intProp, 4); + expect(object.decimalProp, Decimal128.ten); date = DateTime.now().add(Duration(days: 1)).toUtc(); objectId = ObjectId(); diff --git a/test/test.dart b/test/test.dart index fc0fcb8b0..49de05721 100644 --- a/test/test.dart +++ b/test/test.dart @@ -124,6 +124,7 @@ class _AllTypes { late ObjectId objectIdProp; late Uuid uuidProp; late int intProp; + late Decimal128 decimalProp; late String? nullableStringProp; late bool? nullableBoolProp; @@ -132,6 +133,7 @@ class _AllTypes { late ObjectId? nullableObjectIdProp; late Uuid? nullableUuidProp; late int? nullableIntProp; + late Decimal128? nullableDecimalProp; } @RealmModel() @@ -152,6 +154,7 @@ class _AllCollections { late List objectIds; late List uuids; late List ints; + late List decimals; late List nullableStrings; late List nullableBools; @@ -160,6 +163,7 @@ class _AllCollections { late List nullableObjectIds; late List nullableUuids; late List nullableInts; + late List nullableDecimals; } @RealmModel() @@ -177,6 +181,7 @@ class _NullableTypes { late ObjectId? objectIdProp; late Uuid? uuidProp; late int? intProp; + late Decimal128? decimalProp; } @RealmModel() @@ -240,6 +245,7 @@ class _AllTypesEmbedded { late ObjectId objectIdProp; late Uuid uuidProp; late int intProp; + late Decimal128 decimalProp; late String? nullableStringProp; late bool? nullableBoolProp; @@ -248,6 +254,7 @@ class _AllTypesEmbedded { late ObjectId? nullableObjectIdProp; late Uuid? nullableUuidProp; late int? nullableIntProp; + late Decimal128? nullableDecimalProp; late List strings; late List bools; @@ -256,6 +263,7 @@ class _AllTypesEmbedded { late List objectIds; late List uuids; late List ints; + late List decimals; } @RealmModel() diff --git a/test/test.g.dart b/test/test.g.dart index 91b2e875f..a472240ec 100644 --- a/test/test.g.dart +++ b/test/test.g.dart @@ -482,7 +482,8 @@ class AllTypes extends _AllTypes double doubleProp, ObjectId objectIdProp, Uuid uuidProp, - int intProp, { + int intProp, + Decimal128 decimalProp, { String? nullableStringProp, bool? nullableBoolProp, DateTime? nullableDateProp, @@ -490,6 +491,7 @@ class AllTypes extends _AllTypes ObjectId? nullableObjectIdProp, Uuid? nullableUuidProp, int? nullableIntProp, + Decimal128? nullableDecimalProp, }) { RealmObjectBase.set(this, 'stringProp', stringProp); RealmObjectBase.set(this, 'boolProp', boolProp); @@ -498,6 +500,7 @@ class AllTypes extends _AllTypes RealmObjectBase.set(this, 'objectIdProp', objectIdProp); RealmObjectBase.set(this, 'uuidProp', uuidProp); RealmObjectBase.set(this, 'intProp', intProp); + RealmObjectBase.set(this, 'decimalProp', decimalProp); RealmObjectBase.set(this, 'nullableStringProp', nullableStringProp); RealmObjectBase.set(this, 'nullableBoolProp', nullableBoolProp); RealmObjectBase.set(this, 'nullableDateProp', nullableDateProp); @@ -505,6 +508,7 @@ class AllTypes extends _AllTypes RealmObjectBase.set(this, 'nullableObjectIdProp', nullableObjectIdProp); RealmObjectBase.set(this, 'nullableUuidProp', nullableUuidProp); RealmObjectBase.set(this, 'nullableIntProp', nullableIntProp); + RealmObjectBase.set(this, 'nullableDecimalProp', nullableDecimalProp); } AllTypes._(); @@ -551,6 +555,13 @@ class AllTypes extends _AllTypes @override set intProp(int value) => RealmObjectBase.set(this, 'intProp', value); + @override + Decimal128 get decimalProp => + RealmObjectBase.get(this, 'decimalProp') as Decimal128; + @override + set decimalProp(Decimal128 value) => + RealmObjectBase.set(this, 'decimalProp', value); + @override String? get nullableStringProp => RealmObjectBase.get(this, 'nullableStringProp') as String?; @@ -600,6 +611,14 @@ class AllTypes extends _AllTypes set nullableIntProp(int? value) => RealmObjectBase.set(this, 'nullableIntProp', value); + @override + Decimal128? get nullableDecimalProp => + RealmObjectBase.get(this, 'nullableDecimalProp') + as Decimal128?; + @override + set nullableDecimalProp(Decimal128? value) => + RealmObjectBase.set(this, 'nullableDecimalProp', value); + @override Stream> get changes => RealmObjectBase.getChanges(this); @@ -619,6 +638,7 @@ class AllTypes extends _AllTypes SchemaProperty('objectIdProp', RealmPropertyType.objectid), SchemaProperty('uuidProp', RealmPropertyType.uuid), SchemaProperty('intProp', RealmPropertyType.int), + SchemaProperty('decimalProp', RealmPropertyType.decimal128), SchemaProperty('nullableStringProp', RealmPropertyType.string, optional: true), SchemaProperty('nullableBoolProp', RealmPropertyType.bool, @@ -632,6 +652,8 @@ class AllTypes extends _AllTypes SchemaProperty('nullableUuidProp', RealmPropertyType.uuid, optional: true), SchemaProperty('nullableIntProp', RealmPropertyType.int, optional: true), + SchemaProperty('nullableDecimalProp', RealmPropertyType.decimal128, + optional: true), ]); } } @@ -702,6 +724,7 @@ class AllCollections extends _AllCollections Iterable objectIds = const [], Iterable uuids = const [], Iterable ints = const [], + Iterable decimals = const [], Iterable nullableStrings = const [], Iterable nullableBools = const [], Iterable nullableDates = const [], @@ -709,6 +732,7 @@ class AllCollections extends _AllCollections Iterable nullableObjectIds = const [], Iterable nullableUuids = const [], Iterable nullableInts = const [], + Iterable nullableDecimals = const [], }) { RealmObjectBase.set>( this, 'strings', RealmList(strings)); @@ -721,6 +745,8 @@ class AllCollections extends _AllCollections this, 'objectIds', RealmList(objectIds)); RealmObjectBase.set>(this, 'uuids', RealmList(uuids)); RealmObjectBase.set>(this, 'ints', RealmList(ints)); + RealmObjectBase.set>( + this, 'decimals', RealmList(decimals)); RealmObjectBase.set>( this, 'nullableStrings', RealmList(nullableStrings)); RealmObjectBase.set>( @@ -735,6 +761,8 @@ class AllCollections extends _AllCollections this, 'nullableUuids', RealmList(nullableUuids)); RealmObjectBase.set>( this, 'nullableInts', RealmList(nullableInts)); + RealmObjectBase.set>( + this, 'nullableDecimals', RealmList(nullableDecimals)); } AllCollections._(); @@ -787,6 +815,14 @@ class AllCollections extends _AllCollections @override set ints(covariant RealmList value) => throw RealmUnsupportedSetError(); + @override + RealmList get decimals => + RealmObjectBase.get(this, 'decimals') + as RealmList; + @override + set decimals(covariant RealmList value) => + throw RealmUnsupportedSetError(); + @override RealmList get nullableStrings => RealmObjectBase.get(this, 'nullableStrings') @@ -840,6 +876,14 @@ class AllCollections extends _AllCollections set nullableInts(covariant RealmList value) => throw RealmUnsupportedSetError(); + @override + RealmList get nullableDecimals => + RealmObjectBase.get(this, 'nullableDecimals') + as RealmList; + @override + set nullableDecimals(covariant RealmList value) => + throw RealmUnsupportedSetError(); + @override Stream> get changes => RealmObjectBase.getChanges(this); @@ -867,6 +911,8 @@ class AllCollections extends _AllCollections collectionType: RealmCollectionType.list), SchemaProperty('ints', RealmPropertyType.int, collectionType: RealmCollectionType.list), + SchemaProperty('decimals', RealmPropertyType.decimal128, + collectionType: RealmCollectionType.list), SchemaProperty('nullableStrings', RealmPropertyType.string, optional: true, collectionType: RealmCollectionType.list), SchemaProperty('nullableBools', RealmPropertyType.bool, @@ -881,6 +927,8 @@ class AllCollections extends _AllCollections optional: true, collectionType: RealmCollectionType.list), SchemaProperty('nullableInts', RealmPropertyType.int, optional: true, collectionType: RealmCollectionType.list), + SchemaProperty('nullableDecimals', RealmPropertyType.decimal128, + optional: true, collectionType: RealmCollectionType.list), ]); } } @@ -897,6 +945,7 @@ class NullableTypes extends _NullableTypes ObjectId? objectIdProp, Uuid? uuidProp, int? intProp, + Decimal128? decimalProp, }) { RealmObjectBase.set(this, '_id', id); RealmObjectBase.set(this, 'differentiator', differentiator); @@ -907,6 +956,7 @@ class NullableTypes extends _NullableTypes RealmObjectBase.set(this, 'objectIdProp', objectIdProp); RealmObjectBase.set(this, 'uuidProp', uuidProp); RealmObjectBase.set(this, 'intProp', intProp); + RealmObjectBase.set(this, 'decimalProp', decimalProp); } NullableTypes._(); @@ -965,6 +1015,13 @@ class NullableTypes extends _NullableTypes @override set intProp(int? value) => RealmObjectBase.set(this, 'intProp', value); + @override + Decimal128? get decimalProp => + RealmObjectBase.get(this, 'decimalProp') as Decimal128?; + @override + set decimalProp(Decimal128? value) => + RealmObjectBase.set(this, 'decimalProp', value); + @override Stream> get changes => RealmObjectBase.getChanges(this); @@ -989,6 +1046,8 @@ class NullableTypes extends _NullableTypes optional: true), SchemaProperty('uuidProp', RealmPropertyType.uuid, optional: true), SchemaProperty('intProp', RealmPropertyType.int, optional: true), + SchemaProperty('decimalProp', RealmPropertyType.decimal128, + optional: true), ]); } } @@ -1338,7 +1397,8 @@ class AllTypesEmbedded extends _AllTypesEmbedded double doubleProp, ObjectId objectIdProp, Uuid uuidProp, - int intProp, { + int intProp, + Decimal128 decimalProp, { String? nullableStringProp, bool? nullableBoolProp, DateTime? nullableDateProp, @@ -1346,6 +1406,7 @@ class AllTypesEmbedded extends _AllTypesEmbedded ObjectId? nullableObjectIdProp, Uuid? nullableUuidProp, int? nullableIntProp, + Decimal128? nullableDecimalProp, Iterable strings = const [], Iterable bools = const [], Iterable dates = const [], @@ -1353,6 +1414,7 @@ class AllTypesEmbedded extends _AllTypesEmbedded Iterable objectIds = const [], Iterable uuids = const [], Iterable ints = const [], + Iterable decimals = const [], }) { RealmObjectBase.set(this, 'stringProp', stringProp); RealmObjectBase.set(this, 'boolProp', boolProp); @@ -1361,6 +1423,7 @@ class AllTypesEmbedded extends _AllTypesEmbedded RealmObjectBase.set(this, 'objectIdProp', objectIdProp); RealmObjectBase.set(this, 'uuidProp', uuidProp); RealmObjectBase.set(this, 'intProp', intProp); + RealmObjectBase.set(this, 'decimalProp', decimalProp); RealmObjectBase.set(this, 'nullableStringProp', nullableStringProp); RealmObjectBase.set(this, 'nullableBoolProp', nullableBoolProp); RealmObjectBase.set(this, 'nullableDateProp', nullableDateProp); @@ -1368,6 +1431,7 @@ class AllTypesEmbedded extends _AllTypesEmbedded RealmObjectBase.set(this, 'nullableObjectIdProp', nullableObjectIdProp); RealmObjectBase.set(this, 'nullableUuidProp', nullableUuidProp); RealmObjectBase.set(this, 'nullableIntProp', nullableIntProp); + RealmObjectBase.set(this, 'nullableDecimalProp', nullableDecimalProp); RealmObjectBase.set>( this, 'strings', RealmList(strings)); RealmObjectBase.set>(this, 'bools', RealmList(bools)); @@ -1379,6 +1443,8 @@ class AllTypesEmbedded extends _AllTypesEmbedded this, 'objectIds', RealmList(objectIds)); RealmObjectBase.set>(this, 'uuids', RealmList(uuids)); RealmObjectBase.set>(this, 'ints', RealmList(ints)); + RealmObjectBase.set>( + this, 'decimals', RealmList(decimals)); } AllTypesEmbedded._(); @@ -1425,6 +1491,13 @@ class AllTypesEmbedded extends _AllTypesEmbedded @override set intProp(int value) => RealmObjectBase.set(this, 'intProp', value); + @override + Decimal128 get decimalProp => + RealmObjectBase.get(this, 'decimalProp') as Decimal128; + @override + set decimalProp(Decimal128 value) => + RealmObjectBase.set(this, 'decimalProp', value); + @override String? get nullableStringProp => RealmObjectBase.get(this, 'nullableStringProp') as String?; @@ -1474,6 +1547,14 @@ class AllTypesEmbedded extends _AllTypesEmbedded set nullableIntProp(int? value) => RealmObjectBase.set(this, 'nullableIntProp', value); + @override + Decimal128? get nullableDecimalProp => + RealmObjectBase.get(this, 'nullableDecimalProp') + as Decimal128?; + @override + set nullableDecimalProp(Decimal128? value) => + RealmObjectBase.set(this, 'nullableDecimalProp', value); + @override RealmList get strings => RealmObjectBase.get(this, 'strings') as RealmList; @@ -1522,6 +1603,14 @@ class AllTypesEmbedded extends _AllTypesEmbedded @override set ints(covariant RealmList value) => throw RealmUnsupportedSetError(); + @override + RealmList get decimals => + RealmObjectBase.get(this, 'decimals') + as RealmList; + @override + set decimals(covariant RealmList value) => + throw RealmUnsupportedSetError(); + @override Stream> get changes => RealmObjectBase.getChanges(this); @@ -1543,6 +1632,7 @@ class AllTypesEmbedded extends _AllTypesEmbedded SchemaProperty('objectIdProp', RealmPropertyType.objectid), SchemaProperty('uuidProp', RealmPropertyType.uuid), SchemaProperty('intProp', RealmPropertyType.int), + SchemaProperty('decimalProp', RealmPropertyType.decimal128), SchemaProperty('nullableStringProp', RealmPropertyType.string, optional: true), SchemaProperty('nullableBoolProp', RealmPropertyType.bool, @@ -1556,6 +1646,8 @@ class AllTypesEmbedded extends _AllTypesEmbedded SchemaProperty('nullableUuidProp', RealmPropertyType.uuid, optional: true), SchemaProperty('nullableIntProp', RealmPropertyType.int, optional: true), + SchemaProperty('nullableDecimalProp', RealmPropertyType.decimal128, + optional: true), SchemaProperty('strings', RealmPropertyType.string, collectionType: RealmCollectionType.list), SchemaProperty('bools', RealmPropertyType.bool, @@ -1570,6 +1662,8 @@ class AllTypesEmbedded extends _AllTypesEmbedded collectionType: RealmCollectionType.list), SchemaProperty('ints', RealmPropertyType.int, collectionType: RealmCollectionType.list), + SchemaProperty('decimals', RealmPropertyType.decimal128, + collectionType: RealmCollectionType.list), ]); } } From 2fa62286802a1d18a40e4d94f128e4aee0412434 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Wed, 3 May 2023 08:37:49 +0200 Subject: [PATCH 24/30] Work-around to Dart FFI issue Assigning a sub-struct from a heap allocated struct to a stack allocated struct, does not actually copy the bytes. This is a work-around for that issue. --- lib/src/decimal128.dart | 4 +--- lib/src/native/realm_bindings.dart | 17 +++++++++++++++++ lib/src/native/realm_core.dart | 7 ++++--- src/realm_dart.cpp | 4 ++++ src/realm_dart.h | 3 +++ 5 files changed, 29 insertions(+), 6 deletions(-) diff --git a/lib/src/decimal128.dart b/lib/src/decimal128.dart index 24f30b72a..887292bb5 100644 --- a/lib/src/decimal128.dart +++ b/lib/src/decimal128.dart @@ -152,7 +152,5 @@ class Decimal128 extends Comparable implements common.Decimal128 { extension Decimal128Internal on Decimal128 { realm_decimal128_t get value => _value; - static Decimal128 fromNative(realm_decimal128_t value) { - return Decimal128._(value); - } + static Decimal128 fromNative(realm_decimal128_t value) => Decimal128._(value); } diff --git a/lib/src/native/realm_bindings.dart b/lib/src/native/realm_bindings.dart index f82cce517..9f1e11bd9 100644 --- a/lib/src/native/realm_bindings.dart +++ b/lib/src/native/realm_bindings.dart @@ -3219,6 +3219,20 @@ class RealmLibrary { _realm_dart_decimal128_compare_toPtr .asFunction(); + realm_decimal128_t realm_dart_decimal128_copy( + realm_decimal128_t x, + ) { + return _realm_dart_decimal128_copy( + x, + ); + } + + late final _realm_dart_decimal128_copyPtr = _lookup< + ffi.NativeFunction>( + 'realm_dart_decimal128_copy'); + late final _realm_dart_decimal128_copy = _realm_dart_decimal128_copyPtr + .asFunction(); + realm_decimal128_t realm_dart_decimal128_divide( realm_decimal128_t x, realm_decimal128_t y, @@ -10722,6 +10736,9 @@ class _SymbolAddresses { ffi.Int Function(realm_decimal128_t, realm_decimal128_t)>> get realm_dart_decimal128_compare_to => _library._realm_dart_decimal128_compare_toPtr; + ffi.Pointer< + ffi.NativeFunction> + get realm_dart_decimal128_copy => _library._realm_dart_decimal128_copyPtr; ffi.Pointer< ffi.NativeFunction< realm_decimal128_t Function( diff --git a/lib/src/native/realm_core.dart b/lib/src/native/realm_core.dart index c54519e41..1f2b196d5 100644 --- a/lib/src/native/realm_core.dart +++ b/lib/src/native/realm_core.dart @@ -21,6 +21,7 @@ import 'dart:async'; import 'dart:convert'; import 'dart:ffi'; import 'dart:io'; +import 'dart:isolate'; import 'dart:typed_data'; import 'package:cancellation_token/cancellation_token.dart'; @@ -2904,13 +2905,13 @@ extension on Pointer { final nanoseconds = ref.values.timestamp.nanoseconds; return DateTime.fromMicrosecondsSinceEpoch(seconds * _microsecondsPerSecond + nanoseconds ~/ _nanosecondsPerMicrosecond, isUtc: true); case realm_value_type.RLM_TYPE_DECIMAL128: - throw Exception("Not implemented"); + var decimal = ref.values.decimal128; // NOTE: Does not copy the struct! + decimal = lib.realm_dart_decimal128_copy(decimal); // This is a workaround to that + return Decimal128Internal.fromNative(decimal); case realm_value_type.RLM_TYPE_OBJECT_ID: return ObjectId.fromBytes(cast().asTypedList(12)); case realm_value_type.RLM_TYPE_UUID: return Uuid.fromBytes(cast().asTypedList(16).buffer); - case realm_value_type.RLM_TYPE_DECIMAL128: - return Decimal128Internal.fromNative(ref.values.decimal128); default: throw RealmException("realm_value_type ${ref.type} not supported"); } diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index a129ff1bc..fdb188f13 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -214,6 +214,10 @@ RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t x) { return result; } +RLM_API realm_decimal128_t realm_dart_decimal128_copy(realm_decimal128_t x) { + return x; // work-around to Dart FFI issue +} + RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t x) { auto x_bid = to_BID_UINT128(x); BID_UINT128 result; diff --git a/src/realm_dart.h b/src/realm_dart.h index e50950af7..f8b3183f4 100644 --- a/src/realm_dart.h +++ b/src/realm_dart.h @@ -71,4 +71,7 @@ RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y); RLM_API int realm_dart_decimal128_compare_to(realm_decimal128_t x, realm_decimal128_t y); +// work-around for Dart FFI issue +RLM_API realm_decimal128_t realm_dart_decimal128_copy(realm_decimal128_t x); + #endif // REALM_DART_H \ No newline at end of file From 71f06284c51b80b08324d821b912c5aaf4595c6b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Tue, 9 May 2023 09:19:20 +0200 Subject: [PATCH 25/30] More tests --- test/dynamic_realm_test.dart | 11 +++++++++++ test/realm_object_test.dart | 2 ++ 2 files changed, 13 insertions(+) diff --git a/test/dynamic_realm_test.dart b/test/dynamic_realm_test.dart index d5e50397d..c03245368 100644 --- a/test/dynamic_realm_test.dart +++ b/test/dynamic_realm_test.dart @@ -144,6 +144,11 @@ Future main([List? args]) async { expect(actual.dynamic.get('nullableIntProp'), expected.nullableIntProp); expect(actual.dynamic.get('nullableIntProp'), expected.nullableIntProp); + expect(actual.dynamic.get('decimalProp'), expected.decimalProp); + expect(actual.dynamic.get('decimalProp'), expected.decimalProp); + expect(actual.dynamic.get('nullableDecimalProp'), expected.nullableDecimalProp); + expect(actual.dynamic.get('nullableDecimalProp'), expected.nullableDecimalProp); + dynamic actualDynamic = actual; expect(actualDynamic.stringProp, expected.stringProp); expect(actualDynamic.nullableStringProp, expected.nullableStringProp); @@ -159,6 +164,8 @@ Future main([List? args]) async { expect(actualDynamic.nullableUuidProp, expected.nullableUuidProp); expect(actualDynamic.intProp, expected.intProp); expect(actualDynamic.nullableIntProp, expected.nullableIntProp); + expect(actualDynamic.decimalProp, expected.decimalProp); + expect(actualDynamic.nullableDecimalProp, expected.nullableDecimalProp); } void _validateDynamicLists(RealmObject actual, AllCollections expected) { @@ -183,6 +190,9 @@ Future main([List? args]) async { expect(actual.dynamic.getList('ints'), expected.ints); expect(actual.dynamic.getList('ints'), expected.ints); + expect(actual.dynamic.getList('decimals'), expected.decimals); + expect(actual.dynamic.getList('decimals'), expected.decimals); + dynamic actualDynamic = actual; expect(actualDynamic.strings, expected.strings); expect(actualDynamic.bools, expected.bools); @@ -191,6 +201,7 @@ Future main([List? args]) async { expect(actualDynamic.objectIds, expected.objectIds); expect(actualDynamic.uuids, expected.uuids); expect(actualDynamic.ints, expected.ints); + expect(actualDynamic.decimals, expected.decimals); } for (var isDynamic in [true, false]) { diff --git a/test/realm_object_test.dart b/test/realm_object_test.dart index d115b394d..6dd476bab 100644 --- a/test/realm_object_test.dart +++ b/test/realm_object_test.dart @@ -575,6 +575,7 @@ Future main([List? args]) async { object.objectIdProp = objectId; object.uuidProp = uuid; object.intProp = 5; + object.decimalProp = Decimal128.one; }); expect(object.stringProp, 'abc'); @@ -584,6 +585,7 @@ Future main([List? args]) async { expect(object.objectIdProp, objectId); expect(object.uuidProp, uuid); expect(object.intProp, 5); + expect(object.decimalProp, Decimal128.one); }); test('RealmObject.freeze when typed returns typed frozen object', () { From 6c99a27e0d20986299e182fe3e4aa6d161430889 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Tue, 9 May 2023 09:32:15 +0200 Subject: [PATCH 26/30] Support Decimal128 in mixed + tests --- common/lib/src/realm_types.dart | 4 ++-- test/realm_value_test.dart | 7 +++++++ 2 files changed, 9 insertions(+), 2 deletions(-) diff --git a/common/lib/src/realm_types.dart b/common/lib/src/realm_types.dart index 3f4e1f57a..907e9f8f3 100644 --- a/common/lib/src/realm_types.dart +++ b/common/lib/src/realm_types.dart @@ -158,7 +158,7 @@ class RealmValue { const RealmValue.realmObject(RealmObjectMarker o) : this._(o); const RealmValue.dateTime(DateTime timestamp) : this._(timestamp); const RealmValue.objectId(ObjectId id) : this._(id); - // const RealmValue.decimal128(Decimal128 decimal) : this._(decimal); // not supported yet + const RealmValue.decimal128(Decimal128 decimal) : this._(decimal); const RealmValue.uuid(Uuid uuid) : this._(uuid); /// Will throw [ArgumentError] @@ -172,7 +172,7 @@ class RealmValue { o is RealmObjectMarker || o is DateTime || o is ObjectId || - // o is Decimal128 || // not supported yet + o is Decimal128 || o is Uuid) { return RealmValue._(o); } else { diff --git a/test/realm_value_test.dart b/test/realm_value_test.dart index 77302cd5f..d8c0ffae0 100644 --- a/test/realm_value_test.dart +++ b/test/realm_value_test.dart @@ -58,6 +58,7 @@ Future main([List? args]) async { now, ObjectId.fromTimestamp(now), Uuid.v4(), + Decimal128.fromDouble(128.128), ]; for (final x in values) { @@ -118,6 +119,9 @@ Future main([List? args]) async { case Uuid: expect(value, isA()); break; + case Decimal128: + expect(value, isA()); + break; default: fail('${something.oneAny} not handled correctly in switch'); } @@ -145,6 +149,8 @@ Future main([List? args]) async { expect(type, Uuid); } else if (value is ObjectId) { expect(type, ObjectId); + } else if (value is Decimal128) { + expect(type, Decimal128); } else if (value is AnythingGoes) { expect(type, AnythingGoes); } else if (value is Stuff) { @@ -200,6 +206,7 @@ Future main([List? args]) async { now, ObjectId.fromTimestamp(now), Uuid.v4(), + Decimal128.fromInt(128), ]; final config = Configuration.local([AnythingGoes.schema, Stuff.schema]); From a137cae2597689f62bba3a4fb2b5c2e3348a0ca3 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Fri, 12 May 2023 11:53:51 +0200 Subject: [PATCH 27/30] Change libraryVersion regex --- .github/workflows/prepare-release.yml | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/.github/workflows/prepare-release.yml b/.github/workflows/prepare-release.yml index c15237859..f33886658 100644 --- a/.github/workflows/prepare-release.yml +++ b/.github/workflows/prepare-release.yml @@ -45,8 +45,8 @@ jobs: id: update-libraryVersion uses: jacobtomlinson/gha-find-replace@b76729678e8d52dadb12e0e16454a93e301a919d #! 2.0.0 with: - find: "static const libraryVersion = '[^']*';" - replace: "static const libraryVersion = '${{ steps.update-changelog.outputs.new-version }}';" + find: "const libraryVersion = '[^']*';" + replace: "const libraryVersion = '${{ steps.update-changelog.outputs.new-version }}';" include: 'lib/src/native/realm_core.dart' - name: Make sure we updated libraryVersion in realm_core.dart From 943205e26b9b6e03bcd07128fe7c85392cc5e617 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Fri, 12 May 2023 11:52:52 +0200 Subject: [PATCH 28/30] Move decimal128.dart to native as parts file of realm_core.dart (EXPERIMENT) --- lib/src/{ => native}/decimal128.dart | 39 ++++++++++++---------------- lib/src/native/realm_core.dart | 9 +++---- lib/src/realm_class.dart | 2 +- test/decimal128_test.dart | 2 +- 4 files changed, 22 insertions(+), 30 deletions(-) rename lib/src/{ => native}/decimal128.dart (75%) diff --git a/lib/src/decimal128.dart b/lib/src/native/decimal128.dart similarity index 75% rename from lib/src/decimal128.dart rename to lib/src/native/decimal128.dart index 887292bb5..ff2432e2e 100644 --- a/lib/src/decimal128.dart +++ b/lib/src/native/decimal128.dart @@ -16,14 +16,7 @@ // //////////////////////////////////////////////////////////////////////////////// -import 'dart:convert'; -import 'dart:ffi'; - -import 'package:ffi/ffi.dart'; - -import 'native/realm_bindings.dart'; -import 'native/realm_core.dart'; -import 'package:realm_common/realm_common.dart' as common; +part of 'realm_core.dart'; /// A 128-bit decimal floating point number. class Decimal128 extends Comparable implements common.Decimal128 { @@ -37,7 +30,7 @@ class Decimal128 extends Comparable implements common.Decimal128 { static final ten = Decimal128.fromInt(10); /// The value NaN. - static final nan = Decimal128._(lib.realm_dart_decimal128_nan()); + static final nan = Decimal128._(_realmLib.realm_dart_decimal128_nan()); /// The value +Inf. static final infinity = one / zero; // +Inf @@ -55,7 +48,7 @@ class Decimal128 extends Comparable implements common.Decimal128 { static Decimal128? tryParse(String source) { if (!_validInput.hasMatch(source)) return null; return using((arena) { - final result = lib.realm_dart_decimal128_from_string(source.toNativeUtf8(allocator: arena).cast()); + final result = _realmLib.realm_dart_decimal128_from_string(source.toCharPtr(arena)); return Decimal128._(result); }); } @@ -67,7 +60,7 @@ class Decimal128 extends Comparable implements common.Decimal128 { /// Converts a `int` into a [Decimal128]. factory Decimal128.fromInt(int value) { - return Decimal128._(lib.realm_dart_decimal128_from_int64(value)); + return Decimal128._(_realmLib.realm_dart_decimal128_from_int64(value)); } /// Converts a `double` into a [Decimal128]. @@ -76,30 +69,30 @@ class Decimal128 extends Comparable implements common.Decimal128 { } /// Returns `true` if `this` is NaN. - bool get isNaN => lib.realm_dart_decimal128_is_nan(_value); + bool get isNaN => _realmLib.realm_dart_decimal128_is_nan(_value); /// Adds `this` with `other` and returns a new [Decimal128]. Decimal128 operator +(Decimal128 other) { - return Decimal128._(lib.realm_dart_decimal128_add(_value, other._value)); + return Decimal128._(_realmLib.realm_dart_decimal128_add(_value, other._value)); } /// Subtracts `other` from `this` and returns a new [Decimal128]. Decimal128 operator -(Decimal128 other) { - return Decimal128._(lib.realm_dart_decimal128_subtract(_value, other._value)); + return Decimal128._(_realmLib.realm_dart_decimal128_subtract(_value, other._value)); } /// Multiplies `this` with `other` and returns a new [Decimal128]. Decimal128 operator *(Decimal128 other) { - return Decimal128._(lib.realm_dart_decimal128_multiply(_value, other._value)); + return Decimal128._(_realmLib.realm_dart_decimal128_multiply(_value, other._value)); } /// Divides `this` by `other` and returns a new [Decimal128]. Decimal128 operator /(Decimal128 other) { - return Decimal128._(lib.realm_dart_decimal128_divide(_value, other._value)); + return Decimal128._(_realmLib.realm_dart_decimal128_divide(_value, other._value)); } /// Negates `this` and returns a new [Decimal128]. - Decimal128 operator -() => Decimal128._(lib.realm_dart_decimal128_negate(_value)); + Decimal128 operator -() => Decimal128._(_realmLib.realm_dart_decimal128_negate(_value)); /// Returns the absolute value of `this`. Decimal128 abs() => this < zero ? -this : this; @@ -111,14 +104,14 @@ class Decimal128 extends Comparable implements common.Decimal128 { // WARNING: Don't use identical to ensure nan != nan, // if (identical(this, other)) return true; if (other is Decimal128) { - return lib.realm_dart_decimal128_equal(_value, other._value); + return _realmLib.realm_dart_decimal128_equal(_value, other._value); } return false; } /// Returns `true` if `this` is less than `other`. bool operator <(Decimal128 other) { - return lib.realm_dart_decimal128_less_than(_value, other._value); + return _realmLib.realm_dart_decimal128_less_than(_value, other._value); } /// Returns `true` if `this` is less than or equal to `other`. @@ -126,27 +119,27 @@ class Decimal128 extends Comparable implements common.Decimal128 { /// Returns `true` if `this` is greater than `other`. bool operator >(Decimal128 other) { - return lib.realm_dart_decimal128_greater_than(_value, other._value); + return _realmLib.realm_dart_decimal128_greater_than(_value, other._value); } /// Returns `true` if `this` is greater than or equal to `other`. bool operator >=(Decimal128 other) => compareTo(other) >= 0; /// Converts `this` to an `int`. Possibly loosing precision. - int toInt() => lib.realm_dart_decimal128_to_int64(_value); + int toInt() => _realmLib.realm_dart_decimal128_to_int64(_value); /// String representation of `this`. @override String toString() { return using((arena) { - final realmString = lib.realm_dart_decimal128_to_string(_value); + final realmString = _realmLib.realm_dart_decimal128_to_string(_value); return ascii.decode(realmString.data.cast().asTypedList(realmString.size)); }); } /// Compares `this` to `other`. @override - int compareTo(Decimal128 other) => lib.realm_dart_decimal128_compare_to(_value, other._value); + int compareTo(Decimal128 other) => _realmLib.realm_dart_decimal128_compare_to(_value, other._value); } extension Decimal128Internal on Decimal128 { diff --git a/lib/src/native/realm_core.dart b/lib/src/native/realm_core.dart index 1f2b196d5..95714e7d9 100644 --- a/lib/src/native/realm_core.dart +++ b/lib/src/native/realm_core.dart @@ -21,7 +21,6 @@ import 'dart:async'; import 'dart:convert'; import 'dart:ffi'; import 'dart:io'; -import 'dart:isolate'; import 'dart:typed_data'; import 'package:cancellation_token/cancellation_token.dart'; @@ -30,12 +29,12 @@ import 'package:ffi/ffi.dart' hide StringUtf8Pointer, StringUtf16Pointer; import 'package:logging/logging.dart'; import 'package:path/path.dart' as path; import 'package:realm_common/realm_common.dart' hide Decimal128; +import 'package:realm_common/realm_common.dart' as common show Decimal128; import '../app.dart'; import '../collections.dart'; import '../configuration.dart'; import '../credentials.dart'; -import '../decimal128.dart'; import '../init.dart'; import '../list.dart'; import '../migration.dart'; @@ -49,6 +48,8 @@ import '../user.dart'; import '../set.dart'; import 'realm_bindings.dart'; +part 'decimal128.dart'; + const bugInTheSdkMessage = "This is likely a bug in the Realm SDK - please file an issue at https://github.com/realm/realm-dart/issues"; final _realmLib = () { @@ -66,8 +67,6 @@ final _realmLib = () { const libraryVersion = '1.0.3'; late String nativeLibraryVersion; -final lib = _realmLib; - final realmCore = _RealmCore(); class _RealmCore { @@ -2906,7 +2905,7 @@ extension on Pointer { return DateTime.fromMicrosecondsSinceEpoch(seconds * _microsecondsPerSecond + nanoseconds ~/ _nanosecondsPerMicrosecond, isUtc: true); case realm_value_type.RLM_TYPE_DECIMAL128: var decimal = ref.values.decimal128; // NOTE: Does not copy the struct! - decimal = lib.realm_dart_decimal128_copy(decimal); // This is a workaround to that + decimal = _realmLib.realm_dart_decimal128_copy(decimal); // This is a workaround to that return Decimal128Internal.fromNative(decimal); case realm_value_type.RLM_TYPE_OBJECT_ID: return ObjectId.fromBytes(cast().asTypedList(12)); diff --git a/lib/src/realm_class.dart b/lib/src/realm_class.dart index 7e54fda54..0556e0f84 100644 --- a/lib/src/realm_class.dart +++ b/lib/src/realm_class.dart @@ -88,7 +88,6 @@ export "configuration.dart" SyncWebSocketError, SyncSessionError; export 'credentials.dart' show AuthProviderType, Credentials, EmailPasswordAuthProvider; -export 'decimal128.dart' show Decimal128; export 'list.dart' show RealmList, RealmListOfObject, RealmListChanges, ListExtension; export 'set.dart' show RealmSet, RealmSetChanges; export 'migration.dart' show Migration; @@ -122,6 +121,7 @@ export 'session.dart' SyncSessionErrorCode; export 'subscription.dart' show Subscription, SubscriptionSet, SubscriptionSetState, MutableSubscriptionSet; export 'user.dart' show User, UserState, ApiKeyClient, UserIdentity, ApiKey, FunctionsClient; +export 'native/realm_core.dart' show Decimal128; /// A [Realm] instance represents a `Realm` database. /// diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index 020bc1b78..b10c7e872 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -19,7 +19,7 @@ import 'dart:math'; import 'package:meta/meta.dart'; -import '../lib/src/decimal128.dart'; +import '../lib/src/native/realm_core.dart'; import 'package:test/test.dart'; const int defaultTimes = 100000; From cfebff6b63fc6e31e8ff5b0273711d9008bf0c71 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Mon, 15 May 2023 20:12:00 +0200 Subject: [PATCH 29/30] PR feedback --- common/lib/src/realm_types.dart | 2 +- ffigen/config.yaml | 12 +-- ffigen/realm_dart_decimal128.h | 1 + lib/src/native/realm_core.dart | 4 +- src/CMakeLists.txt | 2 + src/realm_dart.cpp | 152 -------------------------------- src/realm_dart.h | 20 ----- src/realm_dart_decimal128.cpp | 149 +++++++++++++++++++++++++++++++ src/realm_dart_decimal128.h | 44 +++++++++ test/decimal128_test.dart | 14 +-- 10 files changed, 214 insertions(+), 186 deletions(-) create mode 120000 ffigen/realm_dart_decimal128.h create mode 100644 src/realm_dart_decimal128.cpp create mode 100644 src/realm_dart_decimal128.h diff --git a/common/lib/src/realm_types.dart b/common/lib/src/realm_types.dart index 907e9f8f3..0ae19d1bf 100644 --- a/common/lib/src/realm_types.dart +++ b/common/lib/src/realm_types.dart @@ -101,7 +101,7 @@ class RealmStateError extends StateError implements RealmError { } /// @nodoc -abstract class Decimal128 {} // TODO Support decimal128 datatype https://github.com/realm/realm-dart/issues/725 +abstract class Decimal128 {} /// @nodoc abstract class RealmObjectBaseMarker {} diff --git a/ffigen/config.yaml b/ffigen/config.yaml index 591384b1b..effbe66ca 100644 --- a/ffigen/config.yaml +++ b/ffigen/config.yaml @@ -6,11 +6,13 @@ headers: entry-points: - 'realm.h' - 'realm_dart.h' + - 'realm_dart_decimal128.h' - 'realm_dart_scheduler.h' - 'realm_dart_sync.h' - include-directives: #generate only for these headers + include-directives: # generate only for these headers - 'realm.h' - 'realm_dart.h' + - 'realm_dart_decimal128.h' - 'realm_dart_scheduler.h' - 'realm_dart_sync.h' compiler-opts: @@ -21,8 +23,8 @@ compiler-opts: sort: true functions: exclude: - - '_.*' #exclude all starting with _ - - 'Dart_.*' #exlude all starting with Dart_ + - '_.*' # exclude all starting with _ + - 'Dart_.*' # exclude all starting with Dart_ symbol-address: include: - 'realm_dart_.*' @@ -30,11 +32,11 @@ functions: structs: exclude: - '_.*' - - 'Dart_.*' #exlude all starting with Dart_ + - 'Dart_.*' # exclude all starting with Dart_ globals: exclude: - '_.*' - - 'RLM_.*' #exlude RLM_ globals constants since they are not exported from binary + - 'RLM_.*' # exclude RLM_ globals constants since they are not exported from binary unions: exclude: - '_.*' diff --git a/ffigen/realm_dart_decimal128.h b/ffigen/realm_dart_decimal128.h new file mode 120000 index 000000000..dad18748a --- /dev/null +++ b/ffigen/realm_dart_decimal128.h @@ -0,0 +1 @@ +../src/realm_dart_decimal128.h \ No newline at end of file diff --git a/lib/src/native/realm_core.dart b/lib/src/native/realm_core.dart index 95714e7d9..1a778ad0f 100644 --- a/lib/src/native/realm_core.dart +++ b/lib/src/native/realm_core.dart @@ -54,7 +54,7 @@ const bugInTheSdkMessage = "This is likely a bug in the Realm SDK - please file final _realmLib = () { final result = RealmLibrary(initRealm()); - nativeLibraryVersion = result.realm_dart_library_version().cast().toDartString(); + final nativeLibraryVersion = result.realm_dart_library_version().cast().toDartString(); if (libraryVersion != nativeLibraryVersion) { final additionMessage = isFlutterPlatform ? bugInTheSdkMessage : "Did you forget to run `dart run realm_dart install` after upgrading the realm_dart package?"; @@ -65,8 +65,6 @@ final _realmLib = () { // stamped into the library by the build system (see prepare-release.yml) const libraryVersion = '1.0.3'; -late String nativeLibraryVersion; - final realmCore = _RealmCore(); class _RealmCore { diff --git a/src/CMakeLists.txt b/src/CMakeLists.txt index 413309149..4c7cdf064 100644 --- a/src/CMakeLists.txt +++ b/src/CMakeLists.txt @@ -9,6 +9,7 @@ add_subdirectory(dart-dl) set(SOURCES realm_dart.cpp + realm_dart_decimal128.cpp realm_dart_scheduler.cpp realm_dart_sync.cpp realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid128_noncomp.c @@ -18,6 +19,7 @@ set(HEADERS realm_dart.h realm_dart.hpp realm_dart_scheduler.h + realm_dart_scheduler.h realm_dart_sync.h realm-core/src/realm.h ) diff --git a/src/realm_dart.cpp b/src/realm_dart.cpp index fdb188f13..fe85af72d 100644 --- a/src/realm_dart.cpp +++ b/src/realm_dart.cpp @@ -23,8 +23,6 @@ #include "realm_dart.h" #include "realm_dart.hpp" -#include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_conf.h" -#include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_functions.h" #if REALM_ARCHITECTURE_ARM32 || REALM_ARCHITECTURE_ARM64 || REALM_ARCHITECTURE_X86_32 || REALM_ARCHITECTURE_X86_64 #if REALM_ARCHITECTURE_ARM32 @@ -55,9 +53,6 @@ RLM_API void realm_dart_initializeDartApiDL(void* data) { Dart_InitializeApiDL(data); } -using namespace realm; -using namespace realm::c_api; - class WeakHandle { public: WeakHandle(Dart_Handle handle): m_weakHandle(Dart_NewWeakPersistentHandle_DL(handle, this, 1, finalize_handle)) { @@ -153,150 +148,3 @@ RLM_API void realm_set_auto_refresh(realm_t* realm, bool enable) { RLM_API const char* realm_get_library_cpu_arch() { return cpuArch.c_str(); } - -namespace { -realm_decimal128_t to_decimal128(const BID_UINT128& value) -{ - realm_decimal128_t result; - memcpy(&result, &value, sizeof(BID_UINT128)); - return result; -} - -BID_UINT128 to_BID_UINT128(const realm_decimal128_t& value) -{ - BID_UINT128 result; - memcpy(&result, &value, sizeof(BID_UINT128)); - return result; -} -} - -RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string) { - unsigned int flags = 0; - BID_UINT128 result; - bid128_from_string(&result, const_cast(string), &flags); - return to_decimal128(result); -} - -RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x) { - auto x_bid = to_BID_UINT128(x); - // This buffer is reused between calls, hence the static keyword - static char buffer[34]; // 34 bytes is the maximum length of a string representation of a decimal128 - unsigned int flags = 0; - bid128_to_string(buffer, &x_bid, &flags); - return realm_string_t{ buffer, strlen(buffer) }; -} - -RLM_API realm_decimal128_t realm_dart_decimal128_nan() { - BID_UINT128 result; - bid128_nan(&result, "+NaN"); - return to_decimal128(result); -} - -RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t x) { - auto x_bid = to_BID_UINT128(x); - int result; - bid128_isNaN(&result, &x_bid); - return result; -} - -RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t x) { - BID_UINT128 result; - BID_SINT64 y = x; - bid128_from_int64(&result, &y); - return to_decimal128(result); -} - -RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t x) { - auto x_bid = to_BID_UINT128(x); - BID_SINT64 result; - unsigned int flags = 0; - bid128_to_int64_int(&result, &x_bid, &flags); - return result; -} - -RLM_API realm_decimal128_t realm_dart_decimal128_copy(realm_decimal128_t x) { - return x; // work-around to Dart FFI issue -} - -RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t x) { - auto x_bid = to_BID_UINT128(x); - BID_UINT128 result; - bid128_negate(&result, &x_bid); - return to_decimal128(result); -} - -RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y) { - auto l = to_BID_UINT128(x); - auto r = to_BID_UINT128(y); - BID_UINT128 result; - unsigned int flags = 0; - bid128_add(&result, &l, &r, &flags); - return to_decimal128(result); -} - -RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y) { - auto l = to_BID_UINT128(x); - auto r = to_BID_UINT128(y); - BID_UINT128 result; - unsigned int flags = 0; - bid128_sub(&result, &l, &r, &flags); - return to_decimal128(result); -} - -RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y) { - auto l = to_BID_UINT128(x); - auto r = to_BID_UINT128(y); - BID_UINT128 result; - unsigned int flags = 0; - bid128_mul(&result, &l, &r, &flags); - return to_decimal128(result); -} - -RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, realm_decimal128_t y) { - auto l = to_BID_UINT128(x); - auto r = to_BID_UINT128(y); - BID_UINT128 result; - unsigned int flags = 0; - bid128_div(&result, &l, &r, &flags); - return to_decimal128(result); -} - -RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y) { - auto l = to_BID_UINT128(x); - auto r = to_BID_UINT128(y); - int result; - unsigned int flags = 0; - bid128_quiet_equal(&result, &l, &r, &flags); - return result; -} - -RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y) { - auto l = to_BID_UINT128(x); - auto r = to_BID_UINT128(y); - int result; - unsigned int flags = 0; - bid128_quiet_less(&result, &l, &r, &flags); - return result; -} - -RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y) { - auto l = to_BID_UINT128(x); - auto r = to_BID_UINT128(y); - int result; - unsigned int flags = 0; - bid128_quiet_greater(&result, &l, &r, &flags); - return result; -} - -RLM_API int realm_dart_decimal128_compare_to(realm_decimal128_t x, realm_decimal128_t y) { - auto l = to_BID_UINT128(x); - auto r = to_BID_UINT128(y); - int lr, rl; - bid128_totalOrder(&lr, &l, &r); - bid128_totalOrder(&rl, &r, &l); - if (lr && rl) return 0; - if (lr) return -1; - if (rl) return 1; - return 0; -} - diff --git a/src/realm_dart.h b/src/realm_dart.h index f8b3183f4..3e4f8d844 100644 --- a/src/realm_dart.h +++ b/src/realm_dart.h @@ -54,24 +54,4 @@ RLM_API void* realm_attach_finalizer(Dart_Handle handle, void* realmPtr, int siz RLM_API void realm_detach_finalizer(void* finalizableHandle, Dart_Handle handle); RLM_API void realm_set_auto_refresh(realm_t* realm, bool enable); -RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string); -RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x); - -RLM_API realm_decimal128_t realm_dart_decimal128_nan(); -RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t x); -RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t low); -RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t x); -RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t x); -RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y); -RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y); -RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y); -RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, realm_decimal128_t y); -RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y); -RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y); -RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y); -RLM_API int realm_dart_decimal128_compare_to(realm_decimal128_t x, realm_decimal128_t y); - -// work-around for Dart FFI issue -RLM_API realm_decimal128_t realm_dart_decimal128_copy(realm_decimal128_t x); - #endif // REALM_DART_H \ No newline at end of file diff --git a/src/realm_dart_decimal128.cpp b/src/realm_dart_decimal128.cpp new file mode 100644 index 000000000..97695405d --- /dev/null +++ b/src/realm_dart_decimal128.cpp @@ -0,0 +1,149 @@ +#include "realm_dart.hpp" +#include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_conf.h" +#include "realm-core/src/external/IntelRDFPMathLib20U2/LIBRARY/src/bid_functions.h" + +namespace { +realm_decimal128_t to_decimal128(const BID_UINT128& value) +{ + realm_decimal128_t result; + memcpy(&result, &value, sizeof(BID_UINT128)); + return result; +} + +BID_UINT128 to_BID_UINT128(const realm_decimal128_t& value) +{ + BID_UINT128 result; + memcpy(&result, &value, sizeof(BID_UINT128)); + return result; +} +} + +RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string) { + unsigned int flags = 0; + BID_UINT128 result; + bid128_from_string(&result, const_cast(string), &flags); + return to_decimal128(result); +} + +RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x) { + auto x_bid = to_BID_UINT128(x); + // This buffer is reused between calls, hence the static keyword + static char buffer[34]; // 34 bytes is the maximum length of a string representation of a decimal128 + unsigned int flags = 0; + bid128_to_string(buffer, &x_bid, &flags); + return realm_string_t{ buffer, strlen(buffer) }; +} + +RLM_API realm_decimal128_t realm_dart_decimal128_nan() { + BID_UINT128 result; + bid128_nan(&result, "+NaN"); + return to_decimal128(result); +} + +RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t x) { + auto x_bid = to_BID_UINT128(x); + int result; + bid128_isNaN(&result, &x_bid); + return result; +} + +RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t x) { + BID_UINT128 result; + BID_SINT64 y = x; + bid128_from_int64(&result, &y); + return to_decimal128(result); +} + +RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t x) { + auto x_bid = to_BID_UINT128(x); + BID_SINT64 result; + unsigned int flags = 0; + bid128_to_int64_int(&result, &x_bid, &flags); + return result; +} + +RLM_API realm_decimal128_t realm_dart_decimal128_copy(realm_decimal128_t x) { + return x; // work-around to Dart FFI issue +} + +RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t x) { + auto x_bid = to_BID_UINT128(x); + BID_UINT128 result; + bid128_negate(&result, &x_bid); + return to_decimal128(result); +} + +RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y) { + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + BID_UINT128 result; + unsigned int flags = 0; + bid128_add(&result, &l, &r, &flags); + return to_decimal128(result); +} + +RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y) { + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + BID_UINT128 result; + unsigned int flags = 0; + bid128_sub(&result, &l, &r, &flags); + return to_decimal128(result); +} + +RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y) { + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + BID_UINT128 result; + unsigned int flags = 0; + bid128_mul(&result, &l, &r, &flags); + return to_decimal128(result); +} + +RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, realm_decimal128_t y) { + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + BID_UINT128 result; + unsigned int flags = 0; + bid128_div(&result, &l, &r, &flags); + return to_decimal128(result); +} + +RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y) { + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + int result; + unsigned int flags = 0; + bid128_quiet_equal(&result, &l, &r, &flags); + return result; +} + +RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y) { + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + int result; + unsigned int flags = 0; + bid128_quiet_less(&result, &l, &r, &flags); + return result; +} + +RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y) { + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + int result; + unsigned int flags = 0; + bid128_quiet_greater(&result, &l, &r, &flags); + return result; +} + +RLM_API int realm_dart_decimal128_compare_to(realm_decimal128_t x, realm_decimal128_t y) { + auto l = to_BID_UINT128(x); + auto r = to_BID_UINT128(y); + int lr, rl; + bid128_totalOrder(&lr, &l, &r); + bid128_totalOrder(&rl, &r, &l); + if (lr && rl) return 0; + if (lr) return -1; + if (rl) return 1; + return 0; +} diff --git a/src/realm_dart_decimal128.h b/src/realm_dart_decimal128.h new file mode 100644 index 000000000..5347de0b0 --- /dev/null +++ b/src/realm_dart_decimal128.h @@ -0,0 +1,44 @@ +//////////////////////////////////////////////////////////////////////////////// +// +// Copyright 2023 Realm Inc. +// +// 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. +// +//////////////////////////////////////////////////////////////////////////////// + +#ifndef REALM_DART_DECIMAL128_H +#define REALM_DART_DECIMAL128_H + +#include + +RLM_API realm_decimal128_t realm_dart_decimal128_from_string(const char* string); +RLM_API realm_string_t realm_dart_decimal128_to_string(realm_decimal128_t x); + +RLM_API realm_decimal128_t realm_dart_decimal128_nan(); +RLM_API bool realm_dart_decimal128_is_nan(realm_decimal128_t x); +RLM_API realm_decimal128_t realm_dart_decimal128_from_int64(int64_t low); +RLM_API int64_t realm_dart_decimal128_to_int64(realm_decimal128_t x); +RLM_API realm_decimal128_t realm_dart_decimal128_negate(realm_decimal128_t x); +RLM_API realm_decimal128_t realm_dart_decimal128_add(realm_decimal128_t x, realm_decimal128_t y); +RLM_API realm_decimal128_t realm_dart_decimal128_subtract(realm_decimal128_t x, realm_decimal128_t y); +RLM_API realm_decimal128_t realm_dart_decimal128_multiply(realm_decimal128_t x, realm_decimal128_t y); +RLM_API realm_decimal128_t realm_dart_decimal128_divide(realm_decimal128_t x, realm_decimal128_t y); +RLM_API bool realm_dart_decimal128_equal(realm_decimal128_t x, realm_decimal128_t y); +RLM_API bool realm_dart_decimal128_less_than(realm_decimal128_t x, realm_decimal128_t y); +RLM_API bool realm_dart_decimal128_greater_than(realm_decimal128_t x, realm_decimal128_t y); +RLM_API int realm_dart_decimal128_compare_to(realm_decimal128_t x, realm_decimal128_t y); + +// work-around for Dart FFI issue +RLM_API realm_decimal128_t realm_dart_decimal128_copy(realm_decimal128_t x); + +#endif // REALM_DART_DECIMAL128_H \ No newline at end of file diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index b10c7e872..d00e875d8 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -19,8 +19,10 @@ import 'dart:math'; import 'package:meta/meta.dart'; +import 'package:test/expect.dart' hide throws; + import '../lib/src/native/realm_core.dart'; -import 'package:test/test.dart'; +import 'test.dart'; const int defaultTimes = 100000; @@ -32,14 +34,14 @@ void repeat(dynamic Function() body, [int times = defaultTimes]) { @isTest void repeatTest(String description, dynamic Function(Decimal128 x, int xInt, Decimal128 y, int yInt) body, [int times = defaultTimes]) { - final r = Random(42); // use a fixed seed to make tests deterministic - test('$description ($times variations)', () { + final random = Random(42); // use a fixed seed to make tests deterministic + test(description, () { repeat( () { // 2^31 ensures x * y doesn't overflow - var xInt = r.nextInt(1 << 31); + var xInt = random.nextInt(1 << 31); final x = Decimal128.fromInt(xInt); - var yInt = r.nextInt(1 << 31); + var yInt = random.nextInt(1 << 31); final y = Decimal128.fromInt(yInt); body(x, xInt, y, yInt); @@ -50,6 +52,8 @@ void repeatTest(String description, dynamic Function(Decimal128 x, int xInt, Dec } Future main([List? args]) async { + await setupTests(args); + test('Decimal128.nan', () { // Test that we mimic the behavior of Dart's double wrt. NaN and // <, <=, >, >=. Unlike compareTo (which define a total order) these From cf719b985e3b7e43c63af89697daccfc34403b41 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Kasper=20Overg=C3=A5rd=20Nielsen?= Date: Tue, 16 May 2023 13:13:41 +0200 Subject: [PATCH 30/30] PR feedback (more tests) --- test/decimal128_test.dart | 26 ++++++++++++++-------- test/results_test.dart | 22 +++++++++++++++++++ test/test.dart | 6 +++++ test/test.g.dart | 46 +++++++++++++++++++++++++++++++++++++++ 4 files changed, 91 insertions(+), 9 deletions(-) diff --git a/test/decimal128_test.dart b/test/decimal128_test.dart index d00e875d8..eab5de988 100644 --- a/test/decimal128_test.dart +++ b/test/decimal128_test.dart @@ -242,25 +242,33 @@ Future main([List? args]) async { }); repeatTest('Decimal128.compareTo + <, <=, ==, !=, >=, >', (x, xInt, y, yInt) { + expect(x.compareTo(x), 0); expect(x.compareTo(y), -(y.compareTo(x))); expect(x.compareTo(y), xInt.compareTo(yInt)); - expect(x == y, y == x); - expect(x == y, xInt == yInt); + + expect(x < x, isFalse); expect(x < y, y > x); expect(x < y, xInt < yInt); + + expect(x <= x, isTrue); expect(x <= y, y >= x); expect(x <= y, xInt <= yInt); - expect(x > y, y < x); - expect(x > y, xInt > yInt); - expect(x >= y, y <= x); - expect(x >= y, xInt >= yInt); - expect(x.compareTo(x), 0); expect(x == x, isTrue); - expect(x < x, isFalse); - expect(x <= x, isTrue); + expect(x == y, y == x); + expect(x == y, xInt == yInt); + + expect(x != x, isFalse); + expect(x != y, y != x); + expect(x != y, xInt != yInt); + expect(x > x, isFalse); + expect(x > y, y < x); + expect(x > y, xInt > yInt); + expect(x >= x, isTrue); + expect(x >= y, y <= x); + expect(x >= y, xInt >= yInt); }); repeatTest('Decimal128.toInt/fromInt roundtrip', (x, xInt, y, yInt) { diff --git a/test/results_test.dart b/test/results_test.dart index 2008247b1..5ec2ae34d 100644 --- a/test/results_test.dart +++ b/test/results_test.dart @@ -662,4 +662,26 @@ Future main([List? args]) async { if (count > 1) fail('Should only receive one event'); } }); + + test('query by condition on decimal128', () { + final config = Configuration.local([ObjectWithDecimal.schema]); + final realm = getRealm(config); + + final small = Decimal128.fromInt(1); + final big = Decimal128.fromInt(1 << 62) * Decimal128.fromInt(1 << 62); + + realm.write(() => realm.addAll([ + ObjectWithDecimal(small), + ObjectWithDecimal(big), + ])); + + expect(realm.query(r'decimal < $0', [small]), isEmpty); + expect(realm.query(r'decimal < $0', [big]).map((e) => e.decimal), [small]); + expect(realm.query(r'decimal <= $0', [big]).map((e) => e.decimal), [small, big]); + expect(realm.query(r'decimal == $0', [small]).map((e) => e.decimal), [small]); + expect(realm.query(r'decimal == $0', [big]).map((e) => e.decimal), [big]); + expect(realm.query(r'decimal > $0', [big]), isEmpty); + expect(realm.query(r'decimal > $0', [small]).map((e) => e.decimal), [big]); + expect(realm.query(r'decimal >= $0', [small]).map((e) => e.decimal), [small, big]); + }); } diff --git a/test/test.dart b/test/test.dart index 49de05721..465b47b4f 100644 --- a/test/test.dart +++ b/test/test.dart @@ -308,6 +308,12 @@ class _RecursiveEmbedded3 { late String value; } +@RealmModel() +class _ObjectWithDecimal { + late Decimal128 decimal; + Decimal128? nullableDecimal; +} + String? testName; Map arguments = {}; final baasApps = {}; diff --git a/test/test.g.dart b/test/test.g.dart index a472240ec..7805d4c71 100644 --- a/test/test.g.dart +++ b/test/test.g.dart @@ -1942,3 +1942,49 @@ class RecursiveEmbedded3 extends _RecursiveEmbedded3 ]); } } + +class ObjectWithDecimal extends _ObjectWithDecimal + with RealmEntity, RealmObjectBase, RealmObject { + ObjectWithDecimal( + Decimal128 decimal, { + Decimal128? nullableDecimal, + }) { + RealmObjectBase.set(this, 'decimal', decimal); + RealmObjectBase.set(this, 'nullableDecimal', nullableDecimal); + } + + ObjectWithDecimal._(); + + @override + Decimal128 get decimal => + RealmObjectBase.get(this, 'decimal') as Decimal128; + @override + set decimal(Decimal128 value) => RealmObjectBase.set(this, 'decimal', value); + + @override + Decimal128? get nullableDecimal => + RealmObjectBase.get(this, 'nullableDecimal') as Decimal128?; + @override + set nullableDecimal(Decimal128? value) => + RealmObjectBase.set(this, 'nullableDecimal', value); + + @override + Stream> get changes => + RealmObjectBase.getChanges(this); + + @override + ObjectWithDecimal freeze() => + RealmObjectBase.freezeObject(this); + + static SchemaObject get schema => _schema ??= _initSchema(); + static SchemaObject? _schema; + static SchemaObject _initSchema() { + RealmObjectBase.registerFactory(ObjectWithDecimal._); + return const SchemaObject( + ObjectType.realmObject, ObjectWithDecimal, 'ObjectWithDecimal', [ + SchemaProperty('decimal', RealmPropertyType.decimal128), + SchemaProperty('nullableDecimal', RealmPropertyType.decimal128, + optional: true), + ]); + } +}