This is a reworked fun experiment I had about how to store and load data
in complex numbers:

https://groups.google.com/g/comp.lang.c++/c/bB1wA4wvoFc/m/OTccTiXLAgAJ



// updated code
Can you run it and tell me what you get? Thanks!

:^)
_____________________________________
// Chris M. Thomasson
// complex storage for fun...


#include <complex>
#include <iostream>
#include <vector>
#include <limits>
#include <algorithm>
#include <cstdint>
#include <cassert>
#include <cstring>

typedef std::int64_t ct_int;
typedef std::uint64_t ct_uint;
typedef double ct_float;
typedef std::numeric_limits<ct_float> ct_float_nlim;
typedef std::complex<ct_float> ct_complex;
typedef std::vector<ct_complex> ct_complex_vec;

#define CT_PI 3.14159265358979323846

ct_float
ct_roots(
ct_complex const& z,
ct_int p,
ct_complex_vec& out
) {
assert(p != 0);

ct_float radius = std::pow(std::abs(z), 1.0 / p);
ct_float angle_base = std::arg(z) / p;
ct_float angle_step = (CT_PI * 2.0) / p;

ct_uint n = std::abs(p);
ct_float avg_err = 0.0;

for (ct_uint i = 0; i < n; ++i) {
ct_float angle = angle_step * i;
ct_complex c = {
std::cos(angle_base + angle) * radius,
std::sin(angle_base + angle) * radius
};

out.push_back(c);

ct_complex raised = std::pow(c, p);
avg_err = avg_err + std::abs(raised - z);
}

return avg_err / n;
}

// Direct angular calculation - O(1) instead of O(n)
ct_int
ct_try_find_direct(
ct_complex const& z,
ct_complex const& z_next,
ct_int power,
ct_float eps
) {
// Calculate what the angle_base was when z_next's roots were computed
ct_float angle_base = std::arg(z_next) / power;

// Get z's angle relative to origin
ct_float z_angle = std::arg(z);

// Find which root slot z falls into
// Subtract the base angle and normalize
ct_float relative_angle = z_angle - angle_base;

// Normalize to [0, 2*pi)
while (relative_angle < 0) relative_angle += CT_PI * 2.0;
while (relative_angle >= CT_PI * 2.0) relative_angle -= CT_PI * 2.0;

// Calculate step size between roots
ct_float angle_step = (CT_PI * 2.0) / power;

// Find nearest root index
ct_uint index = (ct_uint)std::round(relative_angle / angle_step);

// Handle wrap-around
if (index >= (ct_uint)std::abs(power)) {
index = 0;
}

return index;
}

// Original linear search version - more robust but O(n)
ct_int
ct_try_find(
ct_complex const& z,
ct_complex_vec const& roots,
ct_float eps
) {
std::size_t n = roots.size();

for (std::size_t i = 0; i < n; ++i) {
ct_complex const& root = roots[i];
ct_float adif = std::abs(root - z);

if (adif < eps) {
return i;
}
}

return -1;
}

static std::string const g_tokens_str =
"0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

ct_int
ct_gain_power(
std::string const& tokens
) {
ct_uint n = tokens.length();
std::size_t pmax = 0;

for (ct_uint i = 0; i < n; ++i) {
std::size_t fridx = g_tokens_str.find_first_of(tokens[i]);
assert(fridx != std::string::npos);
pmax = std::max(pmax, fridx);
}

return (ct_int)(pmax + 1);
}

ct_complex
ct_store(
ct_complex const& z_origin,
ct_int p,
std::string const& tokens
) {
ct_uint n = tokens.length();
ct_complex z = z_origin;
ct_float store_avg_err = 0.0;

std::cout << "Storing Data..." << "\n";
std::cout << "stored:z_origin:" << z_origin << "\n";

for (ct_uint i = 0; i < n; ++i) {
ct_complex_vec roots;
ct_float avg_err = ct_roots(z, p, roots);
store_avg_err = store_avg_err + avg_err;

std::size_t fridx = g_tokens_str.find_first_of(tokens[i]);
assert(fridx != std::string::npos);

z = roots[fridx];
std::cout << "stored[" << i << "]:" << z << "\n";
}

store_avg_err = store_avg_err / n;
std::cout << "store_avg_err:" << store_avg_err << "\n";

return z;
}

