include/fc/crypto/sha256.hpp

@@ -92,6 +92,9 @@ class sha256
      */
     uint32_t approx_log_32()const;
 
+    void set_to_inverse_approx_log_32( uint32_t x );
+    static double inverse_approx_log_32_double( uint32_t x );
+
     uint64_t _hash[4];
 };
 

src/crypto/sha256.cpp

@@ -3,6 +3,7 @@
 #include <fc/fwd_impl.hpp>
 #include <openssl/sha.h>
 #include <string.h>
+#include <cmath>
 #include <fc/crypto/sha256.hpp>
 #include <fc/variant.hpp>
 #include <fc/exception/exception.hpp>
@@ -123,6 +124,43 @@ namespace fc {
       return y;
    }
 
+   void sha256::set_to_inverse_approx_log_32( uint32_t x )
+   {
+      uint8_t nzbits = uint8_t( x >> 0x18 );
+      _hash[0] = 0;
+      _hash[1] = 0;
+      _hash[2] = 0;
+      _hash[3] = 0;
+      if( nzbits == 0 )
+         return;
+      uint8_t x0 = uint8_t((x        ) & 0xFF);
+      uint8_t x1 = uint8_t((x >> 0x08) & 0xFF);
+      uint8_t x2 = uint8_t((x >> 0x10) & 0xFF);
+      uint8_t* my_bytes = (uint8_t*) data();
+      my_bytes[0x1F] = x0;
+      my_bytes[0x1E] = x1;
+      my_bytes[0x1D] = x2;
+      my_bytes[0x1C] = 1;
+
+      if( nzbits <= 0x18 )
+      {
+         (*this) = (*this) >> (0x18 - nzbits);
+      }
+      else
+         (*this) = (*this) << (nzbits - 0x18);
+      return;
+   }
+
+   double sha256::inverse_approx_log_32_double( uint32_t x )
+   {
+      uint8_t nzbits = uint8_t( x >> 0x18 );
+      if( nzbits == 0 )
+         return 0.0;
+      uint32_t b = 1 << 0x18;
+      uint32_t y = (x & (b-1)) | b;
+      return std::ldexp( y, int( nzbits ) - 0x18 );
+   }
+
    uint16_t sha256::clz()const
    {
       const uint8_t* my_bytes = (uint8_t*) data();

tests/crypto/log_test.cpp

@@ -1,10 +1,34 @@
 
+#include <boost/multiprecision/cpp_int.hpp>
+
 #include <fc/crypto/sha256.hpp>
 #include <fc/exception/exception.hpp>
 
 #include <fstream>
+#include <iomanip>
 #include <iostream>
 
+uint64_t endian_reverse( uint64_t x )
+{
+   uint64_t x0 = ((x        ) & 0xFF);
+   uint64_t x1 = ((x >> 0x08) & 0xFF);
+   uint64_t x2 = ((x >> 0x10) & 0xFF);
+   uint64_t x3 = ((x >> 0x18) & 0xFF);
+   uint64_t x4 = ((x >> 0x20) & 0xFF);
+   uint64_t x5 = ((x >> 0x28) & 0xFF);
+   uint64_t x6 = ((x >> 0x30) & 0xFF);
+   uint64_t x7 = ((x >> 0x38) & 0xFF);
+
+   return (x0 << 0x38)
+        | (x1 << 0x30)
+        | (x2 << 0x28)
+        | (x3 << 0x20)
+        | (x4 << 0x18)
+        | (x5 << 0x10)
+        | (x6 << 0x08)
+        | (x7        );
+}
+
 int main(int argc, char**argv, char** envp)
 {
    std::ifstream infile("log_test.txt");
@@ -33,6 +57,53 @@ int main(int argc, char**argv, char** envp)
          std::cerr << "got error on log(" << str_h << ")" << std::endl;
          ++errors;
       }
+      double d_ilog_h_test = h.inverse_approx_log_32_double( ref_log );
+      h.set_to_inverse_approx_log_32( ref_log );
+      if( ref_log != h.approx_log_32() )
+      {
+         std::cerr << "got error on ilog(" << ref_log << ")" << std::endl;
+         ++errors;
+      }
+
+      std::string str_ilog_h = h.str();
+      boost::multiprecision::uint256_t u256_ilog_h( "0x" + str_ilog_h );
+      double d_ilog_h_ref = u256_ilog_h.template convert_to<double>();
+      if( d_ilog_h_ref != d_ilog_h_test )
+      {
+         std::cerr << "got error on d_ilog(" << ref_log << ")" << std::endl;
+         ++errors;
+      }
+
+      if( h != fc::sha256() )
+      {
+         fc::sha256 h_before = h;
+         if( h._hash[3] == 0 )
+         {
+            if( h._hash[2] == 0 )
+            {
+               if( h._hash[1] == 0 )
+               {
+                  h._hash[0] = endian_reverse( endian_reverse( h._hash[0] )-1 );
+               }
+               h._hash[1] = endian_reverse( endian_reverse( h._hash[1] )-1 );
+            }
+            h._hash[2] = endian_reverse( endian_reverse( h._hash[2] )-1 );
+         }
+         h._hash[3] = endian_reverse( endian_reverse( h._hash[3] )-1 );
+         bool ok = (h.approx_log_32() < ref_log);
+         if( !ok )
+         {
+            std::cerr << "got error on logm1 for " << ref_log << std::endl;
+            std::cerr << "h0:" << str_h << std::endl;
+            std::cerr << "h1:" << h_before.str() << std::endl;
+            std::cerr << "h2:" << h.str() << std::endl;
+            std::cerr << "ref_log:" << std::hex << std::setw(8) << ref_log << std::endl;
+            std::cerr << "log(h) :" << std::hex << std::setw(8) << h.approx_log_32() << std::endl;
+            std::cerr << std::endl;
+            ++errors;
+         }
+      }
+
       ++cases;
    }