So for my first bit of fun with F# I figured it'd be fun to play with the BigNum (used for crazy big numbers) I figured I write up some quick functions that simple generate the power of some number, resulting in some crazy big numbers :)
(*all of my examples include '#light')
My first function doesn't use the BigNum but it's very simplistic.
let rec pwrof x y =
if y = 1 then
x
else
x * pwrof x (y - 1)
So for everyone new to F# 'pwrof' is a recursive function that takes 2 ints. 'rec' lets the compiler know that the function is recursive and the 2 parameters get resolved down to being ints at compile time. This came pretty naturally for me coming from a C# world, so lets try to mix it up a bit.
let rec pwrof x y =
match y with
| 1 -> x
| _ -> x * pwrof x (y - 1)
This function does the exact same thing, but instead of using a familiar if/else statement we're using pattern matching (these are widely used in F#). It's like a switch statement. If y matches 1 then we return x, otherwise if y matches anything else, '_', then we recurse.
These were kinda fun, but I wanted to calculate crazy big power of calculations like 5000^5000. So here's an example that resembles my first function
let bpwrof x y =
let x = Microsoft.FSharp.Math.BigNum.of_int x
let pwr = x
let rec pwrof x y =
if y = 1 then
x
else
pwrof (x * pwr) (y - 1)
pwrof x y
And here's an example that resembles my second function
let bpwrof x y =
let x = Microsoft.FSharp.Math.BigNum.of_int x
let pwr = x
let rec pwrof x y =
match y with
| 1 -> x
| _ -> pwrof (x * pwr) (y - 1)
pwrof x y
These are tail recursive so you can create some really, REALLY big numbers. If you call one of the last 2 functions you can calculate say 5000 to the 9000th power. It ends up taking a lot more time to print the result to the screen than it does to do the calculation(its pages and pages of number madness). I even tried 5000 to the 90,000th pwr, that's a big number.
Oh well, that's all for now...
