Reverse Iteration Fractal Encryption

/*
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 byte to encode, the plaintext pt
        unsigned char pt = 203;

        // 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:" << (int)pt << " != db:" << (int)db << std::endl;
            assert(pt == db);
        }

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

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

    std::cin.get();

    return 0;
}