|
If the computer time is set correctly, then you just need to let the blockchain download. It is a message telling you that you don't have the complete transaction record downloaded yet, and "Displayed transactions may not be correct..."
If the blockchain download will not resume after waiting a while, and you have many connections to the Bitcoin network, it may be an indication that you have firewall software or something else interfering with the network, or finally, that the blockchain file is corrupted.
the %appdata%\Bitcoin\debug.log (on Window) has a verbose record of all network activity. You can restart Bitcoin, wait for it to make connections and (fail) downloading the blockchain, then view the end of the file after the big restart space to see errors that are occurring related to blockchain download.
|
|
|
|
If I have to reinstall, is there any way to save the previously downloaded blockchain? I am not looking forward to that huge download again. The wallet and blockchain are stored in a user data directory, and are not removed when you uninstall the software. It doesn't look "installed" anyway, perhaps you just unzipped some file. The official download IS an installer, and is located here: http://sourceforge.net/projects/bitcoin/files/Bitcoin/bitcoin-0.8.6/bitcoin-0.8.6-win32-setup.exe/downloadIf this problem persists, you should make a copy of the wallet file (if you have used it for anything), it is located at %appdata%\Bitcoin\ and is called wallet.dat. Copy it only after Bitcoin is completely closed. Then start Bitcoin with the command to rebuild the wallet. Press WindowsKey + R, and type in: c:\Program Files (x86)\Bitcoin\bitcoin-qt.exe -salvagewallet (remove the (x86) if you are on 32-bit windows) If this is a new wallet with nothing of importance, you can just rename the old wallet.dat file, and Bitcoin will make a new blank file when it restarts. |
|
|
|
Hello guys,
I am having a major fatal error problem with 0.8.6 and was wondering if anyone could shed some light on what my issues are.
Windows DEP should not be invoked by Bitcoin, it only writes data to the user data directories by default. Have you changed the command-line or bitcoin.conf file to use a datadir option saving data in a different location? Bitcoin is also not running from the default install location. You should remove the program from the desktop folder, and download the official installer and install it with standard options. Windows may have policies set that prevent a non-installed program from running correctly. |
|
|
|
|
That's not what he's asking.
The length depends on how many case insensitive options there are for each word, along with the length of words and video card RAM. Case insensitive searches are unrolled into all possible matches; they consume the same resources as specifying all 100 or 1000 matching addresses.
I have a 12-13 character long word list, and case insensitive searches on it were limited to about 4000 entries. Shorter words can be tens of thousands in a list.
|
|
|
|
Will this version be compatible with my token ring ethernet LAN configuration?
Wot??? Are you sending this message from 1990? As long as your computer has a normal TCP/IP stack and can get on the Internet and run other Internet applications, Bitcoin should work. |
|
|
|
What about windows 8 installation this folder doesn't exist there
Even thought thread you bumped is older than Windows 8, the second post is correct. |
|
|
|
one negative issue with Bitcoin-Qt v0.8.6 client, it takes more than 8 hours to sync the client with network on 120Mb/s connection, slightly very long process, I think the reason behind the data is based one server instead of several geo locations.
Look at your cpu usage while downloading, especially after reaching the "20 weeks behind" point. You will see CPU being the bottleneck. Bitcoin verifies the ECDSA signatures in every transaction to ensure they are authorized payments, only better CPU or code optimizations will really improve this. Verifying an ECDSA signature takes about 3 ms. Let's say the typical transaction has 2 inputs. Each transaction is verified twice, once alone and once in a block. (12 ms)
|
|
|
|
Ok, I would like to revise my last submission then.
Realizing that your MOD 2^32-1 was essentially part of a rotate operation, it finally donned on me that my method of using the power properties of -1 would still work as a substitute modulus function which in turn would supply the bit inputs for the XOR function. As long as I could via your rotate as described, I could set the 1's bit, I could use even vs. odd powers of -1 as described in my previous post.
THE NEW PROGRAM:
...
Does this work for you?
It works for me! In Python, pretty much as written, : def xor(a, b):
return 0**(0**(0**(1+(-1)**(a*2**(32-0)%(2**32-1)))+0**(1+(-1)**(b*2**(32-0)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-0)%(2**32-1)))+0**(1+(-1)**(b*2**(32-0)%(2**32-1))))))+\
0**(0**(0**(1+(-1)**(a*2**(32-1)%(2**32-1)))+0**(1+(-1)**(b*2**(32-1)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-1)%(2**32-1)))+0**(1+(-1)**(b*2**(32-1)%(2**32-1))))))*2+\
0**(0**(0**(1+(-1)**(a*2**(32-2)%(2**32-1)))+0**(1+(-1)**(b*2**(32-2)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-2)%(2**32-1)))+0**(1+(-1)**(b*2**(32-2)%(2**32-1))))))*4+\
0**(0**(0**(1+(-1)**(a*2**(32-3)%(2**32-1)))+0**(1+(-1)**(b*2**(32-3)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-3)%(2**32-1)))+0**(1+(-1)**(b*2**(32-3)%(2**32-1))))))*8+\
0**(0**(0**(1+(-1)**(a*2**(32-4)%(2**32-1)))+0**(1+(-1)**(b*2**(32-4)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-4)%(2**32-1)))+0**(1+(-1)**(b*2**(32-4)%(2**32-1))))))*16+\
0**(0**(0**(1+(-1)**(a*2**(32-5)%(2**32-1)))+0**(1+(-1)**(b*2**(32-5)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-5)%(2**32-1)))+0**(1+(-1)**(b*2**(32-5)%(2**32-1))))))*32+\
0**(0**(0**(1+(-1)**(a*2**(32-6)%(2**32-1)))+0**(1+(-1)**(b*2**(32-6)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-6)%(2**32-1)))+0**(1+(-1)**(b*2**(32-6)%(2**32-1))))))*64+\
0**(0**(0**(1+(-1)**(a*2**(32-7)%(2**32-1)))+0**(1+(-1)**(b*2**(32-7)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-7)%(2**32-1)))+0**(1+(-1)**(b*2**(32-7)%(2**32-1))))))*128+\
0**(0**(0**(1+(-1)**(a*2**(32-8)%(2**32-1)))+0**(1+(-1)**(b*2**(32-8)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-8)%(2**32-1)))+0**(1+(-1)**(b*2**(32-8)%(2**32-1))))))*256+\
0**(0**(0**(1+(-1)**(a*2**(32-9)%(2**32-1)))+0**(1+(-1)**(b*2**(32-9)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-9)%(2**32-1)))+0**(1+(-1)**(b*2**(32-9)%(2**32-1))))))*512+\
0**(0**(0**(1+(-1)**(a*2**(32-10)%(2**32-1)))+0**(1+(-1)**(b*2**(32-10)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-10)%(2**32-1)))+0**(1+(-1)**(b*2**(32-10)%(2**32-1))))))*1024+\
0**(0**(0**(1+(-1)**(a*2**(32-11)%(2**32-1)))+0**(1+(-1)**(b*2**(32-11)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-11)%(2**32-1)))+0**(1+(-1)**(b*2**(32-11)%(2**32-1))))))*2048+\
0**(0**(0**(1+(-1)**(a*2**(32-12)%(2**32-1)))+0**(1+(-1)**(b*2**(32-12)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-12)%(2**32-1)))+0**(1+(-1)**(b*2**(32-12)%(2**32-1))))))*4096+\
0**(0**(0**(1+(-1)**(a*2**(32-13)%(2**32-1)))+0**(1+(-1)**(b*2**(32-13)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-13)%(2**32-1)))+0**(1+(-1)**(b*2**(32-13)%(2**32-1))))))*8192+\
0**(0**(0**(1+(-1)**(a*2**(32-14)%(2**32-1)))+0**(1+(-1)**(b*2**(32-14)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-14)%(2**32-1)))+0**(1+(-1)**(b*2**(32-14)%(2**32-1))))))*16384+\
0**(0**(0**(1+(-1)**(a*2**(32-15)%(2**32-1)))+0**(1+(-1)**(b*2**(32-15)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-15)%(2**32-1)))+0**(1+(-1)**(b*2**(32-15)%(2**32-1))))))*32768+\
0**(0**(0**(1+(-1)**(a*2**(32-16)%(2**32-1)))+0**(1+(-1)**(b*2**(32-16)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-16)%(2**32-1)))+0**(1+(-1)**(b*2**(32-16)%(2**32-1))))))*65536+\
0**(0**(0**(1+(-1)**(a*2**(32-17)%(2**32-1)))+0**(1+(-1)**(b*2**(32-17)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-17)%(2**32-1)))+0**(1+(-1)**(b*2**(32-17)%(2**32-1))))))*131072+\
0**(0**(0**(1+(-1)**(a*2**(32-18)%(2**32-1)))+0**(1+(-1)**(b*2**(32-18)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-18)%(2**32-1)))+0**(1+(-1)**(b*2**(32-18)%(2**32-1))))))*262144+\
0**(0**(0**(1+(-1)**(a*2**(32-19)%(2**32-1)))+0**(1+(-1)**(b*2**(32-19)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-19)%(2**32-1)))+0**(1+(-1)**(b*2**(32-19)%(2**32-1))))))*524288+\
0**(0**(0**(1+(-1)**(a*2**(32-20)%(2**32-1)))+0**(1+(-1)**(b*2**(32-20)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-20)%(2**32-1)))+0**(1+(-1)**(b*2**(32-20)%(2**32-1))))))*1048576+\
0**(0**(0**(1+(-1)**(a*2**(32-21)%(2**32-1)))+0**(1+(-1)**(b*2**(32-21)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-21)%(2**32-1)))+0**(1+(-1)**(b*2**(32-21)%(2**32-1))))))*2097152+\
0**(0**(0**(1+(-1)**(a*2**(32-22)%(2**32-1)))+0**(1+(-1)**(b*2**(32-22)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-22)%(2**32-1)))+0**(1+(-1)**(b*2**(32-22)%(2**32-1))))))*4194304+\
0**(0**(0**(1+(-1)**(a*2**(32-23)%(2**32-1)))+0**(1+(-1)**(b*2**(32-23)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-23)%(2**32-1)))+0**(1+(-1)**(b*2**(32-23)%(2**32-1))))))*8388608+\
0**(0**(0**(1+(-1)**(a*2**(32-24)%(2**32-1)))+0**(1+(-1)**(b*2**(32-24)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-24)%(2**32-1)))+0**(1+(-1)**(b*2**(32-24)%(2**32-1))))))*16777216+\
0**(0**(0**(1+(-1)**(a*2**(32-25)%(2**32-1)))+0**(1+(-1)**(b*2**(32-25)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-25)%(2**32-1)))+0**(1+(-1)**(b*2**(32-25)%(2**32-1))))))*33554432+\
0**(0**(0**(1+(-1)**(a*2**(32-26)%(2**32-1)))+0**(1+(-1)**(b*2**(32-26)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-26)%(2**32-1)))+0**(1+(-1)**(b*2**(32-26)%(2**32-1))))))*67108864+\
0**(0**(0**(1+(-1)**(a*2**(32-27)%(2**32-1)))+0**(1+(-1)**(b*2**(32-27)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-27)%(2**32-1)))+0**(1+(-1)**(b*2**(32-27)%(2**32-1))))))*134217728+\
0**(0**(0**(1+(-1)**(a*2**(32-28)%(2**32-1)))+0**(1+(-1)**(b*2**(32-28)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-28)%(2**32-1)))+0**(1+(-1)**(b*2**(32-28)%(2**32-1))))))*268435456+\
0**(0**(0**(1+(-1)**(a*2**(32-29)%(2**32-1)))+0**(1+(-1)**(b*2**(32-29)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-29)%(2**32-1)))+0**(1+(-1)**(b*2**(32-29)%(2**32-1))))))*536870912+\
0**(0**(0**(1+(-1)**(a*2**(32-30)%(2**32-1)))+0**(1+(-1)**(b*2**(32-30)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-30)%(2**32-1)))+0**(1+(-1)**(b*2**(32-30)%(2**32-1))))))*1073741824+\
0**(0**(0**(1+(-1)**(a*2**(32-31)%(2**32-1)))+0**(1+(-1)**(b*2**(32-31)%(2**32-1))))+0**(2-(0**(1+(-1)**(a*2**(32-31)%(2**32-1)))+0**(1+(-1)**(b*2**(32-31)%(2**32-1))))))*2147483648
def xorf(a, b): # floating point
return 0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-0)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-0)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-0)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-0)%(2.0**32.0-1.0))))))+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-1)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-1)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-1)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-1)%(2.0**32.0-1.0))))))*2.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-2)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-2)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-2)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-2)%(2.0**32.0-1.0))))))*4.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-3)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-3)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-3)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-3)%(2.0**32.0-1.0))))))*8.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-4)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-4)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-4)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-4)%(2.0**32.0-1.0))))))*16.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-5)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-5)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-5)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-5)%(2.0**32.0-1.0))))))*32.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-6)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-6)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-6)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-6)%(2.0**32.0-1.0))))))*64.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-7)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-7)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-7)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-7)%(2.0**32.0-1.0))))))*128.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-8)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-8)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-8)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-8)%(2.0**32.0-1.0))))))*256.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-9)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-9)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-9)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-9)%(2.0**32.0-1.0))))))*512.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-10)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-10)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-10)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-10)%(2.0**32.0-1.0))))))*1024.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-11)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-11)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-11)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-11)%(2.0**32.0-1.0))))))*2048.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-12)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-12)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-12)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-12)%(2.0**32.0-1.0))))))*4096.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-13)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-13)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-13)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-13)%(2.0**32.0-1.0))))))*8192.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-14)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-14)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-14)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-14)%(2.0**32.0-1.0))))))*16384.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-15)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-15)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-15)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-15)%(2.0**32.0-1.0))))))*32768.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-16)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-16)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-16)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-16)%(2.0**32.0-1.0))))))*65536.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-17)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-17)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-17)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-17)%(2.0**32.0-1.0))))))*131072.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-18)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-18)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-18)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-18)%(2.0**32.0-1.0))))))*262144.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-19)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-19)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-19)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-19)%(2.0**32.0-1.0))))))*524288.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-20)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-20)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-20)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-20)%(2.0**32.0-1.0))))))*1048576.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-21)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-21)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-21)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-21)%(2.0**32.0-1.0))))))*2097152.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-22)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-22)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-22)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-22)%(2.0**32.0-1.0))))))*4194304.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-23)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-23)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-23)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-23)%(2.0**32.0-1.0))))))*8388608.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-24)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-24)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-24)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-24)%(2.0**32.0-1.0))))))*16777216.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-25)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-25)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-25)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-25)%(2.0**32.0-1.0))))))*33554432.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-26)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-26)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-26)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-26)%(2.0**32.0-1.0))))))*67108864.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-27)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-27)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-27)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-27)%(2.0**32.0-1.0))))))*134217728.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-28)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-28)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-28)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-28)%(2.0**32.0-1.0))))))*268435456.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-29)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-29)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-29)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-29)%(2.0**32.0-1.0))))))*536870912.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-30)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-30)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-30)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-30)%(2.0**32.0-1.0))))))*1073741824.0+\
0.0**(0.0**(0.0**(1.0+(-1.0)**(a*2.0**(32.0-31)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-31)%(2.0**32.0-1.0))))+0.0**(2-(0.0**(1.0+(-1.0)**(a*2.0**(32.0-31)%(2.0**32.0-1.0)))+0.0**(1.0+(-1.0)**(b*2.0**(32.0-31)%(2.0**32.0-1.0))))))*2147483648.0>>> import random >>> for i in xrange(20): a=random.randint(0,2**32-1) b=random.randint(0,2**32-1) print 'a:%8x b:%8x xor:%8x - %8x , %s' % (a, b, a^b, xor(a, b), xor(a, b)) print 'floating point: %12.2f' % xorf(float(a),float(b)) a:10dbc5d8 b:9c87fc6b xor:8c5c39b3 - 8c5c39b3 , 2354854323
floating point: 2354854323.00
a:7675bcc4 b:35122712 xor:43679bd6 - 43679bd6 , 1130863574
floating point: 1130863574.00
a:3fd4cd4a b:ceb8e67f xor:f16c2b35 - f16c2b35 , 4050398005
floating point: 4050398005.00
a:925bd59b b: e846797 xor:9cdfb20c - 9cdfb20c , 2631905804
floating point: 2631905804.00
a:8d2506e7 b:c78201a1 xor:4aa70746 - 4aa70746 , 1252460358
floating point: 1252460358.00
a:6953c22c b:e9a1dd67 xor:80f21f4b - 80f21f4b , 2163351371
floating point: 2163351371.00
a:197321b5 b:5eb9abd8 xor:47ca8a6d - 47ca8a6d , 1204456045
floating point: 1204456045.00
a:3ec9737a b:2997f27b xor:175e8101 - 175e8101 , 392069377
floating point: 392069377.00
a:822d1508 b:a80b10da xor:2a2605d2 - 2a2605d2 , 707134930
floating point: 707134930.00
a:faf8ac11 b:69369fba xor:93ce33ab - 93ce33ab , 2479764395
floating point: 2479764395.00
a:8db3d46b b:971874c7 xor:1aaba0ac - 1aaba0ac , 447455404
floating point: 447455404.00
a:4b559b49 b: 800f850 xor:43556319 - 43556319 , 1129669401
floating point: 1129669401.00I'm sorry to be that guy, but what kind if calculators do you guys have? Or are you just using Python/Perl?
I think a better question is what kind of calculator do you have that can store a formula or code, but doesn't already have XOR? This does: http://h20331.www2.hp.com/Hpsub/downloads/35_23_Base_Logic_functions.pdfIf it doesn't, but is programmable, you would have a better list of operators you can employ to do the logic functions anyway: http://www.hpmuseum.org/software/32sbits.htm |
|
|
|
|
Because the software has not been largely updated since it was written, which is when opencl 1.0 was just transitioning to 1.1.
OpenCL apps have not yet become generic, they almost have to target a particular card and driver, since driver updates keep breaking things.
Here is an interesting topic - below are the only ATI HDXXXX GPUs that support double-precision math. It would be interesting to see if the computing problem on new drivers varies based on this card list:
HD 5830 HD 5850 HD 5870 HD 5970
HD 6930 HD 6950 HD 6970 HD 6990
HD 7730 HD 7750 HD 7770 HD 7790 HD 7850
HD 7870 HD 7950 HD 7970 HD 7990
I have a 5770, and vanitygen works fine (and first worked correctly) using Driver 11.11, which includes the SDK 2.5 runtime. It doesn't work on any later drivers. One conspiracy theory could be that other OpenCL computing features were disabled on single-precision cards in later drivers.
Here is a list of each first driver version that included a new SDK. You must also be aware that the ATI uninstaller does not properly uninstall key OpenCL files. If you want to experiment, you should increment starting with older versions, so you don't have to manually delete left-behind files each time.
AMD APP SDK v2.9 AMD Catalyst™ 13.11 beta (13.20.16)
AMD APP SDK v2.8.1 AMD Catalyst™ 13.6 Beta2 (13.101)
AMD APP SDK v2.8 AMD Catalyst™ 12.10 (9.002)
AMD APP SDK v2.7 AMD Catalyst™ 12.4 (8.961)
AMD APP SDK v2.6 AMD Catalyst™ 11.12 (8.92)
AMD APP SDK v2.5 AMD Catalyst™ 11.7 (8.872)
AMD APP SDK v2.4 ATI Catalyst™ 11.4 Update Driver (8.841)
|
|
|
|
Also having the GPU hash/CPU hash error. I'm running Catalyst 13.11 and downgrading is not an option for me. Also AMD APP SDK v2.9, willing to downgrade this if this is the issue.
Having this error as well, and also downgrading is not an option. Anyone have any solution for this? Yes, the solution is to rewrite vanitygen in opencl 1.2. Of course, why should this happen, the last time someone donated to samr, it was 0.001 four months ago, and then $2 worth a year ago. "downgrading is not an option"...heh |
|
|
|
This sounds like a lot of chemical jibberjabber for something that can be done with webcam noise or lava lamps. One solution I would have is to take a software defined radio such as http://spectrum.ieee.org/geek-life/hands-on/a-40-softwaredefined-radioTake the 3 million raw I/Q samples per second of background radio and send the data through about 10000 XORed SHA hashes to get 512 bits a second. Random. |
|
|
|
Well that's a pretty awful infographic. Change: Only the full amount of an input can be spent. If the exact amount of the transaction can’t be constructed from available inputs, an additional output, called change, is added, which sends the remainder back to a new address in the user’s wallet. Change addresses are not shown to the user.  |
|
|
|
Hi! Well, the 2 32-1 is needed for one purpose. Let us keep it simple: In order to rorate a 8 bitfield (lets say x) once to the left, you would do the following operation: x*2 mod (2 8-1) Lets quickly verify: 10010110 = 150 Bitrotation to the left: 00101101 = 45 Now doublecheck with math operator: 150*2 mod (2 8 -1) = 45 WORKS LIKE A CHARM!Now what we want it is in the 32bit case the following (very simplified case): x = x xor LEFT_ROTATE(y) As the modulo operator is pretty costly I would want to apply it only once! Meaning ... performing all the calculations, and afterwards doing once the "mod 2 32-1". This is perfectly legit, as the modulo operator is completely associative [e.g. (a mod n) + (b mod n) = (a+b) mod n - as well as - (a * b) mod n = (a mod n) * (b mod n) ]  Modulo is not costly. In some cases, it can be faster in CPU than instructions to store data. XOR is bitwise arithmetic mod 2, it will take 3 mod operations per bit outside of that needed to shuffle things around. I will only adapt your silly mod to into mod 2, which I have already written. |
|
|
|
|
I think I can solve this using the initial terms, but it will have to be later today.
"Allowed operators: powers, *, /, + and -. Also modulo (2^32-1) is allowed."
The mod rule is not a hindrance if we were given infinite precision, as x % 2^32 can be obtained by x *((2^32-1)/(2^32)) % (2^32-1), but I assume this would not be allowed due to some computing platforms with limited float precision (it works in python to 53 sig figs):
def mod32(r):
r = float(r)
return ((r/2.0**32.0 * (2.0**32.0-1.0)) % (2.0**32.0-1.0)) * 2.0**32.0 / (2.0**32.0-1.0)
>>> print mod32(1), 1 % 0x100000000
1.0 1
>>> print mod32(0xffffffff), 0xffffffff % 0x100000000
4294967295.0 4294967295
>>> print mod32(0x100000000), 0x100000000 % 0x100000000
0.0 0
If not, it will have to be via math->logic, as in all bits are set : (x-(x%(2^32-1)))/(2^32-1)
|
|
|
|
Just a pointer ... it might be sufficient to find a representation of the AND operator ;-)
I have not yet proven it, but I think that A XOR B = A+B-2(A AND B)
For individual bits using and, multiplication, and inversion:  (I'll keep adding) The truth table for xor is: Your truth table: although if you can use a logic operation, why can't we just use the correct one? |
|
|
|
|
I can put the int functions in the right place for float.
I think the OP has made a non-solvable challenge. The solution of shifting left and shifting right to truncate to one bit at a time is as elegant as it is going to get.
If mod is the only function that can be used, but unlimited variables can be used, you could discover the bits with maths.
|
|
|
|
|
I found the python problem. I didn't have a constant 231 in the middle, and it now seems to work when only using the integer function and of course passing integers. (stupid edits, I found my goof independently...)
I would think a mathematics computing and simulation platform would have no concept of int data types presented to the user though, you would have to call an int() function.
|
|
|
|
|
Why? Why do you do this? You are asking an unanswerable question. You want stupid answers? Okay, ten. Ten people are mining altcoins. Ten people and 1000 sock puppets for each of them, spamming and pumping and dumping. You might as well ask, "how many people are eating peanut butter and jelly sandwiches right now?"
The hashrate for a particular coin can be determined if you look at it's current difficulty and what the hashrate equivalent is, and from there at least you can guess how much mining hardware of a particular type might be employed.
|
|
|
|
This. This is a terrible idea. The forum is full of newbies asking stupid questions (like how do I mine with my Celeron CPU).
Hey, I take offense to this post! (actually a Celeron mobo packed with GPUs was power efficient, but the cheapest was Sempron 140, which could be undervolted to about two watts) At least people have the place to self-noob again when they ask about guiminer on their Geforce 8600 and re-ask other stickied and FAQ questions. Off-topic, one of my favorite noob interjections in a technical thread: Yes, it would be a huge security risk as eventually it would be so easy to generate a block that someone could generate multiple blocks at one time with their phone... |
|
|
|
|
The first challenge in this thought exercise is how do you extract the value of a bit using only formulas, and not int or mod?
I give you two numbers, 0b0101 = 5 or 0b0111 = 7. Tell me if the 2 bit is set. Allowed operators: powers, *, /, + and -.
|
|
|
|
|
Show Posts
