On Sunday, I thought I’d try and show my son the fun side of programming and Logo seemed a good place to start. Using a Logo Interpreter written in JavaScript, in seconds we were drawing pentagons.
to pentagon repeat 5 [ fd 100 rt 72 ] end
That jogged my memory to a cool sample Logo Interpreter written by Adam Granicz in less than 400 lines, posted on HubFS back in 2006. The code didn’t run straight away due to some subtle changes in the language, but after some worthwhile coercion I was able to resurrect the code, which I have attached.
Try executing:
canvas 300 300
to pentagon :x repeat 5 [ fd :x rt 72 ]
pentagon 100
and:
canvas 400 500
spiral :x repeat :x [fd 4 lt * repcount 1.1]
spiral 10000
Logo.fsx (19.71 kb)
Least Common Multiple on Wikipedia.
How well can the prime factorization method be expressed in F#? This is my first solution and just for fun:
open System
/// Generate sequence of all integer primes
let primes =
let isPrime x =
let rec test = function
| 1 -> true
| n -> if x % n = 0 then false else test (n-1)
test (x/2)
seq {
yield! [1;2;3;5;7]
for n in 11..2..Int32.MaxValue do
if isPrime n then yield n
done
}
/// Compute prime factors
/// <returns>
/// Sequence of prime number powers (x^y) as tuple of (x,y)
/// </returns>
let primefactors x =
/// Compute prime factor
let primefactor x =
primes
|> Seq.skip 1
|> Seq.takeWhile (fun prime -> prime <= x)
|> Seq.tryFind (fun prime -> (x % prime) = 0)
/// Compute list of prime factors
let rec fold acc x =
match primefactor x with
| Some factor -> fold (factor::acc) (x/factor)
| None -> acc
fold [] x
|> Seq.countBy (fun x -> x)
/// Compute lowest common multiple
let lcm xs =
xs // {8;9;21}
|> Seq.map primefactors // {{2^3};{3^2};{3^1;7^1}}
|> Seq.concat // {2^3;3^2;3^1;7^1}
|> Seq.groupBy (fun (x,y) -> x) // {{2;{2^3}};{3;{3^1;3^2}};{7;{7^1}}}
|> Seq.map (fun (x,xys) ->
x, // 3
xys // {3^1;3^2}
|> Seq.map snd // {1;2}
|> Seq.max // 2
) // {2^3;3^2;7^1}
|> Seq.map (fun (x,y) ->
pown x y // {8;9;7}
)
|> Seq.reduce (*) // 504
do lcm [8;9;21] |> printf "%d" // yields 504
The Open Source eXchange III was a mini-conference where members of the ALT.NET community talked about their favourite alternative .NET tools that increase programmer productivity. Units of Measure is a cool language feature in F#, developed by Andrew Kennedy, that lets you easily annotate values with units like metres, kilograms or seconds. Then F# type inference kicks in to give you automatic checking of your unit types at design and compile time, but cost you nothing at run time, e.g.
let gravityOnEarth = 9.8f<m/s^2> // Acceleration
Following a bit of a Apollo 40th Anniversary theme, I presented 3 code samples (attached):
-
Statistics
-
Orbital Mechanics
-
Lunar Lander
Resources:
Further reading: