inline SPROUT_CONSTEXPR FloatType
copysign(FloatType x, FloatType y) {
return x == 0
? y == 0 ? y
: sprout::math::signbit(y) ? -FloatType(0)
: FloatType(0)
: sprout::math::isnan(x)
? sprout::math::isnan(y) ? y
: sprout::math::signbit(y) ? -sprout::numeric_limits<FloatType>::quiet_NaN()
: sprout::numeric_limits<FloatType>::quiet_NaN()
: sprout::math::signbit(y) != sprout::math::signbit(x) ? -x
: x
;
}
inline SPROUT_CONSTEXPR FloatType
str_to_float_impl_exponent_1(
CStrIterator str,
bool negative,
FloatType number = FloatType(),
std::size_t num_digits = 0,
std::size_t num_decimals = 0,
long exponent = 0,
long n = 0
)
{
typedef typename std::iterator_traits<CStrIterator>::value_type char_type;
return sprout::ascii::isdigit(*str) ? sprout::detail::str_to_float_impl_exponent_1<FloatType>(
sprout::next(str),
negative,
number,
num_digits,
num_decimals,
exponent,
n * 10 + (*str - static_cast<char_type>('0'))
)
: sprout::detail::str_to_float_impl_exponent_2<FloatType>(
str,
negative,
number,
num_digits,
num_decimals,
negative ? exponent + n : exponent - n
)
;
}
inline SPROUT_CONSTEXPR FloatType
str_to_float_impl_exponent_2(
CStrIterator str,
bool negative,
FloatType number = FloatType(),
std::size_t num_digits = 0,
std::size_t num_decimals = 0,
long exponent = 0,
long n = 0
)
{
return exponent >= std::numeric_limits<FloatType>::min_exponent
&& exponent <= std::numeric_limits<FloatType>::max_exponent
? sprout::detail::str_to_float_impl_scale<FloatType>(
str,
negative,
number,
num_digits,
num_decimals,
exponent,
exponent < 0 ? -exponent : exponent
)
: HUGE_VAL
;
}
inline SPROUT_CONSTEXPR FloatType
str_to_float_impl(
CStrIterator str,
bool negative,
FloatType number = FloatType(),
std::size_t num_digits = 0
)
{
typedef typename std::iterator_traits<CStrIterator>::value_type char_type;
return sprout::ascii::isdigit(*str) ? sprout::detail::str_to_float_impl<FloatType>(
sprout::next(str),
negative,
number * 10 + (*str - static_cast<char_type>('0')),
num_digits + 1
)
: *str == static_cast<char_type>('.') ? sprout::detail::str_to_float_impl_decimal<FloatType>(
sprout::next(str),
negative,
number,
num_digits
)
: sprout::detail::str_to_float_impl_decimal_1<FloatType>(
str,
negative,
number,
num_digits
)
;
}
inline SPROUT_CONSTEXPR FloatType
acosh(FloatType x) {
return x == 1 ? FloatType(0)
: x < 1 ? std::numeric_limits<FloatType>::quiet_NaN()
: x == std::numeric_limits<FloatType>::infinity() ? std::numeric_limits<FloatType>::infinity()
: sprout::math::log(x + sprout::math::sqrt(x * x - 1))
;
}
TriMesh<FloatType> Shapes<FloatType>::torus(const vec3<FloatType> ¢er, FloatType majorRadius, FloatType minorRadius, UINT stacks, UINT slices, const std::function<vec4<FloatType>(unsigned int)> &stackIndexToColor)
{
std::vector<typename TriMesh<FloatType>::Vertex> vertices(slices * stacks);
std::vector<UINT> indices(stacks * slices * 6);
UINT vIndex = 0;
// initial theta faces y front
FloatType baseTheta = ml::math::PIf / 2.0f;
for (UINT i = 0; i < stacks; i++)
{
FloatType theta = FloatType(i) * 2.0f * ml::math::PIf / FloatType(stacks) + baseTheta;
auto color = stackIndexToColor(i);
FloatType sinT = sinf(theta);
FloatType cosT = cosf(theta);
ml::vec3<FloatType> t0(cosT * majorRadius, sinT * majorRadius, 0.0f);
for (UINT i2 = 0; i2 < slices; i2++)
{
auto& vtx = vertices[vIndex++];
FloatType phi = FloatType(i2) * 2.0f * ml::math::PIf / FloatType(slices);
FloatType sinP = sinf(phi);
vtx.position = ml::vec3<FloatType>(minorRadius * cosT * sinP, minorRadius * sinT * sinP, minorRadius * cosf(phi)) + t0;
vtx.color = color;
}
}
UINT iIndex = 0;
for (UINT i = 0; i < stacks; i++)
{
UINT ip1 = (i + 1) % stacks;
for (UINT i2 = 0; i2 < slices; i2++)
{
UINT i2p1 = (i2 + 1) % slices;
indices[iIndex++] = ip1 * slices + i2;
indices[iIndex++] = i * slices + i2;
indices[iIndex++] = i * slices + i2p1;
indices[iIndex++] = ip1 * slices + i2;
indices[iIndex++] = i * slices + i2p1;
indices[iIndex++] = ip1 * slices + i2p1;
}
}
return TriMesh<FloatType>(vertices, indices, true);
}
void render(const std::vector<Intersecter *> &objects)
{
unsigned width = 640, height = 480;
Vector3 *image = new Vector3[width * height], *pixel = image;
FloatType invWidth = 1 / FloatType(width), invHeight = 1 / FloatType(height);
FloatType fov = 30, aspectratio = width / FloatType(height);
FloatType angle = tan(M_PI * 0.5 * fov / FloatType(180));
// Trace rays
for (unsigned y = 0; y < height; ++y) {
for (unsigned x = 0; x < width; ++x, ++pixel) {
FloatType xx = (2 * ((x + 0.5) * invWidth) - 1) * angle * aspectratio;
FloatType yy = (1 - 2 * ((y + 0.5) * invHeight)) * angle;
Vector3 raydir(xx, yy, -1);
raydir.normalize();
*pixel = trace(Vector3(0), raydir, objects, 0);
}
}
// Save result to a PPM image (keep these flags if you compile under Windows)
std::ofstream ofs("./untitled.ppm", std::ios::out | std::ios::binary);
ofs << "P6\n" << width << " " << height << "\n255\n";
for (unsigned i = 0; i < width * height; ++i) {
ofs << (unsigned char)(std::min(FloatType(1), image[i].x) * 255) <<
(unsigned char)(std::min(FloatType(1), image[i].y) * 255) <<
(unsigned char)(std::min(FloatType(1), image[i].z) * 255);
}
ofs.close();
delete [] image;
}
inline SPROUT_CONSTEXPR FloatType
float2_significand(FloatType x) {
return sprout::math::isnan(x) ? x
: x == sprout::numeric_limits<FloatType>::infinity() ? sprout::numeric_limits<FloatType>::infinity()
: x == -sprout::numeric_limits<FloatType>::infinity() ? -sprout::numeric_limits<FloatType>::infinity()
: x == 0 ? x
: x / sprout::detail::pow_n(FloatType(2), sprout::float2_exponent(x))
;
}
inline SPROUT_CONSTEXPR FloatType
fmod(FloatType x, FloatType y) {
return x == std::numeric_limits<FloatType>::infinity() || x == -std::numeric_limits<FloatType>::infinity() || y == 0
? std::numeric_limits<FloatType>::quiet_NaN()
: x == 0 ? FloatType(0)
: y == std::numeric_limits<FloatType>::infinity() || y == -std::numeric_limits<FloatType>::infinity() ? x
: x - sprout::math::trunc(x / y) * y
;
}
NEIGHAND_INLINE void NeighborhoodHandler<NEIGHAND_TEMPLATE_ARGUMENTS>::updateWeightBaseTables() {
// maintain weighting tables: see neighand_apply.hpp for formula
// Cube
FloatType cellLoad = FloatType(numProxies) / FloatType(WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume);
weightCubeWithLoad = weightCube * (1.0f + 1.52f * cellLoad);
// Sphere
for (uint32_t d32=0; d32<=maxWorldDist32; ++d32) {
weightSphereTableBase[d32] = volumeSphereTable[d32] * (2.0f + helper.getSphereWeightingLoadFactor(d32)*cellLoad) + 10.0f;
weightSphereTable[d32] = weightSphere * weightSphereTableBase[d32];
}
// Model premature stopping ability of Sphere by estimating
// how many cells are processed on average for K objects.
// This is an underestimate, but a fast one.
// ignore weightLoadFactor: would have to compute equivalent d32, plus this kind of compensate the previous underestimate
// One may always change weightSphere if that's not enough.
for (uint32_t K=1; K<256; ++K) {
FloatType eqV = K * FloatType(WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume) / FloatType(numProxies);
weightSphereTableClosestBase[K] = eqV * (2.0f + cellLoad) + 10.0f;
weightSphereTableClosest[K] = weightSphere * weightSphereTableClosestBase[K];
}
// NonEmpty
for (uint32_t d32=0; d32<=maxWorldDist32; ++d32) {
FloatType minV = d32*0.03125f; // d
minV *= minV*minV * 4.1888f; // 4/3 pi d^3
if (minV > WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume) minV = WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume;
//weightNonEmptyTableBase[d32] = 1.0f + 2.0f * cellLoad * minV / WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume;
weightNonEmptyTableBase[d32] = 2.0f * numProxies * minV / WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume;
weightNonEmptyTable[d32] = weightNonEmpty * weightNonEmptyTableBase[d32];
}
// Brute
for (uint32_t d32=0; d32<=maxWorldDist32; ++d32) {
FloatType minV = d32*0.03125f; // d
minV *= minV*minV * 4.1888f; // 4/3 pi d^3
if (minV > WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume) minV = WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume;
//weightBruteTableBase[d32] = cellLoad * minV / WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume;
weightBruteTableBase[d32] = numProxies * (1.0f + minV / WrapHelper<NEIGHAND_TEMPLATE_ARGUMENTS>::MaxVolume);
// Force selection of Brute when there is no object
if (numProxies==0) weightBruteTableBase[d32] = -1.0f;
weightBruteTable[d32] = weightBrute * weightBruteTableBase[d32];
}
updateWeightBaseTablesNeeded = false;
}
FloatType operator()(FloatType t) const noexcept
{
return
t < FloatType(0.0) ? FloatType(0) :
t > FloatType(1.0) ? FloatType(1) :
t < FloatType(0.5) ? InCircular<FloatType>()(t*2)/2 :
(OutCircular<FloatType>()(t*2 - FloatType(1)) + FloatType(1))/2;
}
constexpr FloatType operator()(FloatType t) const noexcept
{
return
t < FloatType(0.0) ? FloatType(0) :
t > FloatType(1.0) ? FloatType(1) :
t < FloatType(0.5) ? InQuartic<FloatType>()(t*2)/2 :
(OutQuartic<FloatType>()(t*2 - FloatType(1)) + FloatType(1))/2;
}
FloatType operator()(FloatType t) const noexcept
{
return
t < FloatType(0.0) ? FloatType(0) :
t > FloatType(1.0) ? FloatType(1) :
t < FloatType(0.5) ? InExponential<FloatType>()(t*2)/2 :
(OutExponential<FloatType>()(t*2 - FloatType(1)) + FloatType(1))/2;
}
inline SPROUT_CONSTEXPR FloatType
copysign(FloatType x, FloatType y) {
return
#if SPROUT_USE_BUILTIN_CMATH_FUNCTION
sprout::math::detail::builtin_copysign(x, y)
#else
x == 0
? y == 0 ? y
: sprout::math::signbit(y) ? -FloatType(0)
: FloatType(0)
: sprout::math::isnan(x)
? sprout::math::isnan(y) ? y
: sprout::math::signbit(y) ? -sprout::numeric_limits<FloatType>::quiet_NaN()
: sprout::numeric_limits<FloatType>::quiet_NaN()
: sprout::math::signbit(y) != sprout::math::signbit(x) ? -x
: x
#endif
;
}
inline SPROUT_CONSTEXPR FloatType
ceil(FloatType x) {
return x == 0 ? FloatType(0)
: x == std::numeric_limits<FloatType>::infinity() ? std::numeric_limits<FloatType>::infinity()
: x == -std::numeric_limits<FloatType>::infinity() ? -std::numeric_limits<FloatType>::infinity()
: std::numeric_limits<std::uintmax_t>::max() < x || std::numeric_limits<std::uintmax_t>::max() < -x
? SPROUT_MATH_THROW_LARGE_FLOAT_ROUNDING(std::runtime_error("ceil: large float rounding."), x)
: x < 0 ? -static_cast<FloatType>(static_cast<std::uintmax_t>(-x))
: sprout::math::detail::ceil_impl(x, static_cast<FloatType>(static_cast<std::uintmax_t>(x)))
;
}
inline SPROUT_CONSTEXPR FloatType
acos(FloatType x) {
return sprout::math::isnan(x) ? x
: sprout::math::fabs(x) > 1 ? sprout::numeric_limits<FloatType>::quiet_NaN()
#if SPROUT_USE_BUILTIN_CMATH_FUNCTION
: sprout::math::detail::builtin_acos(x)
#else
: x == 1 ? FloatType(0)
: static_cast<FloatType>(sprout::math::detail::acos_impl(static_cast<typename sprout::math::detail::float_compute<FloatType>::type>(x)))
#endif
;
}
/*==============================================================================
* FUNCTION: RTLInstDict::partialType
* OVERVIEW: Scan the Exp* pointed to by exp; if its top level operator indicates even a partial type, then set
* the expression's type, and return true
* NOTE: This version only inspects one expression
* PARAMETERS: exp - points to a Exp* to be scanned
* ty - ref to a Type object to put the partial type into
* RETURNS: True if a partial type is found
*============================================================================*/
bool RTLInstDict::partialType(Exp *exp, Type &ty)
{
if (exp->isSizeCast()) {
ty = IntegerType(((Const *)((Binary *)exp)->getSubExp1())->getInt());
return true;
}
if (exp->isFltConst()) {
ty = FloatType(64);
return true;
}
return false;
}
inline SPROUT_CONSTEXPR FloatType
str_to_float_impl_decimal_1(
CStrIterator str,
bool negative,
FloatType number = FloatType(),
std::size_t num_digits = 0,
std::size_t num_decimals = 0,
long exponent = 0
)
{
return num_digits == 0 ? FloatType()
: sprout::detail::str_to_float_impl_exponent<FloatType>(
str,
negative,
negative ? -number : number,
num_digits,
num_decimals,
exponent
)
;
}
void MultiLayerMieApplied<FloatType>::GetFailed() {
FloatType faild_x = 9.42477796076938;
//FloatType faild_x = 9.42477796076937;
std::complex<FloatType> z(faild_x, 0.0);
std::vector<int> nmax_local_array = {20, 100, 500, 2500};
for (auto nmax_local : nmax_local_array) {
std::vector<std::complex<FloatType> > D1_failed(nmax_local + 1);
// Downward recurrence for D1 - equations (16a) and (16b)
D1_failed[nmax_local] = std::complex<FloatType>(0.0, 0.0);
const std::complex<FloatType> zinv = std::complex<FloatType>(1.0, 0.0)/z;
for (int n = nmax_local; n > 0; n--) {
D1_failed[n - 1] = FloatType(n)*zinv - 1.0/(D1_failed[n] + FloatType(n)*zinv);
}
printf("Faild D1[0] from reccurence (z = %16.14f, nmax = %d): %g\n",
faild_x, nmax_local, D1_failed[0].real());
}
printf("Faild D1[0] from continued fraction (z = %16.14f): %g\n", faild_x,
calcD1confra(0,z).real());
//D1[nmax_] = calcD1confra(nmax_, z);
}
void buildNormalizedData( FloatType *normalized_data,
void *orig_data,
unsigned int nr_elements,
float scale,
float bias ) {
A *d = (A*) orig_data;
for (unsigned int i = 0; i < nr_elements; i++) {
normalized_data[i] =
(d[ i ] / FloatType( numeric_limits<A >::max() ) ) * scale + bias;
if( normalized_data[i] < 0 ) normalized_data[i] = 0;
}
}
inline SPROUT_CONSTEXPR FloatType
log10(FloatType x) {
return sprout::math::isnan(x) ? x
: x == 0 ? -sprout::numeric_limits<FloatType>::infinity()
: x == sprout::numeric_limits<FloatType>::infinity() ? sprout::numeric_limits<FloatType>::infinity()
: x < 0 ? sprout::numeric_limits<FloatType>::quiet_NaN()
#if SPROUT_USE_BUILTIN_CMATH_FUNCTION
: sprout::math::detail::builtin_log10(x)
#else
: x == 1 ? FloatType(0)
: static_cast<FloatType>(sprout::math::detail::log10_impl(static_cast<typename sprout::math::detail::float_compute<FloatType>::type>(x)))
#endif
;
}
inline SPROUT_CONSTEXPR sprout::pair<int, FloatType>
float_digits_impl_1(sprout::pair<int, FloatType> const& current, FloatType val, int n) {
typedef sprout::pair<int, FloatType> type;
return (val / current.second) < 1 ? current
: n == 1 ? type(current.first + 1, current.second * FloatType(10))
: sprout::detail::float_digits_impl_1(
sprout::detail::float_digits_impl_1(
current,
val, n / 2
),
val, n - n / 2
)
;
}
/******************************************************************************
* This is called when the user has clicked the "Save Data" button.
******************************************************************************/
void BinAndReduceModifierEditor::onSaveData()
{
BinAndReduceModifier* modifier = static_object_cast<BinAndReduceModifier>(editObject());
if(!modifier)
return;
if(modifier->binData().empty())
return;
QString fileName = QFileDialog::getSaveFileName(mainWindow(),
tr("Save Data"), QString(),
tr("Text files (*.txt);;All files (*)"));
if(fileName.isEmpty())
return;
try {
QFile file(fileName);
if(!file.open(QIODevice::WriteOnly | QIODevice::Text))
throw Exception(tr("Could not open file for writing: %1").arg(file.errorString()));
int binDataSizeX = std::max(1, modifier->numberOfBinsX());
int binDataSizeY = std::max(1, modifier->numberOfBinsY());
if (modifier->is1D()) binDataSizeY = 1;
FloatType binSizeX = (modifier->xAxisRangeEnd() - modifier->xAxisRangeStart()) / binDataSizeX;
FloatType binSizeY = (modifier->yAxisRangeEnd() - modifier->yAxisRangeStart()) / binDataSizeY;
QTextStream stream(&file);
if (binDataSizeY == 1) {
stream << "# " << modifier->sourceProperty().name() << " bin size: " << binSizeX << endl;
for(size_t i = 0; i < modifier->binData().size(); i++) {
stream << (binSizeX * (FloatType(i) + 0.5f) + modifier->xAxisRangeStart()) << " " << modifier->binData()[i] << endl;
}
}
else {
stream << "# " << modifier->sourceProperty().name() << " bin size X: " << binDataSizeX << ", bin size Y: " << binDataSizeY << endl;
for(int i = 0; i < binDataSizeY; i++) {
for(int j = 0; j < binDataSizeX; j++) {
stream << modifier->binData()[i*binDataSizeX+j] << " ";
}
stream << endl;
}
}
}
catch(const Exception& ex) {
ex.showError();
}
}
AnyType TPTScriptInterface::eval(std::deque<String> * words)
{
if(words->size() < 1)
return AnyType(TypeNull, ValueValue());
String word = words->front(); words->pop_front();
ValueType wordType = testType(word);
switch(wordType)
{
case TypeFunction:
if(word == "set")
return tptS_set(words);
else if(word == "create")
return tptS_create(words);
else if(word == "delete" || word == "kill")
return tptS_delete(words);
else if(word == "load")
return tptS_load(words);
else if(word == "reset")
return tptS_reset(words);
else if(word == "bubble")
return tptS_bubble(words);
else if(word == "quit")
return tptS_quit(words);
break;
case TypeNumber:
return NumberType(parseNumber(word));
case TypeFloat:
return FloatType(atof(word.ToUtf8().c_str()));
case TypePoint:
{
int x, y;
if(String::Split comma = word.SplitNumber(x))
if(comma.After().BeginsWith(","))
if(comma.After().Substr(1).SplitNumber(y))
return PointType(x, y);
return PointType(0, 0);
}
case TypeString:
return StringType(word);
default:
break;
}
return StringType(word);
}
AnyType TPTScriptInterface::eval(std::deque<std::string> * words)
{
if(words->size() < 1)
return AnyType(TypeNull, ValueValue());
std::string word = words->front(); words->pop_front();
char * rawWord = (char *)word.c_str();
ValueType wordType = testType(word);
switch(wordType)
{
case TypeFunction:
if(word == "set")
return tptS_set(words);
else if(word == "create")
return tptS_create(words);
else if(word == "delete" || word == "kill")
return tptS_delete(words);
else if(word == "load")
return tptS_load(words);
else if(word == "reset")
return tptS_reset(words);
else if(word == "bubble")
return tptS_bubble(words);
else if(word == "quit")
return tptS_quit(words);
break;
case TypeNumber:
return NumberType(parseNumber(rawWord));
case TypeFloat:
return FloatType(atof(rawWord));
case TypePoint:
{
int pointX, pointY;
sscanf(rawWord, "%d,%d", &pointX, &pointY);
return PointType(pointX, pointY);
}
case TypeString:
return StringType(word);
}
return StringType(word);
}
inline SPROUT_CONSTEXPR FloatType
str_to_float_impl_exponent(
CStrIterator str,
bool negative,
FloatType number = FloatType(),
std::size_t num_digits = 0,
std::size_t num_decimals = 0,
long exponent = 0
)
{
typedef typename std::iterator_traits<CStrIterator>::value_type char_type;
return (*str == static_cast<char_type>('e') || *str == static_cast<char_type>('E'))
? *sprout::next(str) == static_cast<char_type>('-')
? sprout::detail::str_to_float_impl_exponent_1<FloatType>(
sprout::next(str, 2),
true,
number,
num_digits,
num_decimals,
exponent
)
: sprout::detail::str_to_float_impl_exponent_1<FloatType>(
sprout::next(str, 2),
false,
number,
num_digits,
num_decimals,
exponent
)
: sprout::detail::str_to_float_impl_exponent_2<FloatType>(
str,
negative,
number,
num_digits,
num_decimals,
exponent
)
;
}
/******************************************************************************
* Determines the display color of a single particle.
******************************************************************************/
ColorA ParticleDisplay::particleColor(size_t particleIndex, ParticlePropertyObject* colorProperty, ParticleTypeProperty* typeProperty, ParticlePropertyObject* selectionProperty, ParticlePropertyObject* transparencyProperty)
{
OVITO_ASSERT(colorProperty == nullptr || colorProperty->type() == ParticleProperty::ColorProperty);
OVITO_ASSERT(typeProperty == nullptr || typeProperty->type() == ParticleProperty::ParticleTypeProperty);
OVITO_ASSERT(selectionProperty == nullptr || selectionProperty->type() == ParticleProperty::SelectionProperty);
OVITO_ASSERT(transparencyProperty == nullptr || transparencyProperty->type() == ParticleProperty::TransparencyProperty);
// Check if particle is selected.
if(selectionProperty) {
OVITO_ASSERT(particleIndex < selectionProperty->size());
if(selectionProperty->getInt(particleIndex))
return selectionParticleColor();
}
ColorA c = defaultParticleColor();
if(colorProperty) {
// Take particle color directly from the color property.
OVITO_ASSERT(particleIndex < colorProperty->size());
c = colorProperty->getColor(particleIndex);
}
else if(typeProperty) {
// Return color based on particle types.
OVITO_ASSERT(particleIndex < typeProperty->size());
ParticleType* ptype = typeProperty->particleType(typeProperty->getInt(particleIndex));
if(ptype)
c = ptype->color();
}
// Apply alpha component.
if(transparencyProperty) {
OVITO_ASSERT(particleIndex < transparencyProperty->size());
c.a() = FloatType(1) - transparencyProperty->getFloat(particleIndex);
}
return c;
}
inline SPROUT_CONSTEXPR FloatType
fractional_part(FloatType x) {
return x == std::numeric_limits<FloatType>::infinity() || x == -std::numeric_limits<FloatType>::infinity() ? FloatType(0)
: x == std::numeric_limits<FloatType>::quiet_NaN() ? std::numeric_limits<FloatType>::quiet_NaN()
: x - sprout::math::integer_part(x)
;
}
inline SPROUT_CONSTEXPR FloatType
float_pow10(int exponent) {
return sprout::detail::pow_n(FloatType(10), exponent);
}
inline SPROUT_CONSTEXPR FloatType
fractional_part(FloatType x) {
return sprout::math::isnan(x) ? x
: x == sprout::numeric_limits<FloatType>::infinity() || x == -sprout::numeric_limits<FloatType>::infinity() ? sprout::math::copysign(FloatType(0), x)
: x == 0 ? x
: sprout::math::detail::fractional_part_impl(x, sprout::integer_part(x))
;
}