ct_float
ct_load(
ct_complex const& z_store,
ct_complex const& z_target,
ct_int p,
ct_float eps,
std::string& out_tokens,
ct_complex& out_z,
bool use_direct = false // Toggle between direct and linear search
) {
ct_complex z = z_store;
ct_uint n = 128;
ct_float load_err_sum = 0.0;

std::cout << "Loading Data... (using " << (use_direct ? "direct" : "linear search") << " method)\n";

for (ct_uint i = 0; i < n; ++i) {
// Raise to power to get parent point
ct_complex z_next = std::pow(z, p);

ct_int root_idx;

if (use_direct) {
// Direct O(1) calculation
root_idx = ct_try_find_direct(z, z_next, p, eps);
}
else {
// Linear search O(n) - compute roots and search
ct_complex_vec roots;
ct_float avg_err = ct_roots(z_next, p, roots);
load_err_sum += avg_err;
root_idx = ct_try_find(z, roots, eps);
}

if (root_idx < 0 || (ct_uint)root_idx >= g_tokens_str.length()) {
break;
}

std::cout << "loaded[" << i << "]:" << z << " (index:" <<
root_idx << ")\n";
out_tokens += g_tokens_str[root_idx];

// Move to parent point
z = z_next;

// Check if we've reached the origin
if (std::abs(z - z_target) < eps) {
std::cout << "fin detected!:[" << i << "]:" << z << "\n";
break;
}
}

// Reverse to get original order
std::reverse(out_tokens.begin(), out_tokens.end());
out_z = z;

return load_err_sum;
}

int main() {
std::cout.precision(ct_float_nlim::max_digits10);
std::cout << "g_tokens_str:" << g_tokens_str << "\n\n";

{
ct_complex z_origin = { -.75, .06 };
std::string stored = "CHRIS";
ct_int power = ct_gain_power(stored);

std::cout << "stored:" << stored << "\n";
std::cout << "power:" << power << "\n\n";
std::cout << "________________________________________\n";

// STORE
ct_complex z_stored = ct_store(z_origin, power, stored);

std::cout << "________________________________________\n";
std::cout << "\nSTORED POINT:" << z_stored << "\n";
std::cout << "________________________________________\n";

// LOAD - try both methods
std::string loaded;
ct_complex z_loaded;
ct_float eps = .001;

std::cout << "\n=== Testing LINEAR SEARCH method ===\n";
ct_float load_err_sum =
ct_load(z_stored, z_origin, power, eps, loaded, z_loaded,
false);

std::cout << "________________________________________\n";
std::cout << "\nORIGIN POINT:" << z_origin << "\n";
std::cout << "LOADED POINT:" << z_loaded << "\n";
std::cout << "\nloaded:" << loaded << "\n";
std::cout << "load_err_sum:" << load_err_sum << "\n";

if (stored == loaded) {
std::cout << "\n\nDATA COHERENT! :^D" << "\n";
}
else {
std::cout << "\n\n***** DATA CORRUPTED!!! Shi%! *****" << "\n";
std::cout << "Expected: " << stored << "\n";
std::cout << "Got: " << loaded << "\n";
}

// Try direct method
std::cout << "\n\n=== Testing DIRECT ANGULAR method ===\n";
std::string loaded_direct;
ct_complex z_loaded_direct;

ct_float load_err_sum_direct =
ct_load(z_stored, z_origin, power, eps, loaded_direct, z_loaded_direct, true);

std::cout << "________________________________________\n";
std::cout << "\nloaded:" << loaded_direct << "\n";

if (stored == loaded_direct) {
std::cout << "\n\nDATA COHERENT (DIRECT METHOD)! :^D" << "\n";
}
else {
std::cout << "\n\n***** DATA CORRUPTED (DIRECT METHOD)!!!
*****" << "\n";
std::cout << "Expected: " << stored << "\n";
std::cout << "Got: " << loaded_direct << "\n";
}
}

std::cout << "\n\nFin, hit <ENTER> to exit...\n";
std::fflush(stdout);
std::cin.get();

return 0;
}
_____________________________________



