Hey

genjix here, I'm posting as

mizerydearia since I'm not logged in ... blaa blaa

Here;s a fast way to calculate difficulty. It uses a modified

taylor series for the logarithm (you can see tutorials on

flipcode and wikipedia) and relies on logs to transform the difficulty calculation:

#include <iostream>

#include <cmath>

inline float fast_log(float val)

{

int * const exp_ptr = reinterpret_cast <int *>(&val);

int x = *exp_ptr;

const int log_2 = ((x >> 23) & 255) - 128;

x &= ~(255 << 23);

x += 127 << 23;

*exp_ptr = x;

val = ((-1.0f/3) * val + 2) * val - 2.0f/3;

return ((val + log_2) * 0.69314718f);

}

float difficulty(unsigned int bits)

{

static double max_body = fast_log(0x00ffff), scaland = fast_log(256);

return exp(max_body - fast_log(bits & 0x00ffffff) + scaland * (0x1d - ((bits & 0xff000000) >> 24)));

}

int main()

{

std::cout << difficulty(0x1b0404cb) << std::endl;

return 0;

}

Unfortunately I don't have much use for it in

libbitcoin. Maybe some miner will find it useful.

To see the math to go from the normal difficulty calculations (which require large big ints bigger than the space in any normal integer) to the calculation above, here's some python:

import decimal, math

l = math.log

e = math.e

print 0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3)))

print l(0x00ffff * 2**(8*(0x1d - 3)) / float(0x0404cb * 2**(8*(0x1b - 3))))

print l(0x00ffff * 2**(8*(0x1d - 3))) - l(0x0404cb * 2**(8*(0x1b - 3)))

print l(0x00ffff) + l(2**(8*(0x1d - 3))) - l(0x0404cb) - l(2**(8*(0x1b - 3)))

print l(0x00ffff) + (8*(0x1d - 3))*l(2) - l(0x0404cb) - (8*(0x1b - 3))*l(2)

print l(0x00ffff / float(0x0404cb)) + (8*(0x1d - 3))*l(2) - (8*(0x1b - 3))*l(2)

print l(0x00ffff / float(0x0404cb)) + (0x1d - 0x1b)*l(2**8)

Cya

update: Links added by miz