Saturday, December 31, 2011

Picomath

The Picomath project holds some reusable math functions inspired by John D. Cook's Stand-alone code for numerical computing, including:

• Error function
• Phi (standard normal CDF)
• Phi inverse
• Gamma
• Log Gamma
• exp(x) - 1 (for small x)
• log(n!)

These functions are implemented in an impressive list of languages: Ada, C++, C#, D, Erlang, Go, Haskell, Java, Javascript, Lua, Pascal, Perl, PHP, Python (2.x and 3.x), Ruby, Scheme, and Tcl.

And now Factor!

You can find the code (and a bunch of tests) for this on my Github.

Friday, December 30, 2011

Slot Machines

Playing slot machines can be pretty fun, but don't be fooled by claims that the casino has the "loosest slots", odds are probably still against you. I thought it would be fun (and cheaper!) to build a slot machine simulator using Factor.

Our slot machine is going to be a console application that will look something like this:

Spinning

Even though our slot machine is text-only, we can still make use of some nice unicode characters to be our symbols:

`CONSTANT: SYMBOLS "☀☁☂☃"`

Each spin chooses a different symbol at random (each being equally likely):

```: spin ( value -- value' )
SYMBOLS remove random ;```

To reproduce the feel of spinning a slot machine, we will introduce a slight delay so that the wheel spins fast at the beginning and then slower and slower until it stops on a symbol:

```: spin-delay ( n -- )
15 * 25 + milliseconds sleep ;```

Spinning the slot machine takes a spin number, delays for a bit, then rotates each wheel (we stop spinning the first column after 10 spins, the second after 15, and the last after 20):

```: spin-slots ( a b c n -- a b c )
{
[ spin-delay ]
[ 10 < [ [ spin ] 2dip ] when ]
[ 15 < [ [ spin ]  dip ] when ]
[ drop spin ]
} cleave ;```

Display

Each "spin" of the slot machine will be printed out. Using ANSI escape sequences, we move the cursor to the top left ("0,0") of the screen and then issue a clear screen instruction. Then we print out the current display and flush the output to screen:

```: print-spin ( a b c -- a b c )
"\e[0;0H\e[2J" write
"Welcome to the Factor slot machine!" print nl
"  +--------+" print
"  | CASINO |" print
"  |--------| *" print
3dup "  |%c |%c |%c | |\n" printf
"  |--------|/" print
"  |    [_] |" print
"  +--------+" print flush ;```

Playing

The player will have won if, after all the spins, the "pay line" shows three of the same characters:

```: winner? ( a b c -- )
3array all-equal? nl "You WIN!" "You LOSE!" ? print nl ;```

Playing the slot machine consists of spinning the wheels 20 times, displaying each spin to the user, then checking if the user has won the game.

```: play-slots ( -- )
f f f 20 iota [ spin-slots print-spin ] each winner? ;```

Since our casino wants the user to keep playing, we make it really easy to just hit ENTER to continue:

```: continue? ( -- ? )
"Press ENTER to play again." write flush readln ;```

And, to finish it off, we define a "MAIN" entry point that will be run when the script is executed:

```: main-slots ( -- )
[ play-slots continue? ] loop ;

MAIN: main-slots```

The code for this is on my Github.

Wednesday, December 28, 2011

Elementology

Question: What do the words bamboo, crunchy, finance, genius, and tenacious have in common? I'll give you a hint: its the same thing they have in common with the words who, what, when, where, and how?

Stumped? Well, it's not that these are all English words.

Answer: All of these words can be spelled using elements from the periodic table!

I was recently inspired by the Periodic GeNiUS T-shirt from ThinkGeek and a website that can "make any words out of elements in the periodic table". I thought it would be fun to use Factor to see how many other words can be spelled using the symbols for chemical elements.

First, we need a list of elements:

```: elements ( -- assoc )
H{
{ "H" "Hydrogen" }
{ "He" "Helium" }
{ "Li" "Lithium" }
{ "Be" "Beryllium" }
{ "B" "Boron" }
{ "C" "Carbon" }
...
{ "Uut" "Ununtrium" }
{ "Uup" "Ununpentium" }
{ "Uuh" "Ununhexium" }
{ "Uus" "Ununseptium" }
{ "Uuo" "Ununoctium" }
} [ [ >lower ] dip ] assoc-map ;```

Next, a word that checks if a particular substring is the symbol of an element:

```: element? ( from to word -- ? )
2dup length > [ 3drop f ] [ subseq elements key? ] if ;```

We know that symbols are only ever one, two, or three characters. A word is considered "periodic" if it can be composed of any number of (possibly repeating) element symbols. We build a recursive solution that starts with the first character and continues as long as element symbols are a match or until the end of the word is reached:

```: (periodic?) ( word from -- ? )
{
[ swap length = ]
[
{ 1 2 3 } [
dupd + [ pick element? ] keep
'[ dup _ (periodic?) ] [ f ] if
] with any? nip
]
} 2|| ;

: periodic? ( word -- ? )
>lower 0 (periodic?) ;```

It's easy to get a list of dictionary words from most Unix systems:

```: dict-words ( -- words )
"/usr/share/dict/words" ascii file-lines ;```

And then a list of all "periodic words":

```: periodic-words ( -- words )
dict-words [ periodic? ] filter ;```

So, how many words are "periodic words"? About 13.7% of them.

```IN: scratchpad dict-words length .
235886