ALLEN R. MAJEWSKI
A QUALIFYING EXAM PAPER PRESENTED TO THE GRADUATE SCHOOL
OF THE UNIVERSITY OF FLORIDA IN PARTIAL FULFILLMENT
OF THE REQUIREMENTS FOR THE DEGREE OF
DOCTOR OF PHILOSOPHY
UNIVERSITY OF FLORIDA
Get bitcoin price data from the coinbase API and parse it into an easily manipulated form.
>>> from fast_dump_v22 import *
Will return all the data on page 1 of coinbase’s bitcoin price API (this is the latest data).
You can almost always turn on optional debug statements
>>> get_first_N(3, show=True)
... fetching first 3
You can get all the price data that coinbase has
... getting page 1
... getting page 2
... getting page 3
... getting page 4
... getting page 5
... getting page 6
... getting page 7
... getting page 8
... getting page 9
... etc ...
All the ‘get_*’ functions return a price_data string, which is interlaced timestamps and prices littered with newlines and commas. You can print them to see what is going on more clearly:
Turn on the optional show switch for printing large vectors
>>> prices(get_page(11), show=True)
... returning 11000 prices in specified range ...
You can use prices(data)[k] and timestamps()[j] to return the kth price in data, or the jth timestamp in data.
>>> data = get_page(1)
>>> prices(data, index=4)
are two equivalent ways of returning only the 4th price in the requested range (in this case, page 1). This also works for timestamps.
>>> timestamps(get_page(1)+get_page(2)) == timestamps(get_first_N(2), index=1166)
This shows the expressiveness of this module. In general:
>>> prices(get_page(2)) == parse(get_page(2))
prices() and timestamps() are just functions that return a parsed() object having a specific index, or indices.
>>> parse(get_page(1)+get_page(2)+get_page(3)) == prices(get_first_N(3))
>>> parse(get_page(2)+get_page(3)) == prices(get_range(2,3))
The parse() function is there to manually control the outputs instead of just getting prices, or timestamps
>>> x = parse(get_page(1))
As you can see, parse(price_data)[k] returns the kth price in the list. Indices [k] return the kth timestamp.
The parse() function takes care of some weird edge cases:
>>> get_first_N(3) == get_page(1)+get_page(2)+get_page(3)
>>> parse(get_first_N(3)) == parse(get_page(1)+get_page(2)+get_page(3))
>>> x = get_page(1)
>>> y = get_range(2,7)
>>> prices(get_first_N(7)) == prices(x+y)
OPERATOR( get_page(1) + get_page(2) + ... + get_page(k) ) == OPERATOR(get_first_N(k))
OPERATOR is parsed(), prices(), or timestamps(). We also know prices() can obviously display and return ranges of values. When returning large vectors, you can verify their length by setting show=True. The “show” parameter is optional for all get_* functions and provides some information about the operation being performed.
>>> print( prices(get_first_N(11), show=True) )
... returning 11000 prices in specified range...
since each page is a thousand pairs of values (timestamp, price).
>>> prices(get_page(2)) # returns a long list
fast_dump_v1* are older versions that are somewhat different. They are designed to store the fetched data in the .data directory. This in v2*, this was abandoned in favor of stdout redirection.
// 2015 altodinerd.com
A brief introduction to getting started with bitcoin on a linux distribution
For the impatient: Skip to step 1
Bitcoin is one of the most interesting technologies we have seen emerge in the past ten years. And it confuses everyone who sets out to use it. This post is my definitive guide to beginning your journey with bitcoin the right way.
To me, the right way includes, but is not limited to:
- Running bitcoin on a linux machine. My reasons for this are too many to really list here, but suffice it to say that since linux is widely regarded as the most secure operating system available, and the usage of bitcoin involves being your own bank, using bitcoin on linux is the best way to ensure your coins stay safe.
- Using the bitcoin-core wallet software. There are other wallets available. You actually don’t even need a wallet software to own bitcoins or even spend bitcoins. However, if you want to understand how bitcoin works under the hood – which you should, because you are going to be your own bank, you should use this software.
- Using the command line to do bitcoin things. Actually, using both the GUI and the command line is the way to go. This tutorial (this is part 1 of 2) will be a command-line-centric description because afterall, I’m trying to show you the right way to do things.
But that’s just, like, your opinion man.
It is. This is my blog.
You shouldn’t necessarily trust me or anyone – bitcoin isn’t about trust. But if you google “altoidnerd”, you’ll find that I have been around the bitcoin eco-system for quite some time. That’s all I can tell you.
There are just so many wallets available – why bitcoin-core? Because I have been using it for years, I have a very good method of keeping my coins safe, and that is what I am sharing with you today. Use it- it is THE wallet.
But altoidnerd, I don’t want to run linux. I like windows / OSX
I am a linux and an OSX user. So please understand the scope of my knowledge includes these operating systems. If you want to use OSX, most of this tutorial will make sense with minor changes perhaps.
If you want to use windows, that’s ok, I’m not going to judge you. Bitcoin-core is available for windows as well. Please understand however, I am not a windows user, so I will not be able to give you “the definitive bitcoin windows guide”. You can still read on, however, since you can apply much of this tutorial to usage of bitcoin-qt’s debug window instead of the command line.
Step 1: Download and install bitcoin-core
Navigate to bitcoin.org’s official download page and select the bitcoin-core distribution for your operating system. And do choose linux (tgz). Do that because you should be running linux. But if you aren’t, even though you should be, choose the distribution for your operating system. Extract and install the client.
The “right way”
To really take control of things, and understand what is happening, you’re going to want to run bitcoin software from the command line. Though it isn’t really necessary to download the thing from the command line, I’m going to describe that here because this tutorial is the first installment of a start to finish command line approach. For a sneak peak of what I mean, see an earlier post where I described how to use bitcoin-core to generate QR codes without having to trust shady ass websites.
Go to your home directory and create a new directory just for bitcoin. This is not a necessary step, but once again, this is my “right way” tutorial and I will explain reasons for this later on. Enter the directory, and download the tarball with the “wget” command. The extract the tarball like so:
tar -xzvf bitcoin-0.11.0-linux64.tar.gz
Sweet. Now change directory to where the binaries are,
and launch “bitcoin-qt” (qt means its the GUI version).
It’s going to show you the dialogue box below and ask you if you’d like to use the default directory. Do it. Click “OK”.
You’ll see a friendly startup screen if you’ve done things right!
Step 2: Encrypt your wallet, and wait a few days
Bitcoin-core is called a “full-node” implementation, which means the first time you start it on your machine, it’s going to download every single bitcoin transaction that has ever taken place. Wait until the blockchain is synced to start making transactions.
In the mean time, you need to set a passphrase for your wallet. This is super important. In the upper left corner of bitcoin-qt, go to settings -> Encrypt Wallet, and set a very strong passphrase.
This will make it impossible for anyone to send bitcoins from your wallet without entering your password:
Just make sure you:
- Make your password extremely long. I don’t know if there is a length limit in the bitcoin-core code or not. Regardless, seriously push your personal boundaries on what you think a safe password is. Make it super duper long, and impossible to guess. Wise men have discussed password strength to a great extent. Pick a strong password. 20+ characters. Go for 30. No 40. Just make it long, and keep it an absolute secret.
- Never, ever lose or forget this password. If you lose or forgot your password, your coins will be unspendable forever. Neither you, nor anybody on earth, nor God himself will be able to spend your coins. Your coins will be effectively lost.
Picking a strong passphrase makes security so, so easy
Once you encrypt your wallet, you can copy and store
wallet.dat everywhere (I explain
wallet.dat in great detail in “Step 3”). I literally have copies of my main
wallet.dat on 6 or 7 computers, because come hell or highwater, I will always be able to find a copy of my
wallet.dat file. I suggest you do the same. Here is why strong encryption and insane redundancy works:
- If your password is ridiculously long, you can be very lazy and downright cavelier about where you keep your
wallet.dat, because even if someone finds the wallet file, they wont be able to do a damn thing with it. They won’t be able to spend your coins without your passphrase.
- This means that you can make copies of
wallet.datand store them like literally everywhere, on all your machines, three times over. In the cloud. On your mom’s computer. Hell, theoretically speaking, you can post your encrypted
wallet.daton the internet and just about everyone will have a copy, and be unable to spend your coins, because they don’t know your password. Someone remind me to put some coins into an address, and post the encrypted wallet online to prove my point.
If you encrypt your wallet like a boss, you never forget your password, you never tell anyone your password, and you copy the file to everywhere you possibly can imagine, you will never lose your coins. And nobody will be able to steal them from you. Seriously, nobody. It is computationally impossible.
Step 3: Understand what you just did on your computer
Let’s break it down this way. Here are some things that just happened when you launched bitcoin-qt for the first time:
- A hidden directory
~/.bitcoinwas created. It contains among other things the single most important thing ever: a file called
wallet.dat. This file is critical.
~/.bitcoin/wallet.datcontains all of your private keys.
wallet.datis life. When you see in headlines in the news like “Frustrated gentleman quite upset having lost a usb jump drive containing 100,000 BTC“, it means he doesn’t have a copy of
wallet.dat, so neither he, nor anyone on earth, nor God himself can spend his coins anymore.
- Your computer started downloading the blockchain. The blockchain is a record of every bitcoin transaction ever to have taken place. This will take a few days. As of today, the blockchain is about 42 gigabytes. Make sure you have space for it.
Do not delete your
wallet.datfile. Just don’t. If you want to start a new wallet, instead of deleting
wallet.dat, just rename it to something else, like
wallet.dat.old, restart bitcoin-qt, and it will create a new wallet for you. Keep your wallets people. Keep them good.
Notice how I have a file called
wallet.dat.default? That’s because I never delete a wallet. When I installed bitcoin on this computer, I moved the
wallet.datthat stores my coins into
~/.bitcoin/, but first I renamed the existing file so I can keep it. Because, why not? I’m telling you – don’t delete a file called
wallet.dat, because mistakes happen, and its better to have hundreds of files named
wallet.dat.*than it is to lose your coins.
- A hidden directory
In my next post, I will describe some of the features of the bitcoin-qt debug window,
bitcoind and its helper
bitcoin-cli. You can do interesting things, like import new keys, or convert keys to qr-codes.
If you have ay questions, please feel free to comment or contact me.
If you liked this post, you can donate bitcoins to me here: 12gKRdrz7yy7erg5apUvSRGemypTUvBRuJ
Learn about the author here:
I know Vi Hart discussed it, but she may have not been the first to entertain the idea. Not sure. The question is do they digits of pi contain copies of hamlet?
Yes, yes they do. Not just copies of Hamlet, but actually copies of every book imaginable are contained within the digits of pi an infinite number of times.
Using software package pi and simple shell commands,
I found that any N digit sequence probably appears within the first 10^N digits of pi ; moreover, the sequence would appear about 10 times in the first 10^(N+1) digits of pi, 100 times in the first 10^(N+2) digits, etc.
For example, lets say our sequence is the last 4 digits of my phone number – 1345
That’s 4 digits, so if I scan the first 104 digits of pi, sure enough, my phone number occurs 1 time. If I scan 105 digits, it occurs 12 times. For 109 digits, it occures like 98 times. Its clockwork. See below.
altoidnerd@HADRON:~$ pi 10000|grep -o 1345|grep -c 1345
altoidnerd@HADRON:~$ pi 100000|grep -o 1345|grep -c 1345
altoidnerd@HADRON:~$ pi 1000000|grep -o 1345|grep -c 1345
altoidnerd@HADRON:~$ pi 10000000|grep -o 1345|grep -c 1345
Anyway, so the question is how many digits of pi would we need to search through to likely find about 1 or 2 copies of hamlet in the sequence?
So I got hamlet in plaintext from 2 sources. I found that hamlet when compressed from plain text to a tar.gz archive, the average size was 69 KiB. Therefore, (I think?) that means to represent hamlet as just a binary integer, it would have 69 x 8 x 1024 digits = 565248 digits.
To get the number of digits in base 10, we multiply by log_10 (2) +~ .69 so the base ten hamlet would be like a sequence of about ~390,000 digitsm (0-9).
Ok so back to pi. How many digits of pi must we scan to probably find a string of length 390,000? That would be 10^390000 digits. That’s a lot of pi, but pi has got enough digits to spare. We should see approximately 1 copy of hamlet in the first 10^390000 digits of pi.
Even cooler is that if we just increase the power by 1, we should see 10 hamlets; increase the power by 2, and we should get 100 copies of hamlet. So quickly, we end up with infinite hamlets in the digits of pi. And not only hamlet … this argument should would for any book.
 This is not too surprising since pi is believed to be a normal number, though this is unproven.
