# The Computer Language Benchmarks Game
# http://shootout.alioth.debian.org/
#
# contributed by Tupteq

import sys

def main():
    cout = sys.stdout.write
    iter =  50 
    limit =  2 .
    size = int(sys.argv[ 1 ])
    fsize = float(size)
    xr_size = xrange(size)
    xr_iter = xrange(iter)
    bit_num =  7 
    byte_acc =  0 

    cout("P4\n%d %d\n" % (size, size))

    for y in xr_size:
        fy = 2j * y / fsize - 1j
        for x in xr_size:
            z = 0j
            c =  2 . * x / fsize -  1 . 5  + fy

            for i in xr_iter:
                z = z * z + c
                if abs(z) >= limit:
                    break
            else:
                byte_acc +=  1  << bit_num

            if bit_num ==  0 :
                cout(chr(byte_acc))
                bit_num =  7 
                byte_acc =  0 
            else:
                bit_num -=  1 

        if bit_num !=  7 :
            cout(chr(byte_acc))
            bit_num =  7 
            byte_acc =  0 

main()

;;; The Computer Language Shootout
;;;   http://shootout.alioth.debian.org/
;;;
;;; resubmitted by Wade Humeniuk (Fix Stream Problem)
;;; Original contributed by Yannick Gingras <ygingras@ygingras.net>;
;;;
;;; To compile
;;; sbcl --load mandelbrot.lisp --eval "(save-lisp-and-die \"mandelbrot.core\" :purify t :toplevel (lambda () (main) (quit)))"
;;; To run
;;; sbcl --noinform --core mandelbrot.core %A

(defun render (size stream)
  (declare (type fixnum size) (stream stream)
	   (optimize (speed  3 ) (safety  0 ) (debug  0 )))
  (assert (and (<=  8  size  10000 ) (zerop (mod size  8 ))))
  (let* ((code  0 ) (bit  0 )
         (zr  0 .0d0) (zi  0 .0d0) (tr  0 .0d0)
	 (delta (/ 2d0 size))
         (base-real - 1 .5d0) (base-imag - 1 .0d0)
         (buffer (make-array (* size (ceiling size  8 )) :element-type '(unsigned-byte  8 )))
         (index  0 ))
    (declare (type (unsigned-byte  8 ) code)
             (type double-float zr zi tr base-real base-imag delta)
             (type fixnum index bit))

    (dotimes (y size)
      (setf base-imag (-  1 .0d0 (* delta y)))
      (dotimes (x size)
	(declare (fixnum x))
	(setf base-real (+ - 1 .5d0 (* delta x))
	      zr base-real
	      zi base-imag)
        (setf code (logior (ash code  1 )
			   (if (dotimes (n  50 )
				 (when (<  4 .0d0 (+ (* zr zr) (* zi zi)))
				   (return t))
				 (setf tr (+ (* zr zr) (- (* zi zi)) base-real)
				       zi (+ (*  2 .0d0 zr zi) base-imag)
				       zr tr))
			       #x00
			       #x01)))
	(when (= (incf bit)  8 )
	  (setf (aref buffer index) code
		bit  0  code  0 )
	  (incf index))))

    (write-sequence buffer stream)))

(defun main ()
  (declare (optimize (speed  0 ) (safety  3 )))
  (let* ((args sb-ext:*posix-argv*)
	 (n (parse-integer (second args))))
    (with-open-stream (stream (sb-sys:make-fd-stream (sb-sys:fd-stream-fd sb-sys:*stdout*)
						     :element-type :default
						     :buffering :full
						     :output t :input nil))

      (format stream "P4~%~d ~d~%" n n)
      (render n stream)
      (force-output stream))))

{-# OPTIONS -fexcess-precision #-}
--
-- The Computer Language Shootout
-- http://shootout.alioth.debian.org/
--
-- Contributed by Spencer Janssen, Trevor McCort, Christophe Poucet and Don Stewart
--
-- Must be compiled with the -fexcess-precision flag as a pragma. GHC
-- currently doesn't recognise the -fexcess-precision flag on the command
-- line (!).
--
-- The following flags are suggested when compiling:
--
--      -O -fglasgow-exts -optc-march=pentium4
--      -fbang-patterns -funbox-strict-fields -optc-O2 -optc-mfpmath=sse -optc-msse2
--

import System
import System.IO
import Foreign
import Foreign.Marshal.Array

main = do
    w <- getArgs >>= readIO . head
    let n      = w `div`  8 
        m  =  2  / fromIntegral w
    putStrLn ("P4\n"++show w++" "++show w)
    p <- mallocArray0 n
    unfold n (next_x w m n) p (T  1   0   0  (- 1 ))

unfold :: Int -> (T -> Maybe (Word8,T)) -> Ptr Word8 -> T -> IO ()
unfold !i !f !ptr !x0 = loop x0
  where
    loop !x = go ptr  0  x

    go !p !n !x = case f x of
        Just (w,y) | n /= i -> poke p w >> go (p `plusPtr`  1 ) (n+ 1 ) y
        Nothing             -> hPutBuf stdout ptr i
        _                   -> hPutBuf stdout ptr i >> loop x
{-# NOINLINE unfold #-}

data T = T !Int !Int !Int !Double

next_x !w !iw !bw (T bx x y ci)
    | y  == w   = Nothing
    | bx == bw  = Just (loop_x w x  8  iw ci  0 , T  1   0     (y+ 1 )   (iw+ci))
    | otherwise = Just (loop_x w x  8  iw ci  0 , T (bx+ 1 ) (x+ 8 ) y ci)

loop_x !w !x !n !iw !ci !b
    | x < w = if n ==  0 
                    then b
                    else loop_x w (x+ 1 ) (n- 1 ) iw ci (b+b+v)
    | otherwise = b `shiftL` n
  where
    v = fractal  0   0  (fromIntegral x * iw -  1 . 5 ) ci  50 

fractal :: Double -> Double -> Double -> Double -> Int -> Word8
fractal !r !i !cr !ci !k
    | r2 + i2 >  4  =  0 
    | k ==  0       =  1 
    | otherwise   = fractal (r2-i2+cr) ((r+r)*i+ci) cr ci (k- 1 )
  where
    (!r2,!i2) = (r*r,i*i)

Простейший пример:
(defmacro simple-plus-macro (a b)
`(+ ,a ,b))

Если вставим его в программу вроде:
(setf c (simple-plus-macro  4   5 )) то после раскрытия макроса будет компилироваться следующий код:

(setf c (+  4   5 ))

Одна из мощнейших особенностей макросов Лиспа заключается в том, что в них доступен весь язык и ранее определенные функции:

(defun factorial (x)
(if (<= x  1 )  1  (* x (factorial ( 1 - x))))

(defmacro with-factorial ((var argument) &body body)
`(let ((,var ,(factorial argument)))
,@body))

После этого мы можем в коде написать:
(with-factorial (myvar  5 )
(format t "Factorial of 5 is ~D~%" myvar))

значение факториала  5  будет посчитано и присвоено переменной myvar во время компиляции.

А можно, используя reader macros и так написать:
(format t "Factorial of 5 is ~D~%" #.(factorial  5 ))

Значение факториала будет посчитано прямо во время разбора этой строки (до компиляции) и вставлено в код в этом месте.

Для того чтобы это сделать в С++ потребовалось бы писать шаблонный код на языке шаблонов, а не на самом С++. А в Лиспе макрос может пользоваться любыми ранее определенными или даже на ходу определенными функциями.

(with-factorial (myvar  500 )
(format t "Factorial of 500 is ~D~%" myvar))