--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

Am 11.01.2026 um 23:03 schrieb Chris M. Thomasson:

This is a reworked fun experiment I had about how to store and load data
in complex numbers:

https://groups.google.com/g/comp.lang.c++/c/bB1wA4wvoFc/m/OTccTiXLAgAJ

// updated code
Can you run it and tell me what you get? Thanks!

:^)
_____________________________________
// Chris M. Thomasson
// complex storage for fun...

#include <complex>
#include <iostream>
#include <vector>
#include <limits>
#include <algorithm>
#include <cstdint>
#include <cassert>
#include <cstring>

typedef std::int64_t ct_int;
typedef std::uint64_t ct_uint;
typedef double ct_float;
typedef std::numeric_limits<ct_float> ct_float_nlim;
typedef std::complex<ct_float> ct_complex;
typedef std::vector<ct_complex> ct_complex_vec;

I would recomment to use a ct_cout also.
That would increase the readability.

#define CT_PI 3.14159265358979323846

ct_float
ct_roots(
ÿÿÿ ct_complex const& z,
ÿÿÿ ct_int p,
ÿÿÿ ct_complex_vec& out
) {
ÿÿÿ assert(p != 0);

ÿÿÿ ct_float radius = std::pow(std::abs(z), 1.0 / p);
ÿÿÿ ct_float angle_base = std::arg(z) / p;
ÿÿÿ ct_float angle_step = (CT_PI * 2.0) / p;

ÿÿÿ ct_uint n = std::abs(p);
ÿÿÿ ct_float avg_err = 0.0;

ÿÿÿ for (ct_uint i = 0; i < n; ++i) {
ÿÿÿÿÿÿÿ ct_float angle = angle_step * i;
ÿÿÿÿÿÿÿ ct_complex c = {
ÿÿÿÿÿÿÿÿÿÿÿ std::cos(angle_base + angle) * radius,
ÿÿÿÿÿÿÿÿÿÿÿ std::sin(angle_base + angle) * radius
ÿÿÿÿÿÿÿ };

ÿÿÿÿÿÿÿ out.push_back(c);

ÿÿÿÿÿÿÿ ct_complex raised = std::pow(c, p);
ÿÿÿÿÿÿÿ avg_err = avg_err + std::abs(raised - z);
ÿÿÿ }

ÿÿÿ return avg_err / n;
}

// Direct angular calculation - O(1) instead of O(n)
ct_int
ct_try_find_direct(
ÿÿÿ ct_complex const& z,
ÿÿÿ ct_complex const& z_next,
ÿÿÿ ct_int power,
ÿÿÿ ct_float eps
) {
ÿÿÿ // Calculate what the angle_base was when z_next's roots were computed
ÿÿÿ ct_float angle_base = std::arg(z_next) / power;

ÿÿÿ // Get z's angle relative to origin
ÿÿÿ ct_float z_angle = std::arg(z);

ÿÿÿ // Find which root slot z falls into
ÿÿÿ // Subtract the base angle and normalize
ÿÿÿ ct_float relative_angle = z_angle - angle_base;

ÿÿÿ // Normalize to [0, 2*pi)
ÿÿÿ while (relative_angle < 0) relative_angle += CT_PI * 2.0;
ÿÿÿ while (relative_angle >= CT_PI * 2.0) relative_angle -= CT_PI * 2.0;

ÿÿÿ // Calculate step size between roots
ÿÿÿ ct_float angle_step = (CT_PI * 2.0) / power;

ÿÿÿ // Find nearest root index
ÿÿÿ ct_uint index = (ct_uint)std::round(relative_angle / angle_step);

ÿÿÿ // Handle wrap-around
ÿÿÿ if (index >= (ct_uint)std::abs(power)) {
ÿÿÿÿÿÿÿ index = 0;
ÿÿÿ }

ÿÿÿ return index;
}

