It is easy to install the mode for ubuntu 9.10 (karmic). First install the emacs with

sudo apt-get install emacs23

After that copy the the two .el files from you google ~/go/misc/emacs directory to

/usr/share/emacs/23.1/lisp

Now create a .emacs file in you home directory and add the following to lines.

(add-to-list ‘load-path “/usr/share/emacs/23.1/lisp” t)
(require ‘go-mode-load)

Now the google mode is activated after loading a .go file.

More about this nice project Link

package main

import ( "image";
        "image/png";
	"bufio";
	"fmt";
	"os";
	"math";
	"time"; )

type PixelCalc struct {  x int;
     	                 y int;
                         cx float64;
	                 cy float64; }

func PointIteration(in chan *PixelCalc,ready chan int,img *image.RGBA){

	for {
		pixelCalc :=  <- in; 

		xt := float64(0);
		yt := float64(0);
		x := float64(0);
		y := float64(0);
		quadValue := float64(0);
		iter := 0;

		for quadValue <= 255.0 && iter < 255 {
			xt= ( x * x ) - ( y * y) + pixelCalc.cx;
			yt= ( float64(2.0) * x * y ) + pixelCalc.cy;
			x = xt;
			y = yt;
			iter++;

			quadValue = ( x * x ) + ( y * y );
		}

		color := new(image.NRGBAColor);
		color.A = 255;
		iter8 := uint8(iter);
		color.R = iter8;
		color.G = iter8;
		color.B = iter8;
		img.Set(pixelCalc.x,pixelCalc.y,color);

		ready <- 1;
	}
}

func main(){
	start := time.Seconds();

	const pictureSize = 1000;

	img := image.NewRGBA(pictureSize,pictureSize);

	f, err := os.Open("mandel.png", os.O_WRONLY|os.O_CREAT, 0666);
	if err != nil {
		fmt.Printf("Can't create picture file\n");
	}

	calc := make(chan *PixelCalc,pictureSize*pictureSize);
	out := make(chan int,pictureSize*pictureSize);

	for i:=0;i<4;i++{
		go PointIteration(calc,out,img);
	}

	deltaX := math.Fabs(float64(-2.0 - 1.0)) / float64(pictureSize);
        deltaY := math.Fabs(float64(-1.0 - 1.0)) / float64(pictureSize);

	cx := float64(-2.0);

	for x:=0;x<pictureSize;x++{
		cx+=deltaX;
		cy := float64(-1.0);

		for y:=0;y<pictureSize;y++{
	    		cy+=deltaY;
			pixelCalc := new(PixelCalc);
			pixelCalc.cx = cx;
			pixelCalc.cy = cy;
			pixelCalc.x  = x;
			pixelCalc.y  = y;

			calc <- pixelCalc;
		}
	}	

	for i:=0;i<pictureSize*pictureSize;i++{
		<- out;
	}

  	w := bufio.NewWriter(f);
	png.Encode(w,img);
	w.Flush();

	fmt.Printf("Seconds needed %d\n",time.Seconds() - start);
}

At this time the go compiler has some bugs regarding the multiprocessor support. But sometimes I can see the use of my two processors.

I hope there will fix that bug fast. The first workaround for that bug is the GOMAXPROCS environment variable. I set this to 2. But this did’nt help everytime.

Link to part 1

package main

import (   "image";
           "image/png";
           "bufio";
	   "fmt";
	   "os";
           "math";
           "time"; )

func PointIteration( cx, cy, maxValue float64, maxIter uint8) uint8{
     quadValue := float64(0.0);
     iter := uint8(0);
     x := float64(0.0);
     y := float64(0.0);

    for quadValue <= maxValue && iter < maxIter {
        xt:= ( x * x ) - ( y * y) + cx;
        yt:= ( float64(2.0) * x * y ) + cy;
        x = xt;
        y = yt;
        iter++;
        quadValue = ( x * x ) + ( y * y );
    }
    return iter;
}

func main(){
    start := time.Seconds();     

    const pictureSize = 500;
    img := image.NewRGBA(pictureSize,pictureSize);

    f, err := os.Open("mandel.png", os.O_WRONLY|os.O_CREAT, 0666);
    if err != nil {
       fmt.Printf("Can't create picture file\n");
    }

    deltaX := math.Fabs(float64(-2.0 - 1.0)) / float64(pictureSize);
    deltaY := math.Fabs(float64(-1.0 - 1.0)) / float64(pictureSize);

    cx := float64(-2.0);
    for x:=0;x<pictureSize;x++{
        cx+=deltaX;
        cy := float64(-1.0);
        for y:=0;y<pictureSize;y++{
           cy+=deltaY;
           iter := PointIteration(cx,cy,255.0,255);

           color := new(image.NRGBAColor);
           color.A = 255;
           color.R = iter;
           color.G = iter;
           color.B = iter;
           img.Set(x,y,color);
	}
     }

     w := bufio.NewWriter(f);
     png.Encode(w,img);
     w.Flush();

     fmt.Printf("Seconds needed %d\n",time.Seconds() - start);
}

And here the result.

Next step is trying to improve the speed by using goroutines and channels.

No Comments needed Link

A short presentation from Matt at a the Oreilly Ignite. Funny and cool…

Click to play

I need a hug..

Ohh yeah. Mormons driving me crazy. Watch the stupid story of the formation.

list = []
for i in range(10000):
   rand = random.randint(0,50000)
   if not rand in list:
      list.append(rand)

Now we have a list with up to 10000 random and unique entries. Very easy to program, but you also see the performance problem. In line 4 is a check for the uniqueness of the possible new entry. To check for existence of an element in a list, the framework runs through all elements of the list. That is a sequential search, the slowest searching algorithm in this universe. This small example needs 365360 microseconds on my machine.

Now lets try a different version with a dictionary.

dict = {}
for i in range(10000):
   rand = random.randint(0,50000)
   if not dict.has_key(rand):
      dict[rand] = 0

This example needs only 34908 microseconds. That is 10 times faster than the version with the list. It looks very stupid to program a line like “dict[rand] = 0�?, but this solution now uses a different search algorithm. If you increment the loop up to 20000 entries the different is 83times. But in the near of 30000 it comes to a point where the insort algorithm of the dict structure needs so long that the speed benefit is over.

I wrote another small program to visualize the effect.
See the code

I found this problem in a small textminig project. Using dictionarys to search for existence of a word in an document was extremely faster than a list. So sometimes you should think about, when to use a list and when use a dictionary like an list.