Reverse Iteration Fractal Encryption (all byte values)

/*
Original idea by: Juaquin Anderson, in the comments of the following thread:

https://plus.google.com/+JuaquinAnderson/posts/L9A3Da8ju3B

Implementation by: Chris M. Thomasson
______________________________________________________________________
*/

#include <iostream>
#include <complex>
#include <array>
#include <vector>
#include <climits>
#include <cassert>



#define ESP ((iim_float_t)0.000000001)


typedef double iim_float_t;
typedef std::complex<iim_float_t> complex_t;
typedef std::array<bool, CHAR_BIT> bitchar_t;


struct forward_ret
{
    complex_t z;
    bitchar_t bc;
};




static unsigned char
bitchar_get(
    bitchar_t
    );


static complex_t
iterate_reverse(
    complex_t,
    complex_t,
    bitchar_t const&
    );


static forward_ret
iterate_forward(
    complex_t,
    complex_t
);


unsigned char
bitchar_get(
    bitchar_t bc
) {
    assert(bc.size() == CHAR_BIT);

    unsigned char r = 0;
    unsigned int b = 1;

    for (unsigned int i = 0; i < bc.size(); ++i)
    {
        if (bc[i]) r = r | b;
        b = b << 1;
    }

    return r;
}


bitchar_t
bitchar_set(
    unsigned char n
) {
    bitchar_t r = { false };
    unsigned int b = 1;

    for (unsigned int i = 0; i < r.size(); ++i)
    {
        r[i] = (n & b) ? true : false;
        b = b << 1;
    }

    return r;
}


complex_t
iterate_reverse(
    complex_t z,
    complex_t c,
    bitchar_t const& bc
) {
    assert(bc.size() == CHAR_BIT);

    for (std::size_t i = 0; i < CHAR_BIT; ++i)
    {
        complex_t d = z - c;

        iim_float_t l = std::abs(d);
        iim_float_t s = std::sqrt(l);
        iim_float_t a = std::atan2(d.imag(), d.real()) / 2.0;
        iim_float_t r = 0;

        if (bc[i]) { r = 1; }
        else { r = -1; }

        complex_t nz = { r * s * std::cos(a), r * s * std::sin(a) };

        if (bc[i] == 1)
        {
            std::cout << "iterate_reverse:[" << i << "]:("
                << bc[i] << "):(+) = " << nz << std::endl;
        }

        else
        {
            std::cout << "iterate_reverse:[" << i << "]:("
                << bc[i] << "):(-) = " << nz << std::endl;
        }

        z = nz;
    }

    std::cout << "__________________________________________" << std::endl;

    return z;
}


forward_ret
iterate_forward(
    complex_t z,
    complex_t c
) {
    forward_ret ret = { { z },{ false } };

    std::cout << "iterate_forward:(origin):" << z << std::endl;

    for (std::size_t i = 0; i < CHAR_BIT; ++i)
    {
        complex_t pz = ret.z;
        ret.z = ret.z * ret.z + c;

        // check for bit on condition
        if (pz.real() > 0.0)
        {
            // turn the proper bit on...
            std::size_t bc_i = CHAR_BIT - (i + 1);
            ret.bc[bc_i] = true;
        }

        iim_float_t l = std::abs(ret.z);

        if (l < ESP)
        {
            std::cout << "iterate_forward:(term):[" << i << "]: " << ret.z << std::endl;
            break;
        }

        std::cout << "iterate_forward:[" << i << "]: " << ret.z << std::endl;
    }

    std::cout << "__________________________________________" << std::endl;

    return ret;
}




int main()
{
    {
        // the secret key c
        complex_t c = { -0.75, 0.09 };

        // the origin of iteration z
        complex_t z = { 0.0, 0.0 };

        // A bytes to encode, the plaintext pt
        std::cout << std::endl << "**********************************************************"
                  << std::endl;

        for (std::size_t pt = 0; pt < UCHAR_MAX + 1; ++pt)
        {
            std::cout << "encoding pt:" << pt << std::endl;
            std::cout << "__________________________________________" << std::endl;

            // set pt to bitchar_t
            bitchar_t pt_bits = bitchar_set(pt);

            // Our encoded byte point origin, out ciphertext ct
            complex_t ct = iterate_reverse(z, c, pt_bits);

            // Our decoded bits and point origin db_z
            forward_ret db_z = iterate_forward(ct, c);

            // Our decoded byte db, should be equal to plaintext pt.
            unsigned char db = bitchar_get(db_z.bc);

            if (pt != db)
            {
                std::cout << "pt:" << pt << " != db:" << (int)db << std::endl;
                std::cin.get();
                assert(pt == db);
            }

            std::cout << "decoded: pt:" << pt << " == db:" << (int)db << std::endl;

            std::cout << "**********************************************************"
                      << std::endl;
        }
    }

    std::cout << std::endl << "__________________________________________"
        << std::endl << "Program Complete!" << std::endl;

    std::cin.get();

    return 0;
}