// Original linear search version - more robust but O(n)
ct_int
ct_try_find(
ÿÿÿ ct_complex const& z,
ÿÿÿ ct_complex_vec const& roots,
ÿÿÿ ct_float eps
) {
ÿÿÿ std::size_t n = roots.size();

ÿÿÿ for (std::size_t i = 0; i < n; ++i) {
ÿÿÿÿÿÿÿ ct_complex const& root = roots[i];
ÿÿÿÿÿÿÿ ct_float adif = std::abs(root - z);

ÿÿÿÿÿÿÿ if (adif < eps) {
ÿÿÿÿÿÿÿÿÿÿÿ return i;
ÿÿÿÿÿÿÿ }
ÿÿÿ }

ÿÿÿ return -1;
}

static std::string const g_tokens_str =
ÿÿÿ "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";

ct_int
ct_gain_power(
ÿÿÿ std::string const& tokens
) {
ÿÿÿ ct_uint n = tokens.length();
ÿÿÿ std::size_t pmax = 0;

ÿÿÿ for (ct_uint i = 0; i < n; ++i) {
ÿÿÿÿÿÿÿ std::size_t fridx = g_tokens_str.find_first_of(tokens[i]);
ÿÿÿÿÿÿÿ assert(fridx != std::string::npos);
ÿÿÿÿÿÿÿ pmax = std::max(pmax, fridx);
ÿÿÿ }

ÿÿÿ return (ct_int)(pmax + 1);
}

ct_complex
ct_store(
ÿÿÿ ct_complex const& z_origin,
ÿÿÿ ct_int p,
ÿÿÿ std::string const& tokens
) {
ÿÿÿ ct_uint n = tokens.length();
ÿÿÿ ct_complex z = z_origin;
ÿÿÿ ct_float store_avg_err = 0.0;

ÿÿÿ std::cout << "Storing Data..." << "\n";
ÿÿÿ std::cout << "stored:z_origin:" << z_origin << "\n";

ÿÿÿ for (ct_uint i = 0; i < n; ++i) {
ÿÿÿÿÿÿÿ ct_complex_vec roots;
ÿÿÿÿÿÿÿ ct_float avg_err = ct_roots(z, p, roots);
ÿÿÿÿÿÿÿ store_avg_err = store_avg_err + avg_err;

ÿÿÿÿÿÿÿ std::size_t fridx = g_tokens_str.find_first_of(tokens[i]);
ÿÿÿÿÿÿÿ assert(fridx != std::string::npos);

ÿÿÿÿÿÿÿ z = roots[fridx];
ÿÿÿÿÿÿÿ std::cout << "stored[" << i << "]:" << z << "\n";
ÿÿÿ }

ÿÿÿ store_avg_err = store_avg_err / n;
ÿÿÿ std::cout << "store_avg_err:" << store_avg_err << "\n";

ÿÿÿ return z;
}

