Can someone help me translate the following SBCL (or Common Lisp) script to newLISP?
I'm presenting at a conference and interested in showing benchmarks between a bunch of different languages (including some Lisp, Scheme, Python, C, etc).
(declaim (optimize (speed 3)))
(defconstant +BAILOUT+ 16)
(defconstant +MAX-ITERATIONS+ 1000)
(defun mandelbrot (x y)
(declare (type single-float x y))
(let ((cr (- y 0.5))
(ci x)
(zi 0.0)
(zr 0.0))
(declare (type single-float cr ci zi zr))
(do ((i 0 (incf i)))
(nil)
(let* ((temp (the single-float (* zr zi)))
(zr2 (the single-float (* zr zr)))
(zi2 (the single-float (* zi zi))))
(declare (type single-float temp zr2 zi2)
(type fixnum i))
(setq zr (the single-float (+ (- zr2 zi2) cr)))
(setq zi (the single-float (+ temp temp ci)))
(if (> (the single-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 single-float (/ x 40.0))
(the single-float (/ y 40.0)))))
(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))
;newLISP v.10.0.0
;on Win32 IPv4 UTF-8
(import "kernel32.dll" "GetTickCount")
(set 'BAILOUT 16)
(set 'MAX_ITERATIONS 1000)
(define (iterate x y)
(let ((cr (sub y 0.5))
(ci x)
(zi 0.0)
(zr 0.0)
(i 0))
(while 1
(inc i 1)
(set 'temp (mul zr zi))
(set 'zr2 (mul zr zr))
(set 'zi2 (mul zi zi))
(set 'zr (add cr (sub zr2 zi2)))
(set 'zi (add temp temp ci))
(if (> (add zi2 zr2) BAILOUT)
(throw i))
(if (> i MAX_ITERATIONS)
(throw 0)))))
(define (mandelbrot)
(let ((t (GetTickCount)))
(for (y -39 38)
(for (x -39 38)
(set 'j (catch (iterate (div x 40.0) (div y 40.0))))
(if (= j 0.0)
(print "*")
(print " ")))
(print "n"))
(println "Time Elapsed: " (- (GetTickCount) t))))
(mandelbrot)
faster: http://www.newlisp.org/mandelbrot.cgi
benchmarks: http://www.newlisp.org/benchmarks/
I do not use Windows.
When I look at "GetTickCount" the reference reads, "Retrieves the number of milliseconds that have elapsed since the system was started, up to 49.7 days."
Seems like a simple (date-value) in newLISP can do the same thing, with a few modifications?
New code:
Quote
(define (GetTickCount)
(date-value)
)
The problem (as Lutz says later) is that this code is SLOW compared to the same code in other languages. In fact, this example in newLISP is even slower than Python, which is impressive. :)
Quote from: "wandernet"
;newLISP v.10.0.0
;on Win32 IPv4 UTF-8
(import "kernel32.dll" "GetTickCount")
(date-value) gives only seconds of resolution, better use (time-of-day), which has at least milliseconds resolution and on modern Unix systems micro seconds of resolution.
Perhaps the Python uses built-in complex numbers...
I thought Michael's complex version was more fun:
(r 0)
(i 0))
(list complex r i))
(define (complex:rad)
(set 're (self 1) 'im (self 2))
(sqrt (add
(mul re re)
(mul im im))))
(define (complex:theta)
(atan (div
(self 1)
(self 2))))
(define (complex:add b)
(complex (add
(self 1)
(b 1))
(add
(self 2)
(b 2))))
(define (complex:mul b)
(set 'a.re (self 1)
'a.im (self 2)
'b.re (b 1)
'b.im (b 2))
(complex
(sub
(mul a.re b.re)
(mul a.im b.im))
(add
(mul a.re b.im)
(mul a.im b.re))))
(define (mandelbrot)
(for (y -2 2 0.02)
(for (x -2 2 0.02)
(inc counter)
(set 'z (complex x y) 'c 126 'a z)
(while (and
(< (abs (:rad (set 'z (:add (:mul z z) a)))) 2)
(> (dec c) 32)))
(print (char c)))
(println)))
(mandelbrot)
Also, why use multiple calls to 'set when one will do?
cheers
tim
And a single call to
(define (test-multiple)
(set 'a 1)
(set 'b 2)
(set 'c 3)
(set 'd 4)
(set 'e 5)
(set 'f 6)
(set 'g 7)
)
(time (test-once) 1000000) ;=> 447.211
(time (test-multiple) 1000000) ;=> 609.038
m i c h a e l
I'll buy that one. I wonder if differences would change with more complex data types?
thanks
tim
Regarding the set thing... I've actually done the same benchmarks, and they've affected how I decide to use set or setf.
Basically, I've found that setf is faster for situations where only 1 variable needs to be set, but if you're setting multiple things in a row, set is faster (if called once for all of them).
It's a really insignificant difference on its own, but I figure if I make that a convention the times will eventually add up to something meaningful since set is called so much. newlisp makes it easy to microbenchmark, and so you can adjust your coding style to always use the faster version, and eventually I figure the entire program benefits from the lots-of-minor-performance-increases.
The idea of using one call to
with multiple symbol/value pairs
versus
multiple calls to
with just one symbol/value pair for each call
appeals to my aversion to redundancy.
I should have some time in the next few days to run some more complex tests where
the variables are something other than integers.
thanks
tim
Quote from: "Tim Johnson"
with multiple symbol/value pairs
versus
multiple calls to
with just one symbol/value pair for each call
appeals to my aversion to redundancy.
I don't understand, why "but"? His test code shows it's better to use one call.
Quote
I don't understand, why "but"? His test code shows it's better to use one call.
Oh for Pete's Sake, you're right, my brain has been AWOL these couple of days!
I misread the results.
thanks
tim
(define (test-setf-multiple)
(setf a 1)
(setf b 2)
(setf c 3)
(setf d 4)
(setf e 5)
(setf f 6)
(setf g 7)
)
(println (time (test-setf-once) 1000000)) ;=> 372.934
(println (time (test-setf-multiple) 1000000)) ;=> 507.426
Curious.
m i c h a e l
Michael, I've never used
Quote
but I see from my own console:
> (setf a 1)
1
> a
1
Curiouser and curiouser
Quote from: "Tim"
I don't normally use
Quote from: "newLISP Manual & Reference"
I wonder if there's a good reason to
(define (test-setq-multiple)
(setq a 1)
(setq b 2)
(setq c 3)
(setq d 4)
(setq e 5)
(setq f 6)
(setq g 7)
)
(time (test-setq-once) 1000000) ;=> 381.148
(time (test-setq-multiple) 1000000) ;=> 525.763
So it looks like both
m i c h a e l
Quote from: "m i c h a e l"
I don't think setq should be used at all, there's no reason for it as it's just an alias for setf (which is why you're seeing those results), and included for compatibility with old code.
I originally thought set was faster than setf for multiple assignments, but it seems like I must have made a mistake in those benchmarks, so setf is faster for everything. So, I don't know about you, but for consistency and speed I'm going to use setf for everything (unless I explicitly need to set on a symbol, which happens often enough, in which case there's no choice but to use set).
setq setf !
syntax: (setq place-1 exp-1 [place-2 exp-2 ... ])
setq and setf work alike in newLISP and set the contents of a symbol, list, array or string or of a list, array or string place reference. Like set, setq and setf can take multiple argument pairs. Although both setq and setf point to the same built-in function internally, throughout this manual setq is used when setting a symbol reference and setf is used when setting list or array references.
-- xytroxon
Yes, though the manual does use that convention for some reason, I don't see the point. I see it as adding confusion to my code and giving me one more thing to have to worry about (should I use setf or setq here?). There's no reason to burden yourself with unnecessary complexity.
Here's one more way to set variables:
1
> a
1
> _
Of course,
m i c h a e l