Tuesday, 5 March 2013

Sum/Addition Minijava Program

//By Michael Lashley 

//The following program states what the followiing code does for example, it sums all the numbers 
//in an array and returns the overall total. 

//Class is created
class AdditionTestMini
    public static void main(String[] a){ 
System.out.println(((new Sum()).init()).sumAdd());

//class is created for the sum of enteries 
class Sum
    int[] data;
    //below the line of code "getLenght" returns the length of the array (number of elements in the array).
    public int getLength()
        return data.length;

    //this method initials values to specific positions in the array.
    public Sum init()
int index;
        data = new int[5];
        data[0] = 4;
        data[1] = 6;
        data[2] = 8;
        data[3] = 12;
        data[4] = 14;
        return this;               

    //this method calculates/add together the value of all elements in the array stated above.
    public int sumAdd()
        int i;
        int total; 
        int current;
        current = 0;/
        total = 0;
        i = 0;

        //this while loop checks the condition, that the current position in the array is less than the length of the array.
        while (i < (data.length)){
                current = data[i];
                total = total + current;
                i = i + 1;
        return total;    

MiniJava Grammar

This image shows a reconstructed version of the standard mini java grammar which avoids left-recursion and ambiguity. During my Language Processors module I had the pleasure of working with this mini java grammar firstly to write a program using this grammar, secondly to complete write a .jj file which will parse a selected list of mini java programs and lastly to program a type checker and interpreter for the grammar. Compared to standard java mini java should be simpler but having learnt standard java first it was a challenge getting to grips with a this grammar, nonetheless I enjoyed every second of this module...

Friday, 15 February 2013

Functional Programming Code

-- |
-- Module      :  MyAnimation
-- Copyright   :  (c) Michael Lashley 2012
-- License     :  NA
-- Maintainer  :  Michael Lashley
-- Stability   :  experimental
-- Portability :  portable
-- A animation called "The Impossible".
-- This animation is a series of squares which change scale while spining
-- around a central orbit/gravitational pull.
module MyAnimation where
-- Import libraries functions from the Animation .hs file.
import Animation
-- The spin function takes two inputs of type int and returns an animation.
-- This function applies functions from the Animation library to each rect object created by the list in the Picture function.
spin :: Int -> Int -> Animation
spin i j =
  rotate (spinner k)
   (rotate (ever z)
    (translate (ever (-x/2, -x/2))
     (withGenPaint (cycleSmooth (x/10) [c, yellow, lime, purple, cyan, grey, olive]) (cycleSmooth 7 [0.2, 1])
      (rect (cycleSmooth 10 [x/2, 1.5]) (cycleSmooth 5 [6*x, 20])))))

    x = fromIntegral j
    c = hsl (fromIntegral i * 45) 1 0.5
    z = fromIntegral(i `mod` 2) * 45
    k = -10 + 0.5*fromIntegral i
-- The picture function returns and animation.
-- This function calls the Spin function in a list compression with defined variables i and x.
picture :: Animation
picture =

 withPaint (ever black)
   (rect (ever 800) (ever 600)) `plus`

 translate (ever (400, 300))
 (combine [spin i x | i <- [0..16], x <- [350, 150..50]])
-- "test" is a function that writes/creates a .svg file when called.
-- The test.svg file invokes the Picture function there for starting the animation.
test :: IO ()
test = writeFile "test.svg" (svg 800 600 picture)