ct_float
ct_load(
ÿÿÿ ct_complex const& z_store,
ÿÿÿ ct_complex const& z_target,
ÿÿÿ ct_int p,
ÿÿÿ ct_float eps,
ÿÿÿ std::string& out_tokens,
ÿÿÿ ct_complex& out_z,
ÿÿÿ bool use_direct = falseÿ // Toggle between direct and linear search
) {
ÿÿÿ ct_complex z = z_store;
ÿÿÿ ct_uint n = 128;
ÿÿÿ ct_float load_err_sum = 0.0;

ÿÿÿ std::cout << "Loading Data... (using " << (use_direct ? "direct" : "linear search") << " method)\n";

ÿÿÿ for (ct_uint i = 0; i < n; ++i) {
ÿÿÿÿÿÿÿ // Raise to power to get parent point
ÿÿÿÿÿÿÿ ct_complex z_next = std::pow(z, p);

ÿÿÿÿÿÿÿ ct_int root_idx;

ÿÿÿÿÿÿÿ if (use_direct) {
ÿÿÿÿÿÿÿÿÿÿÿ // Direct O(1) calculation
ÿÿÿÿÿÿÿÿÿÿÿ root_idx = ct_try_find_direct(z, z_next, p, eps);
ÿÿÿÿÿÿÿ }
ÿÿÿÿÿÿÿ else {
ÿÿÿÿÿÿÿÿÿÿÿ // Linear search O(n) - compute roots and search
ÿÿÿÿÿÿÿÿÿÿÿ ct_complex_vec roots;
ÿÿÿÿÿÿÿÿÿÿÿ ct_float avg_err = ct_roots(z_next, p, roots);
ÿÿÿÿÿÿÿÿÿÿÿ load_err_sum += avg_err;
ÿÿÿÿÿÿÿÿÿÿÿ root_idx = ct_try_find(z, roots, eps);
ÿÿÿÿÿÿÿ }

ÿÿÿÿÿÿÿ if (root_idx < 0 || (ct_uint)root_idx >= g_tokens_str.length()) {
ÿÿÿÿÿÿÿÿÿÿÿ break;
ÿÿÿÿÿÿÿ }

ÿÿÿÿÿÿÿ std::cout << "loaded[" << i << "]:" << z << " (index:" <<
root_idx << ")\n";
ÿÿÿÿÿÿÿ out_tokens += g_tokens_str[root_idx];

ÿÿÿÿÿÿÿ // Move to parent point
ÿÿÿÿÿÿÿ z = z_next;

ÿÿÿÿÿÿÿ // Check if we've reached the origin
ÿÿÿÿÿÿÿ if (std::abs(z - z_target) < eps) {
ÿÿÿÿÿÿÿÿÿÿÿ std::cout << "fin detected!:[" << i << "]:" << z << "\n";
ÿÿÿÿÿÿÿÿÿÿÿ break;
ÿÿÿÿÿÿÿ }
ÿÿÿ }

ÿÿÿ // Reverse to get original order
ÿÿÿ std::reverse(out_tokens.begin(), out_tokens.end());
ÿÿÿ out_z = z;

ÿÿÿ return load_err_sum;
}

