Home | Fractal Benchmark

Fractal Benchmark Programs

C GCC 4.3.2

// by Erik Wrenholt
#include <stdio.h>
#include <sys/time.h>

#define BAILOUT 16
#define MAX_ITERATIONS 1000

int mandelbrot(double x, double y)
{
        double cr = y - 0.5;
        double ci = x;
        double zi = 0.0;
        double zr = 0.0;
        int i = 0;

        while(1) {
                i ++;
                double temp = zr * zi;
                double zr2 = zr * zr;
                double zi2 = zi * zi;
                zr = zr2 - zi2 + cr;
                zi = temp + temp + ci;
                if (zi2 + zr2 > BAILOUT)
                        return i;
                if (i > MAX_ITERATIONS)
                        return 0;
        }
        
}

int main (int argc, const char * argv[]) {
        struct timeval aTv;
        gettimeofday(&aTv, NULL);
        long init_time = aTv.tv_sec;
        long init_usec = aTv.tv_usec;

        int x,y;
        for (y = -39; y < 39; y++) {
                printf("\n");
                for (x = -39; x < 39; x++) {
                        int i = mandelbrot(x/40.0, y/40.0);
                        if (i==0)
                                printf("*");
                        else
                                printf(" ");
                }       
        }
        printf ("\n");
        
        gettimeofday(&aTv,NULL);
        double query_time = (aTv.tv_sec - init_time) + (double)(aTv.tv_usec - init_usec)/1000000.0;     
        printf ("C Elapsed %0.2f\n", query_time);
    return 0;
}

Java

// by Erik Wrenholt, altered to double float arithmetic by Theo Wollenleben
import java.util.*;

class Mandelbrot
{  
        static int BAILOUT = 16;
        static int MAX_ITERATIONS = 1000;
        
        private static int iterate(double x, double y)
        {
                double cr = y-0.5f;
                double ci = x;
                double zi = 0.0f;
                double zr = 0.0f;
                int i = 0;
                while (true) {
                        i++;
                        double temp = zr * zi;
                        double zr2 = zr * zr;
                        double zi2 = zi * zi;
                        zr = zr2 - zi2 + cr;
                        zi = temp + temp + ci;
                        if (zi2 + zr2 > BAILOUT)
                                return i;
                        if (i > MAX_ITERATIONS)
                                return 0;
                }
        }

        public static void main(String args[])
        {
                Date d1 = new Date();
                int x,y;
                for (y = -39; y < 39; y++) {
                        System.out.print("\n");
                        for (x = -39; x < 39; x++) {
                                if (iterate(x/40.0f,y/40.0f) == 0) 
                                        System.out.print("*");
                                else
                                        System.out.print(" ");

                        }
                }
                Date d2 = new Date();
                long diff = d2.getTime() - d1.getTime();
                System.out.println("\nJava Elapsed " + diff/1000.0f);
                
        }
}

Lua 5.1.4

#!/usr/bin/lua

-- By Erik Wrenholt

local BAILOUT = 16
local MAX_ITERATIONS = 1000

function iterate(x,y)

        local cr = y-0.5
        local ci = x
        local zi = 0.0
        local zr = 0.0
        local i = 0
        
        while 1 do
                i = i+1
                local temp = zr * zi
                local zr2 = zr*zr
                local zi2 = zi*zi
                zr = zr2-zi2+cr
                zi = temp+temp+ci
                if (zi2+zr2 > BAILOUT) then
                        return i
                end
                
                if (i > MAX_ITERATIONS) then
                        return 0
                end
        end

end

function mandelbrot()
        local t = os.time()
        for y = -39, 38 do
                for x = -39, 38 do
                        if (iterate(x/40.0, y/40) == 0) then
                                io.write("*")
                        else
                                io.write(" ")
                        end
                end
                io.write("\n")
        end
        io.write(string.format("Time Elapsed %d\n", os.time() - t))
end

mandelbrot()

Objective Caml 3.10.2