This blog post is a glorified (with some images and minor changes) copy pasta of my post on /r/cryptomarkets.
LTC – how low can it go? It might be time to take a shot with LTC for a potential bitcoin profit.
I have done this with LTC a few times – the best of which was last November. Priced in BTC, it is now near parity with DRK and below .01 … which isn’t far from the price I think I paid for a bunch of LTC right before the boom in November, when I started writing about trading in /r/cryptomarkets with “the golden rules for alt trading.”
One thing that makes LTC different from other scrypt alts is its very slow ditribution – it’s just as slow as bitcoin. To me, that makes it still attractive as a swing trade, because big investors are probably thinking about it. What do y’all think?
BTW, just looked. I decided to buy lots off LTC last year at .008, and it’s not far from this mark. I wrote the golden rules to this sub from a 5-star hotel (I don’t stay in those) thanks to that trade. Good times…
If you write “fail” as 0x0FA11, not fail becomes 0xF05EE..or “foresee!”
It’s fun to try and write words in hex, like “deadbeef” of “cafebabe.” If we allow ourselves certain 1337 notations for letters, we can write even more words as Hexadecimal integers like “5ca1ab1e.” Pretty cool!
What is not scalable? Well that’s computable … not 0x5ca1ab1e is 0xa35e54e1. This isn’t a word.
But as I demonstrated above, much fun can be had by taking binary operations on these integers. Not fail is foresee. Can you find any others?
This is a full description of a situation often encountered by scientists in the process of fabrication of the NMR probe. The analysis requires some tedious complex algebra, a bit of circuit theory, and enforces a matching condition. I tried to write this so that one may infer the cirucit theory from context. If there is a problem, just ask.
We will examine the impedance of this reactive L network
Goals of this challenege:
Characterize the parameter space of the variables Cm, Ct, ω, L, r and produce some useful set of tables for lab, in which the relationship between Cm and Ct is known for a given ω L and r. Furthermore to ponder the level of greed allowed. Which parameters limit others? Compare this with what the laboratory reality is.
One must always strive for impedance matching conditions to be satisfied, which for us means 50 ohms real. So we must
Im_Z = 0
Re_Z = R := 50 ohms
These requirements are nasty if you allow the impedance of the coil to have a small (but very physical and influential) real part r
Z_coil = j ω L + r
So the total impedance is
Z_tot = -j / (Cm ω) + Z_coil || Z_Ct = Re_Z + j Im_Z = R + j 0 = 50
* Z_m is the impedance of the matching cap only
* Z_t is the impedance of the tuning cap only
* the notation A || B means “A parallel B” and A || B = ( 1/A + 1/B)^(-1)
Since Z_coil has a real and an imaginary part, the expression for total impedance is a headache.
So I did it by hand, and with mathematica, and iteratively found what I consider decently short code with reasonably concise expressions. Here we go.
Clone the mathematica stuff here
git clone https://github.com/Altoidnerd/NMR-Tank-Circuits
In which there is a file where I do in fact show the real and imaginary parts of Z_tot are:
real part (which we denote Re_Z…please note the sloppyness. Here w is ω)
Re_Z = r/((r^2 +
L^2 w^2) (r^2/(r^2 +
L^2 w^2)^2 + (T w - (L w)/(r^2 + L^2 w^2))^2))
and imaginary part (Im_Z)
ImZ = (-(1/(M w)) - (T w)/(r^2/(r^2 +
L^2 w^2)^2 + (T w - (L w)/(r^2 +
L^2 w^2))^2) + (L w)/((r^2 +
L^2 w^2) (r^2/(r^2 +
L^2 w^2)^2 + (T w - (L w)/(r^2 + L^2 w^2))^2)))
where we eliminated the need for subscripts but denoting Cm := M and Ct := T.
How do we make useful data from these equations? To answer this, we must first assess what the experimenter can really control.
* coils are hard to wind and have prescibed results. In general, the parameter r is less than 1 ohm, but its actual value is not constant through frequency sadly. It must be treated as such.
* A typical coil inductance L satisfied 1.0 uH < L 30 uH. Intermediate values such as 8 uH tend to be the most difficult to fabricate. A coil inductance of 8uH I find would be useful for lower frequencies, below 3MHz, which are currently causing me problems. It is here the equations become extremely sensitive.
* The capacitance T and M can within reason, be expected to continuously vary between 0 < T,M < 1 nF and even more reasonably if the upper boundary is around 300 pF.
* the frequency is going to satisfy 1 MHz < f < 30 MHz; so ω = 6.28 f so we can say about, that
1 e7 < ω < 3e8
I have made many charts. Got any brilliant ideas?
A typical annoying situation in lab would be:
Drat. To reach the target frequency, we must either replace the capacitors with larger ones,
or exchange the coil with one of larger inductance. Which will take me less time?
I usually do not know in fact. I either make a intuitive guess, prepare some primitive tests, or try a bit of each.
The code in the github repo above will give you some parameter sliders. You can try plotting M, and T vs ω as L and that little tiny r are varied…I still must get to the bottom of these matters, such as, the qualitative effect of increasing r at fixed ω and L etc. How to encapsulate all such desirable relations in a single concise set of diagrams is what I truly seek, from the kind theorists of who may read this.
I have studied this problem up down left right…I wrote some interesting special cases down here, but I believe there is more to be known about these equations that could be of service to the designer.
~$ sad grep poetry of the internet
# facebook | grep brains
# cat ./telecom| egrep (options|competit.?.?.?.?.?)
~$ ls -laR | grep food
# cat ./reddit/r/bitcoin/* | grep criminals
Display all 169,236 possibilities? (y or n)
~$ ./github/ | grep working code