int main() {
ÿÿÿ std::cout.precision(ct_float_nlim::max_digits10);
ÿÿÿ std::cout << "g_tokens_str:" << g_tokens_str << "\n\n";

ÿÿÿ {
ÿÿÿÿÿÿÿ ct_complex z_origin = { -.75, .06 };
ÿÿÿÿÿÿÿ std::string stored = "CHRIS";
ÿÿÿÿÿÿÿ ct_int power = ct_gain_power(stored);

ÿÿÿÿÿÿÿ std::cout << "stored:" << stored << "\n";
ÿÿÿÿÿÿÿ std::cout << "power:" << power << "\n\n";
ÿÿÿÿÿÿÿ std::cout << "________________________________________\n";

ÿÿÿÿÿÿÿ // STORE
ÿÿÿÿÿÿÿ ct_complex z_stored = ct_store(z_origin, power, stored);

ÿÿÿÿÿÿÿ std::cout << "________________________________________\n";
ÿÿÿÿÿÿÿ std::cout << "\nSTORED POINT:" << z_stored << "\n";
ÿÿÿÿÿÿÿ std::cout << "________________________________________\n";

ÿÿÿÿÿÿÿ // LOAD - try both methods
ÿÿÿÿÿÿÿ std::string loaded;
ÿÿÿÿÿÿÿ ct_complex z_loaded;
ÿÿÿÿÿÿÿ ct_float eps = .001;

ÿÿÿÿÿÿÿ std::cout << "\n=== Testing LINEAR SEARCH method ===\n";
ÿÿÿÿÿÿÿ ct_float load_err_sum =
ÿÿÿÿÿÿÿÿÿÿÿ ct_load(z_stored, z_origin, power, eps, loaded, z_loaded, false);

ÿÿÿÿÿÿÿ std::cout << "________________________________________\n";
ÿÿÿÿÿÿÿ std::cout << "\nORIGIN POINT:" << z_origin << "\n";
ÿÿÿÿÿÿÿ std::cout << "LOADED POINT:" << z_loaded << "\n";
ÿÿÿÿÿÿÿ std::cout << "\nloaded:" << loaded << "\n";
ÿÿÿÿÿÿÿ std::cout << "load_err_sum:" << load_err_sum << "\n";

ÿÿÿÿÿÿÿ if (stored == loaded) {
ÿÿÿÿÿÿÿÿÿÿÿ std::cout << "\n\nDATA COHERENT! :^D" << "\n";
ÿÿÿÿÿÿÿ }
ÿÿÿÿÿÿÿ else {
ÿÿÿÿÿÿÿÿÿÿÿ std::cout << "\n\n***** DATA CORRUPTED!!! Shi%! *****" <<
"\n";
ÿÿÿÿÿÿÿÿÿÿÿ std::cout << "Expected: " << stored << "\n";
ÿÿÿÿÿÿÿÿÿÿÿ std::cout << "Got:ÿÿÿÿÿ " << loaded << "\n";
ÿÿÿÿÿÿÿ }

ÿÿÿÿÿÿÿ // Try direct method
ÿÿÿÿÿÿÿ std::cout << "\n\n=== Testing DIRECT ANGULAR method ===\n";
ÿÿÿÿÿÿÿ std::string loaded_direct;
ÿÿÿÿÿÿÿ ct_complex z_loaded_direct;

ÿÿÿÿÿÿÿ ct_float load_err_sum_direct =
ÿÿÿÿÿÿÿÿÿÿÿ ct_load(z_stored, z_origin, power, eps, loaded_direct, z_loaded_direct, true);

ÿÿÿÿÿÿÿ std::cout << "________________________________________\n";
ÿÿÿÿÿÿÿ std::cout << "\nloaded:" << loaded_direct << "\n";

ÿÿÿÿÿÿÿ if (stored == loaded_direct) {
ÿÿÿÿÿÿÿÿÿÿÿ std::cout << "\n\nDATA COHERENT (DIRECT METHOD)! :^D" << "\n";
ÿÿÿÿÿÿÿ }
ÿÿÿÿÿÿÿ else {
ÿÿÿÿÿÿÿÿÿÿÿ std::cout << "\n\n***** DATA CORRUPTED (DIRECT METHOD)!!! *****" << "\n";
ÿÿÿÿÿÿÿÿÿÿÿ std::cout << "Expected: " << stored << "\n";
ÿÿÿÿÿÿÿÿÿÿÿ std::cout << "Got:ÿÿÿÿÿ " << loaded_direct << "\n";
ÿÿÿÿÿÿÿ }
ÿÿÿ }

ÿÿÿ std::cout << "\n\nFin, hit <ENTER> to exit...\n";
ÿÿÿ std::fflush(stdout);
ÿÿÿ std::cin.get();

ÿÿÿ return 0;
}
_____________________________________

--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

On 1/14/2026 4:33 AM, Bonita Montero wrote:

Am 11.01.2026 um 23:03 schrieb Chris M. Thomasson:

This is a reworked fun experiment I had about how to store and load
data in complex numbers:

https://groups.google.com/g/comp.lang.c++/c/bB1wA4wvoFc/m/OTccTiXLAgAJ



// updated code
Can you run it and tell me what you get? Thanks!

:^)
_____________________________________
// Chris M. Thomasson
// complex storage for fun...


#include <complex>
#include <iostream>
#include <vector>
#include <limits>
#include <algorithm>
#include <cstdint>
#include <cassert>
#include <cstring>

typedef std::int64_t ct_int;
typedef std::uint64_t ct_uint;
typedef double ct_float;
typedef std::numeric_limits<ct_float> ct_float_nlim;
typedef std::complex<ct_float> ct_complex;
typedef std::vector<ct_complex> ct_complex_vec;

I would recomment to use a ct_cout also.
That would increase the readability.

;^)

Iirc, back when I created it I used typedef's to try to get my own set
of types so that I can test double vs float, or even define them to
something else. For instance, perhaps use my own complex with arbitrary precision for its real and imag components.

[...]


--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

Am 14.01.2026 um 20:33 schrieb Chris M. Thomasson:

On 1/14/2026 4:33 AM, Bonita Montero wrote:

Am 11.01.2026 um 23:03 schrieb Chris M. Thomasson:

This is a reworked fun experiment I had about how to store and load
data in complex numbers:

https://groups.google.com/g/comp.lang.c++/c/bB1wA4wvoFc/m/OTccTiXLAgAJ



// updated code
Can you run it and tell me what you get? Thanks!

:^)
_____________________________________
// Chris M. Thomasson
// complex storage for fun...


#include <complex>
#include <iostream>
#include <vector>
#include <limits>
#include <algorithm>
#include <cstdint>
#include <cassert>
#include <cstring>

typedef std::int64_t ct_int;
typedef std::uint64_t ct_uint;
typedef double ct_float;
typedef std::numeric_limits<ct_float> ct_float_nlim;
typedef std::complex<ct_float> ct_complex;
typedef std::vector<ct_complex> ct_complex_vec;

I would recomment to use a ct_cout also.
That would increase the readability.

;^)

Iirc, back when I created it I used typedef's to try to get my own set
of types so that I can test double vs float, or even define them to something else. For instance, perhaps use my own complex with arbitrary precision for its real and imag components.

[...]

ct_xxx is counter-intuitive.


--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

On 1/14/2026 6:33 PM, Bonita Montero wrote:

Am 14.01.2026 um 20:33 schrieb Chris M. Thomasson:

On 1/14/2026 4:33 AM, Bonita Montero wrote:

Am 11.01.2026 um 23:03 schrieb Chris M. Thomasson:

This is a reworked fun experiment I had about how to store and load
data in complex numbers:

https://groups.google.com/g/comp.lang.c++/c/bB1wA4wvoFc/m/OTccTiXLAgAJ >>>>


// updated code
Can you run it and tell me what you get? Thanks!

:^)
_____________________________________
// Chris M. Thomasson
// complex storage for fun...


#include <complex>
#include <iostream>
#include <vector>
#include <limits>
#include <algorithm>
#include <cstdint>
#include <cassert>
#include <cstring>

typedef std::int64_t ct_int;
typedef std::uint64_t ct_uint;
typedef double ct_float;
typedef std::numeric_limits<ct_float> ct_float_nlim;
typedef std::complex<ct_float> ct_complex;
typedef std::vector<ct_complex> ct_complex_vec;

I would recomment to use a ct_cout also.
That would increase the readability.

;^)

Iirc, back when I created it I used typedef's to try to get my own set
of types so that I can test double vs float, or even define them to
something else. For instance, perhaps use my own complex with
arbitrary precision for its real and imag components.

[...]

ct_xxx is counter-intuitive.

I agree.

--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

On 1/15/2026 7:45 PM, Chris M. Thomasson wrote:

On 1/14/2026 6:33 PM, Bonita Montero wrote:

Am 14.01.2026 um 20:33 schrieb Chris M. Thomasson:

On 1/14/2026 4:33 AM, Bonita Montero wrote:

Am 11.01.2026 um 23:03 schrieb Chris M. Thomasson:

This is a reworked fun experiment I had about how to store and load >>>>> data in complex numbers:

https://groups.google.com/g/comp.lang.c++/c/bB1wA4wvoFc/m/OTccTiXLAgAJ >>>>>


// updated code
Can you run it and tell me what you get? Thanks!

:^)
_____________________________________
// Chris M. Thomasson
// complex storage for fun...


#include <complex>
#include <iostream>
#include <vector>
#include <limits>
#include <algorithm>
#include <cstdint>
#include <cassert>
#include <cstring>