(*#!/opt/local/bin/ocamlrun ocaml unix.cma*)
(* Linux doesn't split the arguments in the shebang line.
   Alternatives (times don't differ):
    ocaml unix.cma Mandelbrot.ml
    ocamlrun ocaml unix.cma Mandelbrot.ml
    ocamlc unix.cma Mandelbrot.ml -o Mandelbrot; ./Mandelbrot
   Compiled:
    ocamlopt unix.cmxa Mandelbrot.ml -o Mandelbrot; ./Mandelbrot *)
(* Courtesy of pango on #ocaml *)

let bailout = 16.
let max_iterations = 1000

let mandelbrot x y =
  let cr = y -. 0.5 in
  let ci = x in
  let zi = ref 0.0 in
  let zr = ref 0.0 in
  let i = ref 0 in
  let continue = ref true in
  let result = ref 0 in
  while !continue do
    incr i;
    let temp = !zr *. !zi in
    let zr2 = !zr *. !zr in
    let zi2 = !zi *. !zi in
    zr := zr2 -. zi2 +. cr;
    zi := temp +. temp +. ci;
    if zi2 +. zr2 > bailout then begin
      result := !i;
      continue := false;
    end
    else if !i > max_iterations then
      continue := false;
  done;
  !result

let () =
  let start_time = Unix.gettimeofday () in
  for y = -39 to 38 do
    print_newline ();
    for x = -39 to 38 do
      let i = mandelbrot (float x /. 40.) (float y /. 40.) in
      print_char (if i = 0 then '*' else ' ');
    done
  done;
  print_newline ();
  let stop_time = Unix.gettimeofday () in
  let query_time = stop_time -. start_time in
  Printf.printf "OCaml Elapsed %0.2f\n" query_time

Python 2.6.0

#!/usr/bin/python
# by Daniel Rosengren

import sys, time
stdout = sys.stdout

BAILOUT = 16
MAX_ITERATIONS = 1000

class Iterator:
  def __init__(self):
    print 'Rendering...'
    for y in range(-39, 39):
      stdout.write('\n')
      for x in range(-39, 39):
        i = self.mandelbrot(x/40.0, y/40.0)
        
        if i == 0:
          stdout.write('*')
        else:
          stdout.write(' ')
    
  def mandelbrot(self, x, y):
    cr = y - 0.5
    ci = x
    zi = 0.0
    zr = 0.0
    i = 0

    while True:
      i += 1
      temp = zr * zi
      zr2 = zr * zr
      zi2 = zi * zi
      zr = zr2 - zi2 + cr
      zi = temp + temp + ci
                  
      if zi2 + zr2 > BAILOUT:
        return i
      if i > MAX_ITERATIONS:
        return 0

t = time.time()
Iterator()
print '\nPython Elapsed %.02f' % (time.time() - t)

PostScript Ghostscript 8.62

%!PS
%% frac.ps by Jeff Zaroyko
%% a transliteration of the program by Erik Wrenholt
%% at http://www.timestretch.com/FractalBenchmark.html
/star {(*) print } bind def
/space { ( ) print } bind def
realtime pop

/BAILOUT 16 def
/MAX_ITERATIONS 1000 def

/mandelbrot { %% mx my
    /mx exch def
    /my exch def

    /cr my 0.5 sub def
    /ci mx def
    /zi 0.0 def
    /zr 0.0 def
    /i 0 def

    {
     /i i 1 add def
     /temp zr zi mul def
     /zr2 zr zr mul def
     /zi2 zi zi mul def
     /zr zr2 zi2 sub cr add def
     /zi temp temp add ci add def
     zi2 zr2 add BAILOUT gt
         {
             i exit 
         } if
     i MAX_ITERATIONS gt
         {
             0 exit 
         } if
    } loop
} bind def

% main

/y -39 def
{
    y 39 lt
    {
        /y y 1 add def
        (\n) print 

        /x -39 def
        {
            x 39 lt
            {
                /x x 1 add def
                y 40.0 div x 40.0 div mandelbrot
                0 eq { star  } { space  } ifelse
            } { exit } ifelse
        } loop
    } { exit }ifelse  % Done.
} loop

realtime dup log ceiling cvi string cvs
(\nTotal time Elapsed ) print print (ms\n) print
quit

Perl 5.10.0 optimized

#!/usr/bin/perl
# Ported from C to Perl by Anders Bergh <anders1@gmail.com>
# Some Perlification by John Gabriele (4-24-2007).

use strict;
use warnings;
use Time::HiRes qw( gettimeofday );

my $BAILOUT = 16;
my $MAX_ITERATIONS = 1000;
my $begin = gettimeofday();

sub mandelbrot {
    my ( $x, $y ) = @_;

    my $cr = $y - 0.5;
    my $ci = $x;
    my ( $zi, $zr ) = ( 0.0, 0.0 );
    my $i = 0;

    my ( $temp, $zr2, $zi2 );
    while ( 1 ) {
        $i += 1;
        $temp = $zr * $zi;
        $zr2  = $zr * $zr;
        $zi2  = $zi * $zi;
        $zr = $zr2 - $zi2 + $cr;
        $zi = $temp + $temp + $ci;
        if ( $zi2 + $zr2 > $BAILOUT ) {
            return $i;
        }
        if ( $i > $MAX_ITERATIONS ) {
            return 0;
        }
    }
}

for ( my $y = -39; $y < 39; $y++ ) {
    print( "\n" );
    my $i;
    for ( my $x = -39; $x < 39; $x++ ) {
        $i = mandelbrot( $x / 40.0, $y / 40.0 );
        if ( $i == 0 ) {
            print q{*};
        }
        else {
            print q{ };
        }
    }
}

print "\n";
my $end = gettimeofday() - $begin;
print "Perl Elapsed $end\n";

Perl 5.10.0

#!/usr/bin/perl
# Ported from C to Perl by Anders Bergh <anders1@gmail.com>
#

$BAILOUT=16;
$MAX_ITERATIONS=1000;

$begin = time();

sub mandelbrot {
       local $x = $_[0];
       local $y = $_[1];

       local $cr = $y - 0.5;
       local $ci = $x;
       local $zi = 0.0;
       local $zr = 0.0;
       local $i = 0;

       while (1)
       {
               $i = $i + 1;
               local $temp = $zr * $zi;
               local $zr2 = $zr * $zr;
               local $zi2 = $zi * $zi;
               $zr = $zr2 - $zi2 + $cr;
               $zi = $temp + $temp + $ci;
               if ($zi2 + $zr2 > $BAILOUT)
               {
                       return $i;
               }
               if ($i > $MAX_ITERATIONS)
               {
                       return 0;
               }
       }
}

for ($y = -39; $y < 39; $y++)
{
       print("\n");
       for ($x = -39; $x < 39; $x++)
       {
               $i = mandelbrot($x/40.0, $y/40.0);
               if ($i == 0)
               {
                       print("*");
               }
               else
               {
                       print(" ");
               }
       }
}
print("\n");

$end = time() - $begin;

print "Perl Elapsed $end\n";

PHP 5.2.9

#!/usr/bin/php5
<?php
define("BAILOUT",16);
define("MAX_ITERATIONS",1000);

class Mandelbrot
{
        

        function Mandelbrot()
        {
                $d1 = microtime(1);
                for ($y = -39; $y < 39; $y++) {
                        echo("\n");
                        for ($x = -39; $x < 39; $x++) {
                                if ($this->iterate($x/40.0,$y/40.0) == 0) 
                                        echo("*");
                                else
                                        echo(" ");

                        }
                }
                $d2 = microtime(1);
                $diff = $d2 - $d1;
                printf("\nPHP Elapsed %0.2f", $diff);
        }

        function iterate($x,$y)
        {
                $cr = $y-0.5;
                $ci = $x;
                $zi = 0.0;
                $zr = 0.0;
                $i = 0;
                while (true) {
                        $i++;
                        $temp = $zr * $zi;
                        $zr2 = $zr * $zr;
                        $zi2 = $zi * $zi;
                        $zr = $zr2 - $zi2 + $cr;
                        $zi = $temp + $temp + $ci;
                        if ($zi2 + $zr2 > BAILOUT)
                                return $i;
                        if ($i > MAX_ITERATIONS)
                                return 0;
                }
        
        }


}

$m = new Mandelbrot();
?>

Ruby 1.8.7

#!/usr/bin/ruby

BAILOUT = 16
MAX_ITERATIONS = 1000

class Mandelbrot
        
        def initialize
                puts "Rendering"
                for y in -39...39 do
                        puts
                        for x in -39...39 do
                                i = iterate(x/40.0,y/40.0)
                                if (i == 0)
                                        print "*"
                                else
                                        print " "
                                end
                        end
                end
        end

        def iterate(x,y)
                cr = y-0.5
                ci = x
                zi = 0.0
                zr = 0.0
                i = 0
                
                while(1)
                        i += 1
                        temp = zr * zi
                        zr2 = zr * zr
                        zi2 = zi * zi
                        zr = zr2 - zi2 + cr
                        zi = temp + temp + ci
                        return i if (zi2 + zr2 > BAILOUT)
                        return 0 if (i > MAX_ITERATIONS)
                end
        
        end

end

time = Time.now
Mandelbrot.new
puts
puts "Ruby Elapsed %f" % (Time.now - time)

JavaScript SpiderMonkey 1.7.0

#!/usr/bin/js
/* Javascript version by Patrick Haller.*/

function mandelbrot(x, y) {
        var cr = y - 0.5;
        var ci = x;
        var zi = 0.0;
        var zr = 0.0;
        var i = 0;
        var BAILOUT = 16;
        var MAX_ITERATIONS = 1000;

        while(1) {
                i++;
                var temp = zr * zi;
                var zr2 = zr * zr;
                var zi2 = zi * zi;
                zr = zr2 - zi2 + cr;
                zi = temp + temp + ci;
                if (zi2 + zr2 > BAILOUT) {
                        return i;
                }
                if (i > MAX_ITERATIONS) {
                        return 0;
                }
        }
}

function mandelbrot_run() {
        var x; var y;
        output = "";
        
        var date = new Date();
        for (y = -39; y < 39; y++) {
                print(output);
                output = "";
                for (x = -39; x < 39; x++) {
                        var i = mandelbrot(x/40.0, y/40.0);
                        if (i==0) {
                                output += "*";
                        }
                        else {
                                output += " ";
                        }
                }       
        }
        var date2 = new Date();
        output += "\nJavaScript Elapsed " + (date2.getTime() - date.getTime()) / 1000;
        print(output);
        return false;
}

mandelbrot_run();

Tcl 8.5.5

#!/usr/bin/tclsh

# Optimized Version by Samuel Zafrany

# Ported from C by Anders Bergh <anders1@gmail.com>
package require Tcl 8.4

set BAILOUT 16
set MAX_ITERATIONS 1000

proc mandelbrot {x y} {
       global BAILOUT
       global MAX_ITERATIONS

       set cr [expr {$y - 0.5}]
       set ci $x
       set zi 0.0
       set zr 0.0
       set i 0

       while {1} {
               incr i
               set temp [expr {$zr * $zi}]
               set zr2 [expr {$zr * $zr}]
               set zi2 [expr {$zi * $zi}]
               set zr [expr {$zr2 - $zi2 + $cr}]
               set zi [expr {$temp + $temp + $ci}]

               if {$zi2 + $zr2 > $BAILOUT} {
                       return $i
               }

               if {$i > $MAX_ITERATIONS} {
                       return 0
               }
       }
}

set begin [clock clicks -milliseconds]

for {set y -39} {$y < 39} {incr y} {
       puts ""
       for {set x -39} {$x < 39} {incr x} {
               set i [mandelbrot [expr {$x / 40.0}] [expr {$y / 40.0}]]

               if {$i == 0} {
                       puts -nonewline "*"
               } else {
                       puts -nonewline " "
               }
               flush stdout
       }
}
puts ""

set diff [expr [clock clicks -milliseconds] - $begin]
#puts "Tcl Elapsed [expr int($diff / 1000)] seconds ($diff ms)"
puts "Tcl Elapsed [expr int($diff / 1000)]"

Emacs 22.3 Lisp

; By Erik Wrenholt
; emacs -l Mandelbrot.lisp -batch

(defun iterate (xx yy)
        
        (let* 
        (
                (BAILOUT 16.0)
                (MAX_ITERATIONS 1000)
                (bail_val 0)
                (cr (- yy 0.5))
                (ci xx)
                (zi 0.0)
                (zr 0.0)
                (i 0)
        )
        (while (and (< i MAX_ITERATIONS) (< bail_val BAILOUT))
                (setq i (+ 1 i))
                (setq temp (* zr zi))
                (setq zr2 (* zr zr))
                (setq zi2 (* zi zi))
                (setq zr (+ (- zr2 zi2) cr))
                (setq zi (+ temp temp ci))
                
                (setq bail_val (+ zi2 zr2)))
        i)
)

(defun mandelbrot()
(setq yy -39)
(while (< yy 39)
  (setq yy (+ 1 yy))

  (setq xx -39)
  (while (< xx 39)
    (setq xx (+ 1 xx))
    
    (if (= (iterate (/ xx 40.0) (/ yy 40.0)) 1000)
                (princ  "*")
                (princ  " ")
   )
)
(princ  "\n")
))
(setq the-time (cadr (current-time)))
(mandelbrot)
(princ (format "Elapsed %d" (- (cadr (current-time)) the-time)))

Io 20080330

#!/usr/bin/io
# by Erik Wrenholt

iterator := Object clone do (

bailout := 16
max_iterations := 1000

mandelbrot := method (x,y,
        cr := y - 0.5
        ci := x
        zi := 0.0
        zr := 0.0
        i := 0
        
        while (1,
                i = i + 1
                temp := zr * zi
                zr2 := zr * zr
                zi2 := zi * zi
                zr := zr2 - zi2 + cr
                zi := temp + temp +ci

                if (zi2 + zr2 > bailout,
                        return i)
                if (i > max_iterations,
                        return 0)
        )
)

print_set := method (
        writeln("Rendering...") 
        for(y, -39, 38,
                write("\n")
                for(x, -39, 38,
                        i := mandelbrot(x/40.0,y/40.0)
                        if (i == 0, write("*"),write(" "))
                )
        )
)
)

writeln
writeln ("Io Elapsed " .. Date secondsToRun(iterator print_set))

Common Lisp CMUCL 19f

; sbcl lisp version by mandeep singh, altered to double float arithmetic by Theo Wollenleben

(declaim (optimize (speed 3)))

(defconstant +BAILOUT+ 16)
(defconstant +MAX-ITERATIONS+ 1000)

(defun mandelbrot (x y)
  (declare (type double-float x y))
  (let ((cr (- y 0.5))
        (ci x)
        (zi 0d0)
        (zr 0d0))
    (declare (type double-float cr ci zi zr))
    (do ((i 0 (incf i)))
        (nil)
      (let* ((temp (the double-float (* zr zi)))
             (zr2 (the double-float (* zr zr)))
             (zi2 (the double-float (* zi zi))))
        (declare (type double-float temp zr2 zi2)
                 (type fixnum i))
        (setq zr (the double-float (+ (- zr2 zi2) cr)))
        (setq zi (the double-float (+ temp temp ci)))
        (if (> (the double-float (+ zi2 zr2)) +BAILOUT+)
            (return-from mandelbrot i))
        (if (> i +MAX-ITERATIONS+)
            (return-from mandelbrot 0))))))
 
(defun main ()
   (let ((tstart) 
        (tfinish))
     (setq tstart (get-internal-real-time))
     (do ((y -39 (incf y)))
         ((= (the fixnum y) 39))
       (format t "~%")
       (do ((x -39 (incf x)))
           ((= (the fixnum x) 39))
         (let ((i (mandelbrot (the double-float (/ x 40d0))
                              (the double-float (/ y 40d0)))))
           (declare (type fixnum i x y))
        (if (zerop i)
            (format t "*")
            (format t " ")))))
     (format t "~%")
     (setq tfinish (get-internal-real-time))
     (format t "SBCL Elapsed ~,2F~%" (coerce (/ (- tfinish tstart) internal-time-units-per-second) 'float))))

(progn 
 (main)
 (quit))

GNU AWK 3.1.6

#!/bin/gawk -f
# by Erik Wrenholt, ported from C to GNU AWK 3.1.6 by Theo Wollenleben

function mandelbrot(x, y)
{
  cr = y - 0.5
  ci = x
  zi = 0.0
  zr = 0.0
  i = 0
  
  while(1) {
    i ++
    temp = zr * zi
    zr2 = zr * zr
    zi2 = zi * zi
    zr = zr2 - zi2 + cr
    zi = temp + temp + ci
    if (zi2 + zr2 > BAILOUT)
      return i
    if (i > MAX_ITERATIONS)
      return 0
  }
  
}

BEGIN {
  BAILOUT = 16
  MAX_ITERATIONS = 1000
  
  init_time=systime()
  
  for (y = -39; y < 39; y++) {
    printf("\n")
    for (x = -39; x < 39; x++) {
      i = mandelbrot(x/40.0, y/40.0)
      if (i==0)
        printf("*")
      else
        printf(" ")
    }
  }
  printf("\n")
  
  query_time = systime() - init_time
  printf("GAWK Elapsed %d\n", query_time)
  exit
}

GNU bc 1.06

#!/usr/bin/bc -ql
# BC_LINE_LENGTH=80 ./Mandelbrot.bc
# by Erik Wrenholt, ported from C to GNU bc 1.06 by Theo Wollenleben
# bc has no time functions

scale=16

bailout = 16
max_iterations = 1000

define mandelbrot(x, y) {
  
  cr = y - 0.5
  ci = x
  zi = 0.0
  zr = 0.0
  i = 0
  
  while(1) {
    i = i + 1
    temp = zr * zi
    zr2 = zr * zr
    zi2 = zi * zi
    zr = zr2 - zi2 + cr
    zi = temp + temp + ci
    if (zi2 + zr2 > bailout)
      return (i)
    if (i > max_iterations)
      return (0)
  }
  
}

for (y = -39; y < 39; y++) {
  print "\n"
  for (x = -39; x < 39; x++) {
    i = mandelbrot(x/40.0, y/40.0)
    if (i==0)
      print "*" else
      print " "
  }
}
print "\n"

quit

XSLT libxslt 1.1.24

<?xml version="1.0" encoding="utf-8"?>
<!-- echo '<x/>'|xsltproc Mandelbrot.xslt - -->
<!-- by Erik Wrenholt, ported from C to XSLT by Theo Wollenleben -->
<!-- no time functions in XSLT -->
<!-- there is a 'timing' option for xsltproc, see also http://exslt.org/date/ -->
<!-- no output until xsltproc has finished -->
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:output omit-xml-declaration="yes" indent="no"/>

 <xsl:variable name="BAILOUT" select="16"/>
 <xsl:variable name="MAX_ITERATIONS" select="1000"/>

 <xsl:template name="while">
  <xsl:param name="i"/>
  <xsl:param name="temp"/>
  <xsl:param name="zr2"/>
  <xsl:param name="zi2"/>
  <xsl:param name="cr"/>
  <xsl:param name="ci"/>
  <xsl:if test="$zi2 + $zr2 &lt;= $BAILOUT and $i &lt;= $MAX_ITERATIONS">
   <xsl:call-template name="mandelbrot">
    <xsl:with-param name="cr" select="$cr"/>
    <xsl:with-param name="ci" select="$ci"/>
    <xsl:with-param name="zr" select="$zr2 - $zi2 + $cr"/>
    <xsl:with-param name="zi" select="$temp + $temp + $ci"/>
    <xsl:with-param name="i" select="$i"/>
   </xsl:call-template>
  </xsl:if>
  <xsl:if test="$zi2 + $zr2 > $BAILOUT">
   <xsl:text> </xsl:text>
  </xsl:if>
  <xsl:if test="$i > $MAX_ITERATIONS">
   <xsl:text>*</xsl:text>
  </xsl:if>
 </xsl:template>

 <xsl:template name="mandelbrot">
  <xsl:param name="cr"/>
  <xsl:param name="ci"/>
  <xsl:param name="zr"/>
  <xsl:param name="zi"/>
  <xsl:param name="i"/>
   <xsl:call-template name="while">
    <xsl:with-param name="i" select="$i + 1"/>
    <xsl:with-param name="temp" select="$zr * $zi"/>
    <xsl:with-param name="zr2" select="$zr * $zr"/>
    <xsl:with-param name="zi2" select="$zi * $zi"/>
    <xsl:with-param name="cr" select="$cr"/>
    <xsl:with-param name="ci" select="$ci"/>
   </xsl:call-template>
 </xsl:template>

 <xsl:template name="for_x">
  <xsl:param name="x"/>
  <xsl:param name="y"/>
  <xsl:if test="$x &lt; 39">
   <xsl:call-template name="mandelbrot">
    <xsl:with-param name="cr" select="$y div 40 - 0.5"/>
    <xsl:with-param name="ci" select="$x div 40"/>
    <xsl:with-param name="zr" select="0.0"/>
    <xsl:with-param name="zi" select="0.0"/>
    <xsl:with-param name="i" select="0"/>
   </xsl:call-template>
   <xsl:call-template name="for_x">
    <xsl:with-param name="x" select="$x + 1"/>
    <xsl:with-param name="y" select="$y"/>
   </xsl:call-template>
  </xsl:if>
 </xsl:template>

 <xsl:template name="for_y">
  <xsl:param name="y"/>
  <xsl:if test="$y &lt; 39">
   <xsl:value-of select="'&#10;'"/>
   <xsl:call-template name="for_x">
    <xsl:with-param name="x" select="-39"/>
    <xsl:with-param name="y" select="$y"/>
   </xsl:call-template>
   <xsl:call-template name="for_y">
    <xsl:with-param name="y" select="$y + 1"/>
   </xsl:call-template>
  </xsl:if>
 </xsl:template>

 <xsl:template match="/">
  <xsl:call-template name="for_y">
   <xsl:with-param name="y" select="-39"/>
  </xsl:call-template>
 </xsl:template>

</xsl:stylesheet>

tcsh 6.15.00

#!/usr/bin/tcsh
# by Erik Wrenholt, ported from C to tcsh 6.15.00 by Theo Wollenleben
# 32 bit signed integer arithmetic, output differs slightly
@ SCALE = (1 << 24) SCALE2 = (1 << 12)

@ BAILOUT = 16 * $SCALE
set MAX_ITERATIONS = 1000

alias mandelbrot 'set x = \!:1 set y = \!:2 \
  \
  @ cr = $y - $SCALE / 2 \
  set ci = $x \
  set zi = 0 \
  set zr = 0 \
  set i = 0 \
  \
  while (1) \
    @ i ++ \
    @ temp = ($zr / $SCALE2) * ($zi / $SCALE2) \
    @ zr2 = ($zr / $SCALE2) * ($zr / $SCALE2) \
    @ zi2 = ($zi / $SCALE2) * ($zi / $SCALE2) \
    @ zr = ($zr2 - $zi2) + $cr \
    @ zi = ($temp + $temp) + $ci \
    if ($zi2 + $zr2 > $BAILOUT) then \
      echo $i; break \
    endif \
    if ($i > $MAX_ITERATIONS) then \
      echo 0; break \
    endif \
  end'

set y = -39
while ($y < 39)
  echo
  set x = -39
  while ($x < 39)
    @ arg_x = ($x * $SCALE) / 40
    @ arg_y = ($y * $SCALE) / 40
    set i = `mandelbrot $arg_x $arg_y`
    if ($i == 0) then
      echo -n "*"
    else
      echo -n  " "
    endif
    @ x ++
  end
  @ y ++
end
echo

set time = ( 0 "%U+%S" )
echo -n "tcsh Elapsed "
time

dash 0.5.5.1

#!/usr/local/bin/dash
# by Erik Wrenholt, ported from C to dash 0.5.5.1 by Theo Wollenleben
# 64 bit signed integer precision
SCALE=$((1<<56)); SCALE2=$((1<<28))

BAILOUT=$((16*SCALE))
MAX_ITERATIONS=1000

mandelbrot ()
{ x=$1 y=$2
  
  cr=$((y-SCALE/2))
  ci=$x
  zi=0
  zr=0
  i=0
  
  while true; do
    i=$((i+1))
    temp=$(((zr/SCALE2)*(zi/SCALE2)))
    zr2=$(((zr/SCALE2)*(zr/SCALE2)))
    zi2=$(((zi/SCALE2)*(zi/SCALE2)))
    zr=$((zr2-zi2+cr))
    zi=$((temp+temp+ci))
    if [ $((zi2+zr2)) -gt $BAILOUT ]; then
      printf $i; return
    fi
    if [ $i -gt $MAX_ITERATIONS ]; then
      printf 0; return
    fi
  done
  
}

y=-39
while [ $y -lt 39 ]; do
  echo
  x=-39
  while [ $x -lt 39 ]; do
    i=$(mandelbrot $((x*SCALE/40)) $((y*SCALE/40)))
    if [ $i -eq 0 ]; then
      printf "*"
    else
      printf " "
    fi
    x=$((x+1))
  done
  y=$((y+1))
done
echo

echo dash Elapsed
times

cmd.exe Windows XP

@echo off
rem by Erik Wrenholt, ported from C to Windows XP cmd.exe by Theo Wollenleben
setlocal EnableDelayedExpansion
rem 32 bit signed integer precision, output differs slightly
set /a SCALE="1<<24"
set /a SCALE2="1<<12"

set /a BAILOUT = 16 * SCALE
set MAX_ITERATIONS=1000

call:main & endlocal & goto:eof

rem wall clock time in seconds
:wall_time
  for /f "tokens=3-5 delims=:. " %%a in ('echo.^|time') do (
    set /a %1 = ^(%%a*60+%%b^)*60+%%c & goto:eof)
goto:eof

:mandelbrot
  set x=%2 & set y=%3
  set /a cr = y - SCALE / 2 
  set /a ci = x
  set zi=0
  set zr=0
  set i=0
  :while
    set /a i += 1
    set /a temp = (zr / SCALE2) * (zi / SCALE2)
    set /a zr2 = (zr / SCALE2) * (zr / SCALE2)
    set /a zi2 = (zi / SCALE2) * (zi / SCALE2)
    set /a zr = zr2 - zi2 + cr
    set /a zi = temp + temp + ci
    set /a r2 = zi2 + zr2
    if %r2% gtr %BAILOUT% (
      set /a %1 = %i% & goto:eof)
    if %i% gtr %MAX_ITERATIONS% (
      set /a %1 = 0 & goto:eof)
  goto while
goto:eof

:main
  call:wall_time init_time

  for /l %%y in (-39, 1, 38) do (
    echo.
    for /l %%x in (-39, 1, 38) do (
      set /a arg_x = %%x * SCALE / 40
      set /a arg_y = %%y * SCALE / 40
      call:mandelbrot i !arg_x! !arg_y!
      if !i! equ 0 (
        <nul set/p output="*"
      ) else (
        <nul set/p output= )
    )
  )
  echo.

  call:wall_time final_time
  set /a query_time = final_time - init_time
  echo cmd Elapsed %query_time%
goto:eof

bash 3.2

#!/bin/bash
# by Erik Wrenholt, ported from C to GNU bash 3.2 by Theo Wollenleben
# 64 bit signed integer precision
declare -i SCALE=2**56 SCALE2=2**28

declare -i BAILOUT=16*SCALE
declare -i MAX_ITERATIONS=1000

function mandelbrot
{ local -i x=$1 y=$2

  local -i cr=y-SCALE/2 ci=x
  local -i zi=0 zr=0 i=0 temp zr2 zi2

  while true; do
    i=i+1
    temp=\(zr/SCALE2\)*\(zi/SCALE2\)
    zr2=\(zr/SCALE2\)*\(zr/SCALE2\)
    zi2=\(zi/SCALE2\)*\(zi/SCALE2\)
    zr=zr2-zi2+cr
    zi=temp+temp+ci
    if [[ zi2+zr2 -gt BAILOUT ]]; then
      printf $i; return
    fi
    if [[ i -gt MAX_ITERATIONS ]]; then
      printf 0; return
    fi
  done
}

declare -i x y
for ((y = -39; y < 39; y++)); do
  echo
  for ((x = -39; x < 39; x++)); do
    declare -i i=$(mandelbrot $((x*SCALE/40)) $((y*SCALE/40)))
    if [[ i -eq 0 ]]; then
      printf "*"
    else
      printf " "
    fi
  done
done
echo

export LC_NUMERIC=C
times > >(read -d "" TIMES
  TIMES=${TIMES//[ $'\n']/+}
  TIMES=${TIMES//[s.]/}
  TIMES=${TIMES//m/*60000+10#}
  TIMES=$(printf "%03d" $(($TIMES)))
  FLOOR=${TIMES%???}
  printf "bash Elapsed %0.2f\n" $FLOOR.${TIMES#$FLOOR})

KornShell 93t

#!/usr/bin/ksh
# by Erik Wrenholt, ported from C to KornShell 93t by Theo Wollenleben
# arithmetic evaluation depends on language settings
export LANG; LANG=en_EN.UTF-8

typeset -E BAILOUT=16
typeset -i MAX_ITERATIONS=1000

# CPU time in seconds
# ksh ignores TIMEFORMAT if 'time' is called without pipeline
function cpu_time
{
  typeset t=$({ time;} 2>&1)
  t=${t//~(E:(user|sys|s|\t))/}
  t=${t//h/*3600+}; t=${t//m/*60+}
  printf $((${t/$'\n'/+}))
}

function mandelbrot
{ typeset -E x=$1 y=$2
  
  typeset -E cr=y-0.5 ci=x
  typeset -E zi=0.0 zr=0.0 temp zr2 zi2
  typeset -i i=0
  
  while true; do
   i=i+1
   temp=zr*zi
   zr2=zr*zr
   zi2=zi*zi
   zr=zr2-zi2+cr
   zi=temp+temp+ci
   if ((zi2 + zr2 > BAILOUT)); then
     printf $i; return
   fi
   if ((i > MAX_ITERATIONS)); then
     printf 0; return
   fi
  done
  
}

init_time=$(cpu_time)

typeset -i x y
for ((y = -39; y < 39; y++)); do
  printf "\n"
  for ((x = -39; x < 39; x++)); do
    typeset -i i=$(mandelbrot $((x/40.0)) $((y/40.0)))
    if ((i == 0)); then
      printf "*"
    else
      printf " "
    fi
  done
done
printf "\n"

printf "KornShell Elapsed %0.2f\n" $(($(cpu_time)-init_time))

Z shell 4.3.6

#!/usr/bin/zsh
# by Erik Wrenholt, ported from C to Z shell 4.3.6 by Theo Wollenleben

float BAILOUT=16
integer MAX_ITERATIONS=1000

function mandelbrot
{ float x=$1 y=$2
  
  float cr=y-0.5 ci=x
  float zi=0.0 zr=0.0 temp zr2 zi2
  integer i=0
  
  while true; do
   i=i+1
   temp=zr*zi
   zr2=zr*zr
   zi2=zi*zi
   zr=zr2-zi2+cr
   zi=temp+temp+ci
   if ((zi2 + zr2 > BAILOUT)); then
     printf $i; return
   fi
   if ((i > MAX_ITERATIONS)); then
     printf 0; return
   fi
  done
  
}

integer x y
for ((y = -39; y < 39; y++)); do
  print
  for ((x = -39; x < 39; x++)); do
    integer i=$(mandelbrot $((x/40.0)) $((y/40.0)))
    if ((i == 0)); then
      printf "*"
    else
      printf " "
    fi
  done
done
print

export TIMEFMT="%U+%S" LC_NUMERIC=C
{ time;} 2> >(
  read -d "" TIME
  printf "zsh Elapsed %0.2f\n" $((${${TIME//s/}/$'\n'/+}))
)

Mathematica 5.2

#!/usr/local/bin/math -initfile
(* by Erik Wrenholt, ported from C to Mathematica 5.2 by Theo Wollenleben *)
$MinPrecision = $MaxPrecision = $MachinePrecision

BAILOUT = 16;
MAXITERATIONS = 1000;

mandelbrot[x_, y_] := Module[
 {cr = y - 0.5,
  ci = x,
  zi = 0.0,
  zr = 0.0,
  i = 0,
  temp, zr2, zi2},
  
  While[True,
   i ++;
   temp = zr zi;
   zr2 = zr zr;
   zi2 = zi zi;
   zr = zr2 - zi2 + cr;
   zi = temp + temp + ci;
   If[zi2 + zr2 > BAILOUT,
     Return[i]];
   If[i > MAXITERATIONS,
     Return[0]]
  ]
  
];

inittime = TimeUsed[];

For[y = -39, y < 39, y++,
  Print[];
  For[x = -39, x < 39, x++,
    i = mandelbrot[x/40.0, y/40.0];
    If[i==0,
      WriteString["stdout", "*"],
      WriteString["stdout", " "]]
  ]
]
Print[];

querytime = TimeUsed[] - inittime;
Print["Mathematica Elapsed ", querytime];
Quit[]

Mathematica 5.2 compiled

#!/usr/local/bin/math -initfile
(* by Erik Wrenholt, ported from C to Mathematica by Theo Wollenleben *)
$MinPrecision = $MaxPrecision = $MachinePrecision

BAILOUT = 16;
MAXITERATIONS = 1000;

mandelbrot = Compile[{x, y}, Module[
 {cr = y - 0.5,
  ci = x,
  zi = 0.0,
  zr = 0.0,
  i = 0,
  temp, zr2, zi2},
  
  While[True,
   i ++;
   temp = zr zi;
   zr2 = zr zr;
   zi2 = zi zi;
   zr = zr2 - zi2 + cr;
   zi = temp + temp + ci;
   If[zi2 + zr2 > BAILOUT,
     Return[i]];
   If[i > MAXITERATIONS,
     Return[0]]
  ];
  Return[0]
]];

inittime = TimeUsed[];

For[y = -39, y < 39, y++,
  Print[];
  For[x = -39, x < 39, x++,
    i = mandelbrot[x/40.0, y/40.0];
    If[i==0,
      WriteString["stdout", "*"],
      WriteString["stdout", " "]]
  ]
];
Print[];

querytime = TimeUsed[] - inittime;
Print["Mathematica Elapsed ", querytime]
Quit[]

Maple 10

#!/opt/maple10/bin/maple -q
# by Erik Wrenholt, ported from C to Maple 10.00 by Theo Wollenleben
# may crash randomly with odd error "Execution stopped: Stack limit reached."
# using kernelopts(stacklimit=...) doesn't help
Digits := 16:

BAILOUT := 16:
MAX_ITERATIONS := 1000:

mandelbrot := proc(x, y)
  local cr, ci, zi, zr, i, temp, zr2, zi2;
  cr := y - 0.5:
  ci := x:
  zi := 0.0:
  zr := 0.0:
  i := 0:

  while true do
    i := i + 1:
    temp := zr * zi:
    zr2 := zr * zr:
    zi2 := zi * zi:
    zr := zr2 - zi2 + cr:
    zi := temp + temp + ci:
    if zi2 + zr2 > BAILOUT then
      return i
    end if;
    if i > MAX_ITERATIONS then
      return 0
    end if
  end do

end proc:

init_time := time():

for y from -39 to 38 do
  printf("\n");
  for x from -39 to 38 do
    i := mandelbrot(x/40.0, y/40.0);
    if i=0 then
     printf("*")
    else
     printf(" ")
    end if;
  end do;
end do;
printf("\n");

query_time := time() - init_time:
printf("Maple Elapsed %0.3f\n", query_time);

Maple 10 compiled GCC 4.3.2

#!/opt/maple10/bin/maple -q
# by Erik Wrenholt, ported from C to Maple 10.00 by Theo Wollenleben

BAILOUT := 16:
MAX_ITERATIONS := 1000:

mandelbrot := proc(x, y)
  local cr, ci, zi, zr, i, temp, zr2, zi2;
  cr := y - 0.5:
  ci := x:
  zi := 0.0:
  zr := 0.0:
  i := 0:

  while true do
    i := i + 1:
    temp := zr * zi:
    zr2 := zr * zr:
    zi2 := zi * zi:
    zr := zr2 - zi2 + cr:
    zi := temp + temp + ci:
    if zi2 + zr2 > BAILOUT then
      return i
    end if;
    if i > MAX_ITERATIONS then
      return 0
    end if
  end do

end proc:

cmandelbrot := Compiler:-Compile(mandelbrot, optimize=true):

init_time := time():

for y from -39 to 38 do
  printf("\n");
  for x from -39 to 38 do
    i := cmandelbrot(x/40.0, y/40.0);
    if i=0 then
     printf("*")
    else
     printf(" ")
    end if;
  end do;
end do;
printf("\n");

query_time := time() - init_time:
printf("Maple Elapsed %0.3f\n", query_time);

Maxima 5.1

/* maxima --very-quiet < Mandelbrot.mac */
/* by Erik Wrenholt, ported from C to Maxima 5.17.1 by Theo Wollenleben */
/* needed for compilation: */
mode_declare(
  BAILOUT,fixnum,
  MAX_ITERATIONS,fixnum,
  i,fixnum
)$
i: 0$
/* maxima -r 'compile_file("Mandelbrot.mac");' */
/* maxima -q --batch-lisp=Mandelbrot.fas */

BAILOUT: 16$
MAX_ITERATIONS: 1000$

mandelbrot(x, y) :=
block(
  [cr: y - 0.5,
   ci: x,
   zi: 0.0,
   zr: 0.0,
   i: 0,
   temp, zr2, zi2
  ],

  while true do (
   i: i + 1,
   temp: zr * zi,
   zr2: zr * zr,
   zi2: zi * zi,
   zr: zr2 - zi2 + cr,
   zi: temp + temp + ci,
   if zi2 + zr2 > BAILOUT then
     return(i),
   if i > MAX_ITERATIONS then
     return(0)
  )
  
)$

for y: -39 thru 38 step 1 do (
  printf(true, "~%"),
  for x: -39 thru 38 do (
    i: mandelbrot(x/40.0, y/40.0),
    if i=0 then
      printf(true, "*")
    else
      printf(true, " ")
  )
)$
print("")$

query_time: elapsed_run_time ()$
printf(true, "Maxima Elapsed ~,2f~%", query_time)$
quit()$

Axiom jan2009

-- su -c 'axiom -noht'
-- )read Mandelbrot )quiet
-- need to run as root only if axiom was installed as root
-- by Erik Wrenholt, ported from C to Axiom by Theo Wollenleben
)set messages autoload off
)set message time on
)set messages type off
)set output length 79
)set quit unprotected

macro BAILOUT == 16;
macro MAX_ITERATIONS == 1000;

mandelbrot(x: DoubleFloat, y: DoubleFloat): Integer ==
  
  cr : DoubleFloat
  cr :=  y - 0.5
  ci : DoubleFloat
  ci := x
  zi : DoubleFloat := 0.0
  zr : DoubleFloat := 0.0
  i : Integer := 0
  
  temp : DoubleFloat
  zr2 : DoubleFloat
  zi2 : DoubleFloat
  while true repeat
    i := i + 1
    temp := zr * zi
    zr2 := zr * zr
    zi2 := zi * zi
    zr := zr2 - zi2 + cr
    zi := temp + temp + ci
    if  zi2 + zr2 > BAILOUT then
      return i
    if i > MAX_ITERATIONS then
      return 0

x : Integer
x : Integer
i : Integer
line : String := ""; -- I found no way to print without newline
for y in -39..38 repeat
  output(line); line := ""
  for x in -39..39 repeat
    i := mandelbrot(x/40.0, y/40.0)
    if i=0 then
      line := concat(line, "*")
    else
      line := concat(line, " ")
output("")

)quit

Yacas 1.2.2

// yacas -pc Mandelbrot.ys
// by Erik Wrenholt, ported from C to Yacas 1.2.2 by Theo Wollenleben
Builtin'Precision'Set(16);

BAILOUT := 16;
MAXITERATIONS := 1000;

Function("mandelbrot", {x, y})
[ Local(cr,ci,zi,zr,i,temp,zr2,zi2);
  cr := y - 0.5;
  ci := If(x=0,1e-85,x); // avoid very slow arithmetic with zero
  zi := 0.0;
  zr := 0.0;
  i := 0;
  
  Until(zi2 + zr2 > BAILOUT Or i > MAXITERATIONS) [
    i ++;
    temp := zr * zi;
    zr2 := zr * zr;
    zi2 := zi * zi;
    zr := zr2 - zi2 + cr;
    zi := temp + temp + ci;
  ];
  If (i > MAXITERATIONS,
    i := 0);
  i;
  
];

querytime := GetTime([

  For (y := -39, y < 39, y++) [
    NewLine();
    For (x := -39, x < 39, x++) [
      i := mandelbrot(MathDivide(x,40.0), MathDivide(y,40.0));
      If (i=0,
        WriteString("*"),
        WriteString(" ")
      );
    ];
  ];
  NewLine();

]);

WriteString("Yacas Elapsed");
Echo(N(querytime,2));

Yacas 1.2.2 core

// yacas -pc Mandelbrot-core.ys
// by Erik Wrenholt, ported from C to Yacas 1.2.2 by Theo Wollenleben
// uses built-in (core) functions
Builtin'Precision'Set(16);

BAILOUT := 16;
MAXITERATIONS := 1000;

Function("mandelbrot", {x, y})
[ Local(cr,ci,zi,zr,i,temp,zr2,zi2);
  cr := MathSubtract(y,0.5);
  ci := If(x=0,1e-85,x); // avoid very slow arithmetic with zero
  zi := 0.0;
  zr := 0.0;
  i := 0;
  
  Until(Or(GreaterThan(MathAdd(zi2,zr2),BAILOUT),
        GreaterThan(i,MAXITERATIONS))) [
    i := MathAdd(i,1);
    temp := MathMultiply(zr,zi);
    zr2 := MathMultiply(zr,zr);
    zi2 := MathMultiply(zi,zi);
    zr := MathAdd(MathSubtract(zr2,zi2),cr);
    zi := MathAdd(MathAdd(temp,temp),ci);
  ];
  If (GreaterThan(i,MAXITERATIONS),
    i := 0);
  i;
  
];

querytime := GetTime([

  For (y := -39, LessThan(y,39), y := MathAdd(y,1)) [
    NewLine();
    For (x := -39, LessThan(x,39), x := MathAdd(x,1)) [
      i := mandelbrot(MathDivide(x,40.0), MathDivide(y,40.0));
      If (Equals(i,0),
        WriteString("*"),
        WriteString(" ")
      );
    ];
  ];
  NewLine();

]);

WriteString("Yacas Elapsed");
Echo(N(querytime,2));

Singular 3.0.4

// Singular -q --ticks-per-sec=100 ./Mandelbrot.sing
// by Erik Wrenholt, ported from C to Singular 3.0.4 by Theo Wollenleben
ring r = (real,16),x,dp; // double precision floating point numbers

number BAILOUT=16;
int MAX_ITERATIONS=1000;

proc mandelbrot (x, y)
{
  number cr = y - 0.5;
  number ci = x;
  number zi = 0.0;
  number zr = 0.0;
  int i = 0;

  number temp,zr2,zi2;
  while(1) {
    i ++;
    temp = zr * zi;
    zr2 = zr * zr;
    zi2 = zi * zi;
    zr = zr2 - zi2 + cr;
    zi = temp + temp + ci;
    if (zi2 + zr2 > BAILOUT) {
      return(i); }
    if (i > MAX_ITERATIONS) {
      return(0); }
  }

}

number init_time = timer;

int x,y,i;
string line; // I found no way to print without newline
for (y = -39; y < 39; y++) {
  print(line); line="";
  for (x = -39; x < 39; x++) {
    i = mandelbrot(x/40.0, y/40.0);
    if (i==0) {
     line=line+sprintf("*"); }
    else {
     line=line+sprintf(" "); }
  }
}
print ("");

number query_time = (timer - init_time)/system("--ticks-per-sec");
printf ("%s%s", "Singular Elapsed ", query_time);
quit;

GAP 4

# gap -q -L /opt/gap4r4/bin/wsgap4 < Mandelbrot.g
# by Erik Wrenholt, ported from C to GAP 4 by Theo Wollenleben
# no floating point arithmetic
# SCALE is large enough such that output image does not differ
SCALE:=2^68;; SCALE2:=2^34;;

BAILOUT:=16*SCALE;;
MAX_ITERATIONS:=1000;;

mandelbrot:= function(x, y)
  local cr, ci, zi, zr, i, temp, zr2, zi2;
  cr := y - QuoInt(SCALE,2);
  ci := x;
  zi := 0;
  zr := 0;
  i := 0;
  
  while true do
    i :=  i + 1;
    temp := QuoInt(zr,SCALE2) * QuoInt(zi,SCALE2);
    zr2 := QuoInt(zr,SCALE2) * QuoInt(zr,SCALE2);
    zi2 := QuoInt(zi,SCALE2) * QuoInt(zi,SCALE2);
    zr := zr2 - zi2 + cr;
    zi := temp + temp + ci;
    if zi2 + zr2 > BAILOUT then
      return i; fi;
    if i > MAX_ITERATIONS then
      return 0; fi;
  od;
  
end;;

aTv := Runtimes();;
init_time := aTv.user_time+aTv.system_time+aTv.user_time_children+aTv.system_time_children;;

for y in [-39..38] do
  Print("\n");
  for x in [-39..38] do
    i := mandelbrot(QuoInt(x*SCALE,40), QuoInt(y*SCALE,40));
    if i=0 then
      Print("*\c");
    else
      Print(" \c");
    fi;
  od;
od;
Print ("\n");

aTv := Runtimes();;
query_time := aTv.user_time+aTv.system_time+aTv.user_time_children+aTv.system_time_children-init_time;;
query_time_string := ReplacedString(String(query_time,4)," ","0");;
Add(query_time_string,'.',Length(query_time_string)-2);
Print("GAP Elapsed ",query_time_string,"\n");

quit;

Octave 3.0.3

#!/usr/bin/octave -q
# by Erik Wrenholt, ported from C to Octave 3.0.3 by Theo Wollenleben

global BAILOUT = 16;
global MAX_ITERATIONS = 1000;

function i = mandelbrot (x, y)

  global BAILOUT MAX_ITERATIONS
  cr = y - 0.5;
  ci = x;
  zi = 0.0;
  zr = 0.0;
  i = 0;
  
  while(1)
    i ++;
    temp = zr * zi;
    zr2 = zr * zr;
    zi2 = zi * zi;
    zr = zr2 - zi2 + cr;
    zi = temp + temp + ci;
    if (zi2 + zr2 > BAILOUT)
      return;
    endif
    if (i > MAX_ITERATIONS)
      i = 0; return;
    endif
  endwhile
  
endfunction

init_time = cputime () (1);

for y = -39:38
  printf("\n");
    for x = -39:38
      i = mandelbrot(x/40.0, y/40.0);
      if (i==0)
        printf("*");
      else
        printf(" ");
      endif
    endfor
endfor
printf ("\n");

query_time = cputime () (1) - init_time;
printf ("Octave Elapsed %0.2f\n", query_time);

Scilab 5.1

// scilab -nogui -nwni -nb -nouserstartup -f Mandelbrot.sci
// by Erik Wrenholt, ported from C to Scilab 5.1 by Theo Wollenleben

BAILOUT = 16;
MAX_ITERATIONS = 1000;

function i = mandelbrot (x, y)
  
  cr = y - 0.5;
  ci = x;
  zi = 0.0;
  zr = 0.0;
  i = 0;
  
  while 1
    i = i + 1;
    temp = zr * zi;
    zr2 = zr * zr;
    zi2 = zi * zi;
    zr = zr2 - zi2 + cr;
    zi = temp + temp + ci;
    if zi2 + zr2 > BAILOUT
      return;
    end
    if i > MAX_ITERATIONS
      i = 0; return;
    end
  end
  
endfunction

init_time = timer();

for y = -39:38
  printf('\n');
    for x = -39:38
      i = mandelbrot(x/40.0, y/40.0);
      if (i==0)
        printf("*");
      else
        printf(" ");
      end
    end
end
printf ("\n");

query_time = timer() - init_time;
printf ("Scilab Elapsed %0.2f\n", query_time);
quit

Haskell

-- ghc --make Mandelbrot.hs; ./Mandelbrot
-- runghc ./Mandelbrot.hs # remove output of ghc before!
-- runhugs ./Mandelbrot.hs
-- by Erik Wrenholt, ported to Haskell by Brad Clawsie
-- completed by Theo Wollenleben

module Main where
import System.CPUTime
import Text.Printf

mandelbrot :: Double -> Double -> Int
mandelbrot x y =
  while 0.0 0.0 0
  where bailout = 16
        maxIterations = 1000
        cr = y - 0.5
        ci = x
        while :: Double -> Double -> Int -> Int
        while zr zi i = 
          let i' = succ i
              temp = zr * zi
              zr2 = zr * zr
              zi2 = zi * zi
              zr' = zr2 - zi2 + cr
              zi' = temp + temp + ci in
          case (zi2 + zr2 > bailout) of
            True -> i'
            False -> case (i' > maxIterations) of
              True -> 0
              False -> while zr' zi' i'

main = do
  init_time <- getCPUTime
  let i = map (map (\(x,y) -> mandelbrot (x/40.0) (y/40.0)))
              [[(x,y) | x <- [-39..38]] | y <- [-39..38]]
  mapM putStr (map (('\n':).(map (\i -> if i==0 then '*' else ' '))) i)
  putStr "\n"
  final_time <- getCPUTime
  let query_time = final_time - init_time
  printf "Haskell Elapsed %0.2f\n" ((fromIntegral query_time)/10^12::Double)

Haskell jhc 0.6.0 GCC 4.3.2

-- ghc --make Mandelbrot.hs; ./Mandelbrot
-- runghc ./Mandelbrot.hs # remove output of ghc before!
-- runhugs ./Mandelbrot.hs
-- by Erik Wrenholt, ported to Haskell by Brad Clawsie
-- completed by Theo Wollenleben

module Main where
-- import System.CPUtime -- missing in jhc 0.6.0
import Text.Printf

mandelbrot :: Double -> Double -> Int
mandelbrot x y =
  while 0.0 0.0 0
  where bailout = 16
        maxIterations = 1000
        cr = y - 0.5
        ci = x
        while :: Double -> Double -> Int -> Int
        while zr zi i = 
          let i' = succ i
              temp = zr * zi
              zr2 = zr * zr
              zi2 = zi * zi
              zr' = zr2 - zi2 + cr
              zi' = temp + temp + ci in
          case (zi2 + zr2 > bailout) of
            True -> i'
            False -> case (i' > maxIterations) of
              True -> 0
              False -> while zr' zi' i'

main = do
--   init_time <- System.CPUtime.getCPUTime
  let i = map (map (\(x,y) -> mandelbrot (x/40.0) (y/40.0)))
              [[(x,y) | x <- [-39..38]] | y <- [-39..38]]
  mapM putStr (map (('\n':).(map (\i -> if i==0 then '*' else ' '))) i)
  putStr "\n"
--   final_time <- System.CPUtime.getCPUTime
--   let query_time = final_time - init_time
--   printf "Haskell Elapsed %0.2f\n" ((fromIntegral query_time)/10^12::Double)

Cobra 0.8.0

"""
See http://www.timestretch.com/FractalBenchmark.html
History
    2009-03-09 Csaba Urbaniczky
    2009-03-09 Test in SciTE 
        With float:: 48-128 ms (in SciTE)
        With  float & Try Catch  &:48-128 ms  = same!
        With decimal & Try Catch  6.05 - 6.06 s = very much slower!
        VB.NET 2005 version on the same computer: 175-180 ms
    2009-03-10 Code cleanup by Chuck Esterbrook
    2009-04-22 Minor changes by Theo Wollenleben to make it work
               with Cobra 0.8.0 for Unix
"""

class Program 

    def mandelbrot is shared
        for y in -39 : 39
            print
            for x in -39 : 39
                if .calc(x/40, y/40), c = '*'
                else, c = ' '
                print c stop

    def calc(ci as number, y as number) as bool is shared
        bailOut = 16
        maxIterations = 1_000
        cr = y - 0.5
        zr = 0.0
        zi = 0.0
        for i in 0 : maxIterations
            zr2 = zr * zr
            zi2 = zi * zi
            if zi2 + zr2 > bailOut, return false
            temp = zr * zi
            zr = zr2 - zi2 + cr
            zi = temp + temp + ci
        return true

    def main is shared
        sw = System.Diagnostics.Stopwatch()
        sw.start
        .mandelbrot
        sw.stop
        print
        print 'Cobra elapsed: [sw.elapsedMilliseconds] ms'

Erlang R12B5

-module(mandelbrot).
-author("Jim Menard, jimm@io.com").
-export([run/0]).

-define(BAILOUT, 16).
-define(MAX_ITERATIONS, 1000).

%% Idea from http://www.timestretch.com/FractalBenchmark.html

run() ->
    io:format("Rendering~n"),
    statistics(runtime),
    statistics(wall_clock),
    lists:map(fun(Y) ->
                      io:format("~n"),
                      lists:map(fun(X) -> plot(X, Y) end, lists:seq(-39, 39))
              end,
              lists:seq(-39, 39)),
    io:format("~n"),
    {_, Time1} = statistics(runtime),
    {_, Time2} = statistics(wall_clock),
    Sec1 = Time1 / 1000.0,
    Sec2 = Time2 / 1000.0,
    io:format("Erlang Elapsed ~p (runtime) ~p (wall clock) seconds~n",
              [Sec1, Sec2]).

plot(X, Y) ->
    case iterate(X/40.0, Y/40.0) of
        0 ->
            io:format("*");
        _ ->
            io:format(" ")
    end.

iterate(X, Y) ->
    CR = Y - 0.5,
    CI = X,
    iter_value(CR, CI, 0.0, 0.0, 0.0, 0.0, 0).

iter_value(_CR, _, _ZI, _ZI2, _ZR, _ZR2, I)
  when I > ?MAX_ITERATIONS,
  is_float(_CR), is_float(_ZI), is_float(_ZI2), is_float(_ZR), is_float(_ZR2) ->
    0;
iter_value(_CR, _, _ZI, _ZI2, _ZR, _ZR2, I)
  when _ZI2 + _ZR2 > ?BAILOUT,
  is_float(_CR), is_float(_ZI), is_float(_ZI2), is_float(_ZR), is_float(_ZR2) ->
    I;
iter_value(CR, CI, ZI, ZI2, ZR, ZR2, I)
  when
  is_float(CR), is_float(ZI), is_float(ZI2), is_float(ZR), is_float(ZR2) ->
    Temp = ZR * ZI,
    ZRnew = ZR2 - ZI2 + CR,
    ZInew = Temp + Temp + CI,
    iter_value(CR, CI, ZInew, ZInew * ZInew, ZRnew, ZRnew * ZRnew, I + 1).

Fortran 95 G

! by Erik Wrenholt, ported from C to Fortran 95 by Theo Wollenleben

program main
    implicit none
    
    real :: init_time, final_time, query_time
    integer, parameter :: BAILOUT = 16
    integer, parameter :: MAX_ITERATIONS = 1000
    integer :: x, y, i
    
    call cpu_time(init_time)

    do y = -39, 38
        print *
        do x = -39, 38
            i = mandelbrot(DBLE(x)/40.0, DBLE(y)/40.0)
            if (i==0) then
                write(*,'(a)',advance='no') '*'
            else
                write(*,'(a)',advance='no') ' '
            end if
        end do
    end do
    print *
    
    call cpu_time(final_time)
    query_time = final_time - init_time
    print '("Fortran Elapsed ",f4.2)',query_time
    
contains
    
    integer function mandelbrot(x, y)
        implicit none
        
        double precision, intent(in) :: x, y
        double precision :: cr, ci, zi, zr, temp, zr2, zi2
        integer :: i
        cr = y - 0.5
        ci = x
        zi = 0.0
        zr = 0.0
        i = 0
        
        do
            i = i + 1
            temp = zr * zi
            zr2 = zr * zr
            zi2 = zi * zi
            zr = zr2 - zi2 + cr
            zi = temp + temp + ci
            if (zi2 + zr2 > BAILOUT) then
                mandelbrot = i; exit
            end if
            if (i > MAX_ITERATIONS) then
                mandelbrot = 0; exit
            end if
        end do
        
    end function mandelbrot
    
end program main

Pascal FPC 2.2.2

{ fpc -O3 Mandelbrot.pas }
{ by Erik Wrenholt, ported from C to Pascal by Theo Wollenleben }

program Mandelbrot;

uses  BaseUnix;

const BAILOUT = 16;
      MAX_ITERATIONS = 1000;

var x, y : integer;
    i : integer;
    buf : tms;
    init_time, final_time: clock_t;

function mandelbrot (x, y : double) : integer;
var cr, ci, zi, zr : double;
    i : integer;
    temp, zr2, zi2 : double;
begin
    cr := y - 0.5;
    ci := x;
    zi := 0.0;
    zr := 0.0;
    i := 0;

    while TRUE do begin
        i := i + 1;
        temp := zr * zi;
        zr2 := zr * zr;
        zi2 := zi * zi;
        zr := zr2 - zi2 + cr;
        zi := temp + temp + ci;
        if zi2 + zr2 > BAILOUT then
            begin mandelbrot := i; break; end;
        if i > MAX_ITERATIONS then
            begin mandelbrot := 0; break; end;
    end;

end;

begin

    FpTimes(buf);
    init_time := buf.tms_utime + buf.tms_stime
               + buf.tms_cutime + buf.tms_cstime;

    for y := -39 to 38 do begin
        writeln;
        for x := -39 to 38 do begin
            i := mandelbrot(x/40.0, y/40.0);
            if i = 0 then
                write('*')
            else
                write(' ');
        end;
    end;
    writeln;

    FpTimes(buf);
    final_time := buf.tms_utime + buf.tms_stime
                + buf.tms_cutime + buf.tms_cstime;
    writeln('Pascal Elapsed ', (final_time-init_time)/100:1:2);

end.

GNU Sather 1.2.3 GCC 4.3.2

-- sacomp -O Mandelbrot.sa -o Mandelbrot
-- by Erik Wrenholt, ported from C to Sather by Theo Wollenleben

class MAIN is
  
  const BAILOUT := 16;
  const MAX_ITERATIONS := 1000;
  
  mandelbrot(x:FLTD, y:FLTD):INT is
    
    cr:FLTD := y - 0.5d;
    ci:FLTD := x;
    zi:FLTD := 0.0d;
    zr:FLTD := 0.0d;
    i:INT  := 0;
    
    loop while!(true);
      i := i + 1;
      temp:FLTD := zr * zi;
      zr2:FLTD  := zr * zr;
      zi2:FLTD  := zi * zi;
      zr := zr2 - zi2 + cr;
      zi := temp + temp + ci;
      if (zi2 + zr2 > BAILOUT.fltd) then
        return i;
      end;
      if (i > MAX_ITERATIONS) then
        return 0;
      end;
    end;
  
  end;
  
  main is
    time:TIMES := #;
    
    x,y:INT;
    loop y := (-39).upto!(38);
      #OUT + "\n";
      loop x := (-39).upto!(38);
        i:INT := mandelbrot(x.fltd/40.0d, y.fltd/40.0d);
        if (i=0) then
          #OUT + "*";
        else
          #OUT + " ";
        end;
      end;
    end;
    #OUT + "\n";
    
    elapsed_time:TIMES := time.elapsed;
    query_time:INT := elapsed_time.user_time + elapsed_time.sys_time;
                 -- + elapsed_time.child_user_time + elapsed_time.child_sys_time;
                 -- seems to give twice the correct time!
    #OUT + #FMT("Sather Elapsed %0.2f\n", query_time.fltd/100.0d);
  end;
  
end;

Pike 7.8.116

#! /usr/local/bin/pike

#define BAILOUT 16
#define MAX_ITERATIONS 1000

int mandelbrot (float x, float y) {
  
  float cr = y - 0.5;
  float ci = x;
  float zi = 0.0;
  float zr = 0.0;
  int i = 0;
  
  while (1) {
    i++;
    float temp = zr * zi;
    float zr2 = zr * zr;
    float zi2 = zi * zi;
    zr = zr2 - zi2 + cr;
    zi = temp + temp + ci;
      if (zi2 + zr2 > BAILOUT)
        return i;
      if (i > MAX_ITERATIONS)
        return 0;
  }
  
}


int main() {
  int init_time =  gethrvtime();

  int x,y;
  for (y = -39; y < 39; y++) {
    write("\n");
    for (x = -39; x < 39; x++) {
      int i = mandelbrot(x/40.0, y/40.0);
      if (i==0)
        write("*");
      else
        write(" ");
    }
  }
  write("\n");

  float query_time = (gethrvtime() - init_time)/1000000.0;
  write("Pike Elapsed %0.2f\n", query_time);
  return 0;
}

Oz Mozart 1.4.0

% ozc -x Mandelbrot.oz; ./Mandelbrot
% by Erik Wrenholt, ported from C to Oz by Theo Wollenleben

functor
  import
    Application(exit)
    System(printInfo showInfo)
    Property
  define
    
    BAILOUT = 16.0
    MAX_ITERATIONS = 1000
    
    fun {Mandelbrot X Y}
      
      Cr = Y - 0.5
      Ci = X
      Zi = 0.0
      Zr = 0.0
      I = 0
      
      fun {Iterate I Zr Zi}
        I_ = I + 1
        Temp = Zr * Zi
        Zr2 = Zr * Zr
        Zi2 = Zi * Zi
        Zr_ = Zr2 - Zi2 + Cr
        Zi_ = Temp + Temp + Ci
      in
        if Zi2 + Zr2 > BAILOUT then
          I_
        elseif I_ > MAX_ITERATIONS then
          0
        else {Iterate I_ Zr_ Zi_} end
      end
      
    in
      {Iterate I Zr Zi}
    end
    
    Init_time Final_time
    
  in
    Init_time = {Property.get 'time.user'} + {Property.get 'time.user'}
 
    for Y in ~39..38 do
      {System.printInfo "\n"}
      for X in ~39..38 do
        I = {Mandelbrot {IntToFloat X}/40.0 {IntToFloat Y}/40.0}
      in
        if I==0 then
          {System.printInfo "*"}
        else
          {System.printInfo " "}
        end
      end
    end
    {System.printInfo "\n"}
    
    Final_time = {Property.get 'time.user'} + {Property.get 'time.system'}
    {System.printInfo "Oz Elapsed "}
    {System.showInfo {IntToFloat (Final_time - Init_time)}/1000.0}
    {Application.exit 0}
end

Scheme Guile 1.8.5

#!/usr/bin/guile -s
!#
; by Erik Wrenholt, ported from C to Scheme by Theo Wollenleben

(define BAILOUT 16.0)
(define MAX_ITERATIONS 1000)

(define (mandelbrot x y)
  (letrec
    ((cr (- y 0.5))
     (ci x)
     (zi 0.0)
     (zr 0.0)
     (i 0)
     (iterate (lambda (i zr zi)
       (let*
         ((i_ (+ i 1))
          (temp (* zr zi))
          (zr2 (* zr zr))
          (zi2 (* zi zi))
          (zr_ (+ (- zr2 zi2) cr))
          (zi_ (+ temp temp ci)))
         (cond
           ((> (+ zi2 zr2) BAILOUT) i_)
           ((> i_ MAX_ITERATIONS) 0)
           (else (iterate i_ zr_ zi_)))))))
    (iterate i zr zi)))


(define init_time 0)
(let ((t (times)))
  (set! init_time (+
    (tms:utime t) (tms:stime t)
    (tms:cutime t) (tms:cstime t))))

(define x 0)(define y -39)
(let for () (if (< y 39) (begin
  (newline)
  (set! x -39)(let for () (if (< x 39) (begin
    (let ((i (mandelbrot (/ x 40.0) (/ y 40.0))))
       (if (= i 0)
         (display #\*)
         (display #\ )))
    (set! x (+ x 1))(for))))
  (set! y (+ y 1))(for))))
(newline)

(define query_time 0)
(let ((t (times)))
  (set! query_time (/ (+
    (tms:utime t) (tms:stime t)
    (tms:cutime t) (tms:cstime t) (- init_time)) 100.0)))
(display "Scheme Elapsed ")
(display query_time)
(newline)

Scheme 48 1.8

; echo $',set inline-values\n,open posix-time\n,load Mandelbrot.scheme48.scm\n,exit' | scheme48
; by Erik Wrenholt, ported from C to Scheme 48 by Theo Wollenleben

(define BAILOUT 16.0)
(define MAX_ITERATIONS 1000)

(define (mandelbrot x y)
  (letrec
    ((cr (- y 0.5))
     (ci x)
     (zi 0.0)
     (zr 0.0)
     (i 0)
     (iterate (lambda (i zr zi)
       (let*
         ((i_ (+ i 1))
          (temp (* zr zi))
          (zr2 (* zr zr))
          (zi2 (* zi zi))
          (zr_ (+ (- zr2 zi2) cr))
          (zi_ (+ temp temp ci)))
         (cond
           ((> (+ zi2 zr2) BAILOUT) i_)
           ((> i_ MAX_ITERATIONS) 0)
           (else (iterate i_ zr_ zi_)))))))
    (iterate i zr zi)))

(define init_time
  (time-seconds (current-time)))

(define x)(define y)
(set! y -39)(let for () (if (< y 39) (begin
  (newline)
  (set! x -39)(let for () (if (< x 39) (begin
    (let ((i (mandelbrot (/ x 40.0) (/ y 40.0))))
       (if (= i 0)
         (display #\*)
         (display #\ )))
    (set! x (+ x 1))(for))))
  (set! y (+ y 1))(for))))
(newline)

(define query_time (-
  (time-seconds (current-time))
  init_time))
(display "Scheme48 Elapsed ")
(display query_time)
(newline)

Mercury 0.13.1 GCC 4.3.2

:- module 'Mandelbrot_mercury'.
% mmc Mandelbrot_mercury.m -o Mandelbrot; ./Mandelbrot
% by Erik Wrenholt, ported from C to Mercury by Theo Wollenleben
:- interface.
:- import_module io.
:- pred main(io::di, io::uo) is det.
:- implementation.
:- import_module int, float, time, list, string.

:- func mandelbrot(float, float) = int.
mandelbrot(X, Y) = Return :-
    Cr = Y - 0.5,
    Ci = X,
    Zi = 0.0,
    Zr = 0.0,
    I = 0,
    Return = iterate(I, Zr, Zi, Cr, Ci).

:- func iterate(int, float, float, float, float) = int.
iterate(I, Zr, Zi, Cr, Ci) = Return :-
    BAILOUT = 16.0,
    MAX_ITERATIONS = 1000,
    I_ = I + 1,
    Temp = Zr * Zi,
    Zr2 = Zr * Zr,
    Zi2 = Zi * Zi,
    Zr_ = Zr2 - Zi2 + Cr,
    Zi_ = Temp + Temp + Ci,
    ( if Zi2 + Zr2 > BAILOUT then
        Return = I_
      else if I_ > MAX_ITERATIONS then
        Return = 0
      else Return = iterate(I_, Zr_, Zi_, Cr, Ci)
    ).


main(!IO) :-
    times(tms(Iutime, Istime, Icutime, Icstime), _, !IO),
    Init_time = Iutime + Istime + Icutime + Icstime,
    
    for_y(-39, !IO),
    io.nl(!IO),
    
    times(tms(Futime, Fstime, Fcutime, Fcstime), _, !IO),
    Query_time = Futime + Fstime + Fcutime + Fcstime - Init_time,
    io.format("Mercury Elapsed %0.2f\n",
      [f(float(Query_time)/float(clk_tck))], !IO).

:- pred for_y(int::in, io::di, io::uo) is det.
for_y(Y, !IO) :-
    if Y < 39 then
      io.nl(!IO),
      for_x(Y, -39, !IO),
      for_y(Y + 1, !IO)
    else true.

:- pred for_x(int::in, int::in, io::di, io::uo) is det.
for_x(Y, X, !IO) :-
    if X < 39 then
      I = mandelbrot(float(X)/40.0, float(Y)/40.0),
      ( if I = 0 then
          io.write_char('*', !IO)
        else
          io.write_char(' ', !IO)
      ),
      for_x(Y, X + 1, !IO)
    else true.

newLISP 10.0.2

#!/usr/bin/newlisp
by Erik Wrenholt, ported from C to newLISP by Theo Wollenleben
!#

(constant 'BAILOUT 16)
(constant 'MAX_ITERATIONS 1000)

(define (mandelbrot x y)
    (set 'cr (sub y 0.5))
    (set 'ci x)
    (set 'zi 0.0)
    (set 'zr 0.0)
    (set  'i 0)
    (catch (while true
        (inc i)
        (set 'temp (mul zr zi))
        (set 'zr2 (mul zr zr))
        (set 'zi2 (mul zi zi))
        (set 'zr (add (sub zr2 zi2) cr))
        (set 'zi (add temp temp ci))
        (if (> (add zi2 zr2) BAILOUT)
          (throw i))
        (if (> i MAX_ITERATIONS)
          (throw 0)))))


(set 'query_time (time (begin
    (for (y -39 38)
        (write-line)
        (for (x -39 38)
            (set 'i (mandelbrot (div x 40.0) (div y 40.0)))
            (if (= i 0)
                (print "*")
                (print " "))))
    (write-line))))

(print (format
    "newLisp Elapsed %0.2f\n" (div query_time 1000)))
(exit)

SWI-Prolog 5.6.59

#!/usr/bin/pl -q -O -g main -t halt -f
% by Erik Wrenholt, ported from C to SWI-Prolog by Theo Wollenleben

mandelbrot(X, Y, I_return) :-
  Cr is Y - 0.5,
  Ci is X,
  Zi is 0.0,
  Zr is 0.0,
  I is 0,
  mandelbrot_iterate(I, Zr, Zi, Cr, Ci, I_return).
  
  mandelbrot_iterate(I, Zr, Zi, Cr, Ci, I_return) :-
    BAILOUT is 16,
    MAX_ITERATIONS is 1000,
    I_ is I + 1,
    Temp is Zr * Zi,
    Zr2 is Zr * Zr,
    Zi2 is Zi * Zi,
    Zr_ is Zr2 - Zi2 + Cr,
    Zi_ is Temp + Temp + Ci,
    ( Zi2 + Zr2 > BAILOUT ->
        I_return is I_;
      I_ > MAX_ITERATIONS ->
        I_return is 0;
        mandelbrot_iterate(I_, Zr_, Zi_, Cr, Ci, I_return)
    ).

main :-
  statistics(runtime, _),
  statistics(system_time, _),
  
  for_y(-39),
  nl,
  
  statistics(runtime, [_, UTime]),
  statistics(system_time, [_, STime]),
  Query_time is (UTime + STime)/1000,
  format('Prolog Elapsed ~2f', [Query_time]), nl
  .
  
  for_y(39) :- !. for_y(Y) :-
    nl,
    for_x(Y, -39),
    Y_ is Y + 1, for_y(Y_).
    
    for_x(_, 39) :- !. for_x(Y, X) :-
      mandelbrot(X/40.0, Y/40.0, I),
      ( I = 0 ->
          write('*');
          write(' ')
      ),
      X_ is X + 1, for_x(Y, X_).

Eiffel tecomp 0.17

-- tecomp Mandelbrot_tecomp.ace
-- by Erik Wrenholt, ported from C to Eiffel by Theo Wollenleben
-- (found no time procedures for tecomp)

class
    MANDELBROT_TECOMP

create
    main

feature

    BAILOUT: REAL = 16.0
    MAX_ITERATIONS: INTEGER = 1000

    mandelbrot (x: REAL_64; y: REAL_64): INTEGER
        local
            cr, ci, zi, zr, temp, zr2, zi2: REAL_64
            i: INTEGER
        do
            cr := y - 0.5
            ci := x
            zi := 0.0
            zr := 0.0
            from  i := 0 until
                zi2 + zr2 > BAILOUT or
                i > MAX_ITERATIONS
            loop
                i := i + 1
                temp := zr * zi
                zr2 := zr * zr
                zi2 := zi * zi
                zr := zr2 - zi2 + cr
                zi := temp + temp + ci
            end
            if zi2 + zr2 > BAILOUT then
                Result := i
            end
            if i > MAX_ITERATIONS then
                Result := 0
            end
        end

    main
        local
            x, y, i: INTEGER
        do
            from y := -39 until y > 38 loop
                io.put_new_line
                from x := -39 until x > 38 loop
                    i := mandelbrot(({REAL_64}[x])/40.0, ({REAL_64}[y])/40.0)
                    if i = 0 then
                        io.put_character ('*')
                    else
                        io.put_character (' ')
                    end
                    x := x + 1
                end
                y := y + 1
            end
            io.put_new_line
        end

end

Gobo Eiffel 3.9

indexing
    description: "gec --finalize Mandelbrot.ace"
    author: "Erik Wrenholt, ported from C to Gobo Eiffel by Theo Wollenleben"

class
    MANDELBROT

inherit
    DT_SHARED_SYSTEM_CLOCK
    ST_FORMATTING_ROUTINES

create
    main

feature

    BAILOUT: REAL = 16.0
    MAX_ITERATIONS: INTEGER = 1000

    mandelbrot (x: REAL_64; y: REAL_64): INTEGER
        local
            cr, ci, zi, zr, temp, zr2, zi2: REAL_64
            i: INTEGER
        do
            cr := y - 0.5
            ci := x
            zi := 0.0
            zr := 0.0
            from  i := 0 until
                zi2 + zr2 > BAILOUT or
                i > MAX_ITERATIONS
            loop
                i := i + 1
                temp := zr * zi
                zr2 := zr * zr
                zi2 := zi * zi
                zr := zr2 - zi2 + cr
                zi := temp + temp + ci
            end
            if zi2 + zr2 > BAILOUT then
                Result := i
            end
            if i > MAX_ITERATIONS then
                Result := 0
            end
        end

    main
        local
            x, y, i: INTEGER
            init_time: DT_DATE_TIME
            query_time: REAL_64
        do
            init_time := utc_system_clock.date_time_now
            
            from y := -39 until y > 38 loop
                io.put_new_line
                from x := -39 until x > 38 loop
                    i := mandelbrot(({REAL_64}[x])/40.0, ({REAL_64}[y])/40.0)
                    if i = 0 then
                        io.put_character ('*')
                    else
                        io.put_character (' ')
                    end
                    x := x + 1
                end
                y := y + 1
            end
            io.put_new_line
            
            query_time := (utc_system_clock.date_time_now - init_time).millisecond_count/1000
            print (format ("Eiffel Elapsed $0.2f", <<double_cell (query_time)>>))
            io.put_new_line
        end

end

Last modification date: 2009-05-26
Theo Wollenleben (alpha0x89 yahoo de)


Free web hostingWeb hosting