This post references Project Brownian, of which related posts can be found here.

The next step in creating the first prototype of our ‘Box’ thought experiment was to initially create a certain number of particles within the box.

A function make defined as make :: Int -> Box would be required  to create ‘n number of particles’ and place them in a Box.

The problem we came across was such: “How is it possible to create ‘random’ generated particles”. As many computer scientists are aware, randomness and the quest for creating ‘truly’ random numbers using computers can be complex and tedious as well as bringing up all kinds of philosophical idiocy such as “What really is random and how can something random be defined as random?”. For the sake of our (and now your) sanity I am happily glossing over this.

The System.Random library was used in our initial tests. I was previously unfamiliar with this library and its functions making this stage of the project the hardest to comprehend so far. I researched numerous sources in vain trying to find a solution to creating a list of Coord types that are randomly created.

The source below documents the solution we used in the first prototype:

randPairs :: (RandomGen g, Random a) => (a,a) -> g -> [(a,a)]
randPairs range gen = zip as bs
where (a,b) = split gen -- create two separate generators
as = randomRs range a -- one infinite list of randoms
bs = randomRs range b -- another infinate list

mygen :: StdGen
mygen = mkStdGen seed

make :: Int -> Box
make n = take n $ randPairs (0,100) mygen

The source uses three functions to create a ‘box’:

randPairs creates two lists of infinite random numbers within a specified range and uses the zip function to place them into tuples i.e Coord types – Creating an infinite list of Coord types.

mygen is the ‘Random Generator’ used to produce the random numbers used in randPairs. It uses a seed where seed :: Int. This seed will be discussed in the next blog post in detail.

Finally, make is the function we set out to create. It take in an integer parameter and places that number of ‘random’ particles into a ‘box’ using the Prelude function take.

I have come to realize that this is not an ideal way of creating these particles – This will also be discussed in greater detail in the next blog post.

Until then please feel free to offer advice on how I could optimize.

Yours technologically,

Ed

Posted in Haskell, Programming, Project Brownian | 2 Comments

This post references Project Brownian, of which related posts can be found here.

Initially the problem of creating a functionally programmed implementation of a Brownian Motion environment seemed very daunting. As an undergraduate freshman, the task of creating something so complex in a language I am only newly familiar with will be tough but also extremely beneficial as a learning aide.

The first step of any program is to identify the key goals and ideas you want the program to contain and put across.

We decided  that to start of simple we would create some prototype ideas and concepts.

Initially we came up with the idea of ‘particles’ in an enclosed space. A two-dimensional thought experiment in which a number of random particles are placed in locations within a box and interact with each other.

The box takes the form of a Cartesian co-ordinate grid with only positive integers representing the x and y axises (the first quadrant). The box is of a finite size that is defined at compile time as a constant (I believe we initially had this set at 100 – giving  10,000 unique positions for a particle to be – a relationship)

The initial source code was as follows:
-- Brownean Motion Haskell Test
-- Created & Developed by Ed George
-- With Assistance from Sam Davidson

type Coord = (Int, Int)
type Box = [Coord]

maxN :: Int
maxN = 100

empty :: Box
empty = []

incx :: Int -> Coord -> Coord
incx n (a,b) = ((a+n),b)

incy :: Int -> Coord -> Coord
incy n (a,b) = (a,(b+n))

add :: Int -> Int -> Box -> Box
add x y ts = (x,y) : ts

The first couple of lines describe the two data types used within the initial program. Coord is the type that represents a particle and takes the form of a tuple of integers. The Box represents the metaphorical enclosed areas that contain the particles. It therefore takes the form of a list of ‘particles’ – Coord elements.

maxn and empty are two definitions that are to be used within later prototypes. (Where maxn is the maximum size of the box. In this example the upper right boundary begins at (100,100))

incx and incy are two helper functions written to add an integer amount to a particle’s x or y co-ordinate.

Finally add is a function to create particles and add them to a ‘box’. It takes in the parameters of a x and y coordinate for the particle to be added as well as the list of previous particles the new particle should be added too (the ‘box’).

Currently this program contains some of the key building blocks required to create a working prototype. Plenty more functions are to be added soon.

Yours technologically,

Ed

Posted in Haskell, Programming, Project Brownian | Leave a comment

Many of you will be familiar with the concept of Brownean Motion. This is the is the “assumably random movement of particles suspended in a fluid (a liquid or a gas)” (Wikipedia) that occurs naturally. The maths behind this branch of particle theory can be used in a variety of ways. To describe randomness or even describe changes in stocks and shares.

I took up a project recently along side my good friend Sam Davidson - (blog) to attempt to create a functional programming language implementation of a similar system to that described by the motion observed in these suspended particles.

Haskell was our chosen language to begin the project. This blog will continue to follow the progress of the project step by step, documenting key areas of interest and problems that occurred along the way.

Unfortunately, WordPress and its built in source code highlighter does NOT yet support the Haskell language. Any code that appears in the format below is, from here on, to be read as Haskell source code.
--Example.hs
--Ed George 2011

add :: Num a => a -> a -> a
add x y = x + y

(A simple addition function.)

Yours technologically,

Ed

Posted in Haskell, Programming, Project Brownian | Leave a comment