typedef std::int64_t ct_int;
typedef std::uint64_t ct_uint;
typedef double ct_float;
typedef std::numeric_limits<ct_float> ct_float_nlim;
typedef std::complex<ct_float> ct_complex;
typedef std::vector<ct_complex> ct_complex_vec;

I would recomment to use a ct_cout also.
That would increase the readability.

;^)

Iirc, back when I created it I used typedef's to try to get my own
set of types so that I can test double vs float, or even define them
to something else. For instance, perhaps use my own complex with
arbitrary precision for its real and imag components.

[...]

ct_xxx is counter-intuitive.

I agree.

Well, ct_* as a namespace is fine. But I see what you mean.

--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

Am 16.01.2026 um 04:46 schrieb Chris M. Thomasson:

Well, ct_* as a namespace is fine. But I see what you mean.

The best thing to do is request the namespace ct from the
standardization committee. Alternatively, I can recommend
namespace 7777078A_AAAC_4761_9B34-5BC0F1059353, as this
GUID is particularly easy to remember.

--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

On 16/01/2026 04:45, Chris M. Thomasson wrote:

On 1/14/2026 6:33 PM, Bonita Montero wrote:

ct_xxx is counter-intuitive.

I agree.

I disagree.

The ct_ prefix is not intuitive, based on the code (clearly it comes
from your name). But it is not /counter-intuitive/, which would mean it
goes directly against intuition.

"cs_int" could be called intuitive for a prefix used in code for
"complex storage".

"complex_int" would be counter-intuitive, because it would look like a
type for Gaussian integers rather than a local name for an integer type.

"ct_int" is neither intuitive nor counter-intuitive. It's just not particularly great, and looks like C-style code rather than C++ code
with namespaces, using directives, and templates rather than typedefs
like this. But it's perfectly good for trying things out while
developing - you can always polish it later if it is to be a general
library for wider use.



--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

Am 16.01.2026 um 09:23 schrieb David Brown:

On 16/01/2026 04:45, Chris M. Thomasson wrote:

On 1/14/2026 6:33 PM, Bonita Montero wrote:

ct_xxx is counter-intuitive.

I agree.

I disagree.

The ct_ prefix is not intuitive, based on the code (clearly it comes
from your name).ÿ But it is not /counter-intuitive/, which would mean it goes directly against intuition.

"cs_int" could be called intuitive for a prefix used in code for
"complex storage".

"complex_int" would be counter-intuitive, because it would look like a
type for Gaussian integers rather than a local name for an integer type.

"ct_int" is neither intuitive nor counter-intuitive.ÿ It's just not particularly great, and looks like C-style code rather than C++ code
with namespaces, using directives, and templates rather than typedefs
like this.ÿ But it's perfectly good for trying things out while
developing - you can always polish it later if it is to be a general
library for wider use.

SICK !

It's his project, not your, and not a shared project.
You're still focussed on details and not on the code itself.


--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)

On 1/16/2026 12:23 AM, David Brown wrote:

On 16/01/2026 04:45, Chris M. Thomasson wrote:

On 1/14/2026 6:33 PM, Bonita Montero wrote:

ct_xxx is counter-intuitive.

I agree.

I disagree.

The ct_ prefix is not intuitive, based on the code (clearly it comes
from your name).ÿ But it is not /counter-intuitive/, which would mean it goes directly against intuition.

"cs_int" could be called intuitive for a prefix used in code for
"complex storage".

"complex_int" would be counter-intuitive, because it would look like a
type for Gaussian integers rather than a local name for an integer type.

"ct_int" is neither intuitive nor counter-intuitive.ÿ It's just not particularly great, and looks like C-style code rather than C++ code
with namespaces, using directives, and templates rather than typedefs
like this.ÿ But it's perfectly good for trying things out while
developing - you can always polish it later if it is to be a general
library for wider use.

Thanks David. Agreed. I do need to port it to a complex number real,
imag parts being arbitrary precision.


--- PyGate Linux v1.5.2
* Origin: Dragon's Lair, PyGate NNTP<>Fido Gate (3:633/10)