Mirrors/tinyusdz
0
0
Fork 0
mirror of https://github.com/lighttransport/tinyusdz.git synced 2026-01-18 01:11:17 +01:00
Code Issues Packages Projects Releases Wiki Activity

support more float/double types.

Browse Source
This commit is contained in:
Syoyo Fujita
2025-07-28 11:41:28 +09:00
parent 5cf79781d1
commit ef44ffd921
2 changed files with 196 additions and 46 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
sandbox/print_fp/Makefile
View File

@@ -1,3 +1,4 @@
all:
clang++ -O2 -g print_fp.cc -I ../../src/external/dragonbox/ ../../src/external/dragonbox/dragonbox_to_chars.cpp -I../../src/external
g++ -O2 -g -std=c++14 print_fp.cc -I ../../src/external/dragonbox/ ../../src/external/dragonbox/dragonbox_to_chars.cpp -I../../src/external -o print_fp
#clang++ -O2 -g print_fp.cc -I ../../src/external/dragonbox/ ../../src/external/dragonbox/dragonbox_to_chars.cpp -I../../src/external
#clang++ -O2 -g print_fp.cc -I ../../src/external/

239
sandbox/print_fp/print_fp.cc
View File

@@ -4,10 +4,18 @@
#include <random>
#include <sstream>
#include <vector>
#include <array>
#include "dragonbox_to_chars.h"
#include "dtoa_milo.h"
using float2 = std::array<float, 2>;
using float3 = std::array<float, 3>;
using float4 = std::array<float, 4>;
using double2 = std::array<double, 2>;
using double3 = std::array<double, 3>;
using double4 = std::array<double, 4>;
std::vector<float> gen_floats(size_t n) {
std::vector<float> dst;
dst.resize(n);
@@ -334,6 +342,110 @@ std::string print_floats(const std::vector<float> &v) {
return s;
}
template<size_t N>
std::string print_float_array(const std::vector<std::array<float, N>> &v) {
std::ostringstream oss;
for (size_t i = 0; i < v.size(); i++) {
if (i > 0) {
oss << ", ";
}
oss << "(";
for (size_t j = 0; j < N; j++) {
if (j > 0) {
oss << ", ";
}
char buffer[40];
// Handle special cases to avoid dragonbox assertion
if (!std::isfinite(v[i][j]) || v[i][j] == 0.0f) {
if (v[i][j] == 0.0f) {
oss << "0";
} else if (std::isnan(v[i][j])) {
oss << "nan";
} else if (std::isinf(v[i][j])) {
oss << (v[i][j] > 0 ? "inf" : "-inf");
}
} else {
char *e = internal::dtoa_dragonbox(v[i][j], buffer);
*e = '\0';
oss << buffer;
}
}
oss << ")";
}
oss << "\n";
return oss.str();
}
template<size_t N>
std::string print_double_array(const std::vector<std::array<double, N>> &v) {
std::ostringstream oss;
for (size_t i = 0; i < v.size(); i++) {
if (i > 0) {
oss << ", ";
}
oss << "(";
for (size_t j = 0; j < N; j++) {
if (j > 0) {
oss << ", ";
}
char buffer[40];
// Handle special cases to avoid dragonbox assertion
if (!std::isfinite(v[i][j]) || v[i][j] == 0.0) {
if (v[i][j] == 0.0) {
oss << "0";
} else if (std::isnan(v[i][j])) {
oss << "nan";
} else if (std::isinf(v[i][j])) {
oss << (v[i][j] > 0 ? "inf" : "-inf");
}
} else {
char *e = internal::dtoa_dragonbox(v[i][j], buffer);
*e = '\0';
oss << buffer;
}
}
oss << ")";
}
oss << "\n";
return oss.str();
}
std::string print_float2_array(const std::vector<float2> &v) {
return print_float_array<2>(v);
}
std::string print_float3_array(const std::vector<float3> &v) {
return print_float_array<3>(v);
}
std::string print_float4_array(const std::vector<float4> &v) {
return print_float_array<4>(v);
}
std::string print_double2_array(const std::vector<double2> &v) {
return print_double_array<2>(v);
}
std::string print_double3_array(const std::vector<double3> &v) {
return print_double_array<3>(v);
}
std::string print_double4_array(const std::vector<double4> &v) {
return print_double_array<4>(v);
}
#if 0
std::string print_floats(const std::vector<float> &v) {
@@ -380,53 +492,90 @@ int main(int argc, char** argv) {
delim_at_end = std::stoi(argv[2]) > 0;
}
double d = 1.0;
for (size_t i = 0; i < 32; i++) {
char buf[25];
// Skip original dragonbox test loop - has issues
// double d = 1.0;
// for (size_t i = 0; i < 32; i++) {
// char buf[25];
// char *p = internal::dtoa_dragonbox(d, buf);
// *p = '\0';
// std::cout << "db " << buf << "\n";
// {
// auto ret = jkj::dragonbox::to_decimal(d);
// std::cout << "to_decimal " << ret.significand << "\n";
// std::cout << "to_decimal " << ret.exponent << "\n";
// }
// {
// char db_buf[40];
// auto ret = jkj::dragonbox::to_chars(d, db_buf);
// std::cout << "to_chars " << db_buf << "\n";
// }
// {
// char buffer[25];
// int length, K;
// Grisu2(d, buffer, &length, &K);
// std::cout << "grisu len " << length << "\n";
// std::cout << "grisu K " << K << "\n";
// std::cout << "grisu " << buffer << "\n";
// }
// d = d * 10.0;
// }
char *p = internal::dtoa_dragonbox(d, buf);
*p = '\0';
std::cout << "db " << buf << "\n";
// Skip the performance test for now - has issues with dragonbox assertion
// std::vector<float> arr = gen_floats(n);
// auto start = std::chrono::steady_clock::now();
// std::string s = print_floats(arr);
// auto end = std::chrono::steady_clock::now();
// std::cout << "n elems " << arr.size() << "\n";
// std::cout << "print : " <<
// std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()
// << " [ms]\n";
{
auto ret = jkj::dragonbox::to_decimal(d);
std::cout << "to_decimal " << ret.significand << "\n";
std::cout << "to_decimal " << ret.exponent << "\n";
}
{
char db_buf[40];
auto ret = jkj::dragonbox::to_chars(d, db_buf);
std::cout << "to_chars " << db_buf << "\n";
}
{
char buffer[25];
int length, K;
Grisu2(d, buffer, &length, &K);
std::cout << "grisu len " << length << "\n";
std::cout << "grisu K " << K << "\n";
std::cout << "grisu " << buffer << "\n";
}
d = d * 10.0;
}
std::vector<float> arr = gen_floats(n);
// std::cout << input << "\n";
auto start = std::chrono::steady_clock::now();
std::string s = print_floats(arr);
auto end = std::chrono::steady_clock::now();
std::cout << "n elems " << arr.size() << "\n";
std::cout << "print : " <<
std::chrono::duration_cast<std::chrono::milliseconds>(end - start).count()
<< " [ms]\n";
//std::cout << s << "\n";
// Test vector array printers
std::cout << "\n=== Testing vector array printers ===\n";
// Test float2 arrays
std::vector<float2> float2_test = {
{1.0f, 2.0f},
{3.14159f, -2.71828f},
{0.0001f, 1000000.0f}
};
std::cout << "float2 array: " << print_float2_array(float2_test);
// Test float3 arrays
std::vector<float3> float3_test = {
{1.0f, 2.0f, 3.0f},
{0.577f, 0.577f, 0.577f},
{-1.0f, 0.0f, 1.0f}
};
std::cout << "float3 array: " << print_float3_array(float3_test);
// Test float4 arrays
std::vector<float4> float4_test = {
{1.0f, 0.0f, 0.0f, 1.0f},
{0.5f, 0.5f, 0.5f, 0.8f}
};
std::cout << "float4 array: " << print_float4_array(float4_test);
// Test double2 arrays
std::vector<double2> double2_test = {
{1.0, 2.0},
{3.14, -2.71}
};
std::cout << "double2 array: " << print_double2_array(double2_test);
// Test double3 arrays
std::vector<double3> double3_test = {
{1.0, 2.0, 3.0},
{0.577, 0.577, 0.577}
};
std::cout << "double3 array: " << print_double3_array(double3_test);
// Test double4 arrays
std::vector<double4> double4_test = {
{1.0, 2.0, 3.0, 4.0},
{0.707, 0.707, 1.0, 2.0}
};
std::cout << "double4 array: " << print_double4_array(double4_test);
return 0;
}