scheme vs lisp, scientific computing
Tamas K Papp
I am a newbie in need of advice.
A bit of background: I am an economist (currently in graduate school),
and have been programming since my teenage years (C, a bit of C++, and
for the past 5 years, R, which is a nice but not purely functional
language with C-like syntax). I am realizing the shortcomings of R now
(especially when compared to Scheme/Lisp), and would like to learn
either or both of the latter.
Questions:
1. Scheme or Lisp? While they are different languages, they also seem
similar, especially when compared to other languages. I might want to
learn both in the future, but which one should I start with? I would
not use it for anything critical for a while, but it is important that
I can implement small things after a while, because I need that to
sustain my enthusiasm in learning something new. To what extent does
knowledge of one language convert into the other one? Should I learn
Common Lisp or Scheme first?
2. I have noticed that there are some Scheme compilers. I find the
idea intriguing: I like interpreted languages (flexible, quick
development), but compiling finalized code would be a huge bonus in
numerical applications. What is the factor of speed improvement when
compiling (approximately, of course, I expect it varies with the
application).
3. Do people use Sheme for numerical applications? Do they have
libraries for multivariate optimization, nonlinear equation solving,
matrix operations etc? In most other languages, this is just glue to
Atlas/BLAS, is it done that way in Scheme?
4. Does Scheme have a library to produce nice (2d) graphs?
Thank you,
Tamas
Brandon J. Van Every
Tamas K Papp wrote:
> Hi,
>
> I am a newbie in need of advice.
>
> A bit of background: I am an economist (currently in graduate school),
> and have been programming since my teenage years (C, a bit of C++, and
> for the past 5 years, R, which is a nice but not purely functional
> language with C-like syntax). I am realizing the shortcomings of R now
> (especially when compared to Scheme/Lisp), and would like to learn
> either or both of the latter.
>
> Questions:
>
> 1. Scheme or Lisp? While they are different languages, they also seem
> similar, especially when compared to other languages. I might want to
> learn both in the future, but which one should I start with?
It doesn't matter.
> I would not use it for anything critical for a while,
Especially because you say this.
> but it is important that
> I can implement small things after a while, because I need that to
> sustain my enthusiasm in learning something new.
This is pretty much up to you.
> To what extent does
> knowledge of one language convert into the other one? Should I learn
> Common Lisp or Scheme first?
It doesn't matter. Quit worrying. You're overthinking it.
> 2. I have noticed that there are some Scheme compilers.
There are Common Lisp compilers as well. I chose the Chicken
Scheme-to-C compiler
http://www.call-with-current-continuation.org
because there are no well-supported open source Common Lisp compilers
on Windows. SBCL may soon be fully ported to Windows, but it isn't
ready for prime time yet. I also spent time with the Bigloo
Scheme-to-C compiler. I ditched it in favor of Common Lisp, thinking
I'd get more universality that way, but it turned out that for C
foreign function interfaces, every Lisp implementation is a right unto
itself. There's nothing "Common" about it. This is no different than
the Scheme universe, and good open source Scheme compilers were
available on Windows. I went for Chicken over Bigloo, trading some
performance for a slightly larger community and some C++ support.
Also I got the opportunity to move the build system to CMake, which
unlike Autoconf can target VC++ and other compilers nicely. I'm happy
to say I think I've crushed the last major bug in the CMake build, and
it seems ready to be used. But it hasn't been widely tested yet so I'm
not quite ready to officially announce it.
> I find the
> idea intriguing: I like interpreted languages (flexible, quick
> development), but compiling finalized code would be a huge bonus in
> numerical applications.
Chicken has an interpreter as well. So do other Schemes, although you
can't categorically assume that both a compiler and interpreter is
available, nor that they're symmetric in functionality.
> What is the factor of speed improvement when
> compiling (approximately, of course, I expect it varies with the
> application).
If you study the erstwhile Shootout benchmarks, you'll see that all
interpreted languages fall in roughly the same clump, all compiled
languages fall in roughly the same clump, and that there's a
significant separation between the two clumps. More precise than this,
I cannot say. Benchmarks are always full of "Your Mileage May Vary"
caveats.
> 3. Do people use Sheme for numerical applications? Do they have
> libraries for multivariate optimization, nonlinear equation solving,
> matrix operations etc?
Yeah, some people do that and I imagine they'll pipe up.
> In most other languages, this is just glue to
> Atlas/BLAS, is it done that way in Scheme?
I believe so. Scheme is just a language, not a numerical computation
standard.
> 4. Does Scheme have a library to produce nice (2d) graphs?
Various Common Lisps and Schemes have bindings to SDL, which may or may
not fulfil your needs. People like myself endeavor to do 2D through
OpenGL. Various OpenGL bindings are of various quality. People often
let the bindings rot for lack of use.
The truth is you live or die by your implementation. It's not really
about Scheme or Common Lisp. It's about what implementation of either
language has the most libraries and proven utility for your problem
domain. If I were you, I'd go with a Common Lisp or Scheme that has
both a compiler and an interpreter, and see what scientific software is
readily available for that implementation. Sure you can port stuff
between different implementations, but it's a PITA and stands in the
way of getting real work done. It's better to leverage any epicenters
of scientific programming, if such there are.
Cheers,
Brandon Van Every
Pascal Bourguignon
> Hi,
>
> I am a newbie in need of advice.
>
> A bit of background: I am an economist (currently in graduate school),
> and have been programming since my teenage years (C, a bit of C++, and
> for the past 5 years, R, which is a nice but not purely functional
> language with C-like syntax). I am realizing the shortcomings of R now
> (especially when compared to Scheme/Lisp), and would like to learn
> either or both of the latter.
Have a look at maxima and axiom:
http://maxima.sourceforge.net/
http://wiki.axiom-developer.org/FrontPage
--
__Pascal Bourguignon__ http://www.informatimago.com/
THIS IS A 100% MATTER PRODUCT: In the unlikely event that this
merchandise should contact antimatter in any form, a catastrophic
explosion will result.
William James
Tamas K Papp wrote:
> Hi,
>
> I am a newbie in need of advice.
>
> A bit of background: I am an economist (currently in graduate school),
> and have been programming since my teenage years (C, a bit of C++, and
> for the past 5 years, R, which is a nice but not purely functional
> language with C-like syntax). I am realizing the shortcomings of R now
> (especially when compared to Scheme/Lisp), and would like to learn
> either or both of the latter.
>From the R FAQ:
The design of R has been heavily influenced by two existing languages:
Becker, Chambers & Wilks' S (see What is S?) and Sussman's Scheme.
Whereas the resulting language is very similar in appearance to S, the
underlying implementation and semantics are derived from Scheme.
Edu
Tamas K Papp escreveu:
> Hi,
> Questions:
>
> 1. Scheme or Lisp? While they are different languages, they also seem
> similar, especially when compared to other languages. I might want to
> learn both in the future, but which one should I start with?
>
> 2. I have noticed that there are some Scheme compilers. I find the
> idea intriguing: I like interpreted languages (flexible, quick
> development), but compiling finalized code would be a huge bonus in
> numerical applications.
> 3. Do people use Sheme for numerical applications?
> 4. Does Scheme have a library to produce nice (2d) graphs?
Hi, Tamas.
Here is my bit of background, so you can put my answers in context: I
also work with number crunching from time to time. My PhD is from
Cornell, my major was in Space Science, with minors in Applyed Physics,
Mathematics and Ancient Greek. I have been working with OCAML and Clean
for the last five years or so; both languages are functional, and quite
similar to Scheme. Not long ago, I decided to switch to Scheme in order
to increase my productivity as a programmer, and also because Scheme
community is very nice. People have been saying in this list how nice
is to work with Felix (Chicken Scheme) and Manuel Serrano (Bigloo). I
would like to add that I also received prompt attention from Marc
Feeley and Shriram Krishnamurthi and Matthew Flatt (PLT). In fact, it
would be harder to say who was nicer. Now, I will try to answer your
questions.
1- Scheme or Lisp? Scheme absolutely.
3. Do people use Scheme for numerical applications? Yes! Appart from
myself, W. Farr has many interesting numerical applications in Bigloo.
You will find him in the Bigloo list.
4. Does Scheme have a library to produce nice (2d) graphs? Of course,
and also 3D graphs, or 3D animations using open GL. Scheme is used as
script language for many famous graphic packages, scientific text
editors and Computer Algebra packages, like Gimp, CICS and TeXmacs
(http://www.texmacs.org/). You can also use bindings to famous plotting
tools, like Ploticus (http://ploticus.sourceforge.net/doc/welcome.html)
and Cairo.
Now, I will give you some guidance on choosing a Scheme. It is hard,
because all of them are very good. However, if you need raw number
crunching capability and speed, Bigloo is your choice. It produces
tight and speedy code; Bigloo is stingy and fast! Belive me, if you
write your code in Bigloo, your colleagues who are working in Fortran
or C will need to run for the catch. It is not easy to beat Bigloo,
even if you try to squeeze a few microseconds coding in C. What is
more, it is very easy to bind Bigloo code to C. But I heard (inside
information) that Chicken team is working a special tool to speed up
number crunching modules. It will not be easy for Bigloo to keep ahead
in this domain... By the way, Bigloo philosophy is to generate code as
close as possible to the code generated by a C compiler, both for speed
and easiness of binding Scheme code to external libraries. Bigloo
runtime dynamic libraries are somewhat large, but not excessively so;
you will need to pack and dispatch 2 Megabytes with your system. As for
user graphic interface, you can use Jeremy Shute/Peter van Eeerten GTK
bindings, that are straightforward to install and use; you can also
create bindings to ploticus. It easy to use Bigloo with Ploticus
(straightforward woud be the right term), or even Cairo.
If you want easy of distribution, good interface to C libraries,
immediate access to all famous GUI libraries, bindings to plotting
programs like plotticus and cairo, then Chicken is unbeatable. Of
course, Biglooers are playing catch, and they are good. I don't know
how long Chicken will succeed in staying ahead of the pack in this
matter. You can compile Chicken in such way that it does not need any
runtime apart from msvc (Windows) or widely available libraries (in
Linux). A program without GUI and graphics requires a pack of no more
than 500 K, before zipping. You can get a great Graphic User interface
plus your code in less than 1.5 Megabytes. For raw number crunching,
Chicken is about 30% slower than Bigloo, but perhaps you are willing to
pay this price for a tool that is easy to pack, easy to distribute,
easy to install, and easy to use. Chicken is friendly!
My choice? I am having a hard time in choosing between such great tools
like Chicken, Bigloo and Gambit-C. But you know, I am fascinated by
speed, bench marks, etc. Therefore I am still flying around the light
of Bigloo. But when Chicken team finish their number crunching tool,
well, I don't know.
Edu500ac
>
> Tamas
Rob Thorpe
> Tamas K Papp wrote:
> > 2. I have noticed that there are some Scheme compilers.
>
> There are Common Lisp compilers as well. I chose the Chicken
> Scheme-to-C compiler
> http://www.call-with-current-continuation.org
> because there are no well-supported open source Common Lisp compilers
> on Windows. SBCL may soon be fully ported to Windows, but it isn't
> ready for prime time yet. I also spent time with the Bigloo
> Scheme-to-C compiler. I ditched it in favor of Common Lisp, thinking
> I'd get more universality that way, but it turned out that for C
> foreign function interfaces, every Lisp implementation is a right unto
> itself. There's nothing "Common" about it. This is no different than
> the Scheme universe, and good open source Scheme compilers were
> available on Windows. I went for Chicken over Bigloo, trading some
> performance for a slightly larger community and some C++ support.
As a sidenote..
At present the MS Windows support of GCL, ECL and CLISP is better than
that of SBCL. SBCL is still experimental on Windows. That's my
experience of running the current versions of all four on a Windows
machine.
As you say interfacing is painful and non-standard.
These things may change when the SBCL port is finished.
Tamas K Papp
Brandon.
Edu:
1) what do you use to make vector graphics in Scheme (eg eps files to
insert into papers).
and
2) is there a good random number generation library for Bigloo or
Chicken? I need to get random numbers from various distributions for
MCMC (Markov Chain Monte Carlo, but I guess that being a physicist you
know what that is). I can always use transformations or reimplement an
existing RNG (or even link to R's random functions from C) but it would
be nice to have it written.
How should I start learning Scheme? I have quite a bit of programming
experience, but not the scheme way (mostly imperative languages, like C
and R). Should I start with HTDP, or The Scheme Programming Language?
Thanks,
Tamas
zitterb...@gmail.com
http://www.call-with-current-continuation.org/eggs/srfi-27.html then
that is a random number "library" for chicken scheme.
Brandon J. Van Every
Rob Thorpe wrote:
> Brandon J. Van Every wrote:
> > Tamas K Papp wrote:
> > > 2. I have noticed that there are some Scheme compilers.
> >
> > There are Common Lisp compilers as well. I chose the Chicken
> > Scheme-to-C compiler
> > http://www.call-with-current-continuation.org
> > because there are no well-supported open source Common Lisp compilers
> > on Windows. SBCL may soon be fully ported to Windows, but it isn't
> > ready for prime time yet.
>
> At present the MS Windows support of GCL, ECL and CLISP is better than
> that of SBCL. SBCL is still experimental on Windows. That's my
> experience of running the current versions of all four on a Windows
> machine.
My definition of "support" includes editors and adherance to CL
standards. In these respects GCL is not well supported on Windows,
although it is a compiler. CLISP is very well supported, but is not a
-to-C or -to-native-code compiler. I didn't quite give ECL a fair
shake, as its build system didn't look terribly Windows oriented, but I
also wasn't encountering much on my Google radar to indicate "first
class" Windows support. So with ECL YMMV.
> As you say interfacing is painful and non-standard.
Yeah, so if interfacing to C is going to be non-standard, it should at
least be easy and good. That is obtained with both Chicken Scheme and
Bigloo Scheme.
> These things may change when the SBCL port is finished.
By then I'll be a fullblown Chicken Scheme expert with no incentive to
change. Absent a lucrative contract.
Cheers,
Brandon Van Every
Edu
I will start with the easy question. Is there a good random number
generation library for Bigloo or Chicken? Both languages have complete
communication with C. Then the answer is: Keep enjoying the same C or
Fortran libraries that you are used to, even after migrating to Scheme.
There is no gain in porting these libraries to Scheme. Since I am in a
project to create vector graphics in Scheme (type setting electronic
circuits, drawing chemical structural formulae, etc.) I decided to use
Peter van Eerten's GTK2/DLL. You probably think that it took me a lot
of work to create bindings to Peter's excellent library, written in C.
Well, all I had to do is to add one single line to a Bigloo module:
(extern (macro gtk::string (::string) "gtk"))
That gave me full access to the GTK2 library, written in C, and to
Peter's GTK-server as well. By the way, I will make available my Bigloo
bindings to Peter's GTK2/DLL both at the site of Bigloo, and at the
site of the GTK-server. This will happen pretty soon, but if you cannot
wait, or do not want to wait, contact me, and I will send you the
bindings with a few examples of vector graphics.
I will show you how easy is to call a function written in C (or Java,
or C#) from Scheme. I wrote a small program in C. Here it is:
long
fib(long n){
if (n<2) {return 1;}
else {return(fib(n-1)+fib(n-2));}}
The Scheme program that you see below reads the command line, checks
whether it is an integer, print error messages if this is not the case,
and applies the C function if the number is correctly formed. You must
agree with me that even that simple program would be quite difficult
to write in a language other than Scheme. For instance, I use the
result of converting the string argument to integer to decide whether I
will apply the C function or not. Cute, isn't it?
(module sch-side
(main start)
(extern (fib::long (::long) "fib")))
(define (start argv)
(cond ( (null? (cdr argv)) (print "Usage: fib 5"))
( (string->number (cadr argv))
(print (fib (string->number (cadr argv)))))
(else (print "Usage: fib 5"))))
The example shows that you can keep using all legacy libraries, written
in C, Fortran, you name it. LAPACK, BLAS, GTK2 everything is available
to the Bigloo programmer. The interesting point is that it is easier to
use these libraries from Scheme, than from their native languages! I
know an electric engineer who used one of these libraries to perform
number crunching, and did not even noticed that he was not using a
native Scheme library.
Tamas K Papp escreveu:
Rob Thorpe
> Rob Thorpe wrote:
> > Brandon J. Van Every wrote:
> > > Tamas K Papp wrote:
> > > > 2. I have noticed that there are some Scheme compilers.
> > >
> > > There are Common Lisp compilers as well. I chose the Chicken
> > > Scheme-to-C compiler
> > > http://www.call-with-current-continuation.org
> > > because there are no well-supported open source Common Lisp compilers
> > > on Windows. SBCL may soon be fully ported to Windows, but it isn't
> > > ready for prime time yet.
> >
> > As a sidenote..
> > At present the MS Windows support of GCL, ECL and CLISP is better than
> > that of SBCL. SBCL is still experimental on Windows. That's my
> > experience of running the current versions of all four on a Windows
> > machine.
>
> My definition of "support" includes editors and adherance to CL
> standards. In these respects GCL is not well supported on Windows,
Well, for info the ANSI Commom Lisp version of GCL works on Windows.
(Which is more than can be said for Linux).
> although it is a compiler. CLISP is very well supported, but is not a
> -to-C or -to-native-code compiler.
Ah, missed that.
> I didn't quite give ECL a fair
> shake, as its build system didn't look terribly Windows oriented, but I
> also wasn't encountering much on my Google radar to indicate "first
> class" Windows support. So with ECL YMMV.
In the rare moments I use CL on Windows I use ECL. It may not be as
fast or as standards compliant as SBCL but it doesn't say "You're
Kitten of Death Awaits" when I start it up, so I have a bit more
confidence in it's stability.
Förster vom Silberwald
Tamas K Papp wrote:
> I would like to thank everybody for the answers, especially Edu and
> Brandon.
>
> Edu:
> 1) what do you use to make vector graphics in Scheme (eg eps files to
> insert into papers).
> and
> 2) is there a good random number generation library for Bigloo or
> Chicken? I need to get random numbers from various distributions for
> MCMC (Markov Chain Monte Carlo, but I guess that being a physicist you
> know what that is). I can always use transformations or reimplement an
> existing RNG (or even link to R's random functions from C) but it would
> be nice to have it written.
I can offer you the following:
a) a very good binding to the high plotting library DISLIN:
==
(module main
(library plot)
(include "./dislin_wrap.sch")
(export (dislin-fun-surfcp::float ::float ::float ::int))
(extern (export dislin-fun-surfcp "dislin_fun_surfcp")) )
(define (ex-styles)
(let ((ctit1 "Demonstration of CURVE")
(ctit2 "Line Styles")
(ctyp (list "SOLID" "DOT " "DASH" "CHNDSH"
"CHNDOT" "DASHM" "DOTL " "DASHL"))
(x (list 3. 9.))
(y (list 0. 0.))
(nx 0) (ny 0))
(dislin-x11mod "store")
(dislin-metafl "cons")
(dislin-setpag "da4p")
(dislin-disini)
(dislin-pagera)
(dislin-complx)
(dislin-center)
(dislin-chncrv "BOTH")
(dislin-name "X-axis" "X")
(dislin-name "Y-axis" "Y")
(dislin-titlin ctit1 1)
(dislin-titlin ctit2 3)
(dislin-graf 0. 10. 0. 2. 0. 10. 0. 2.)
(dislin-title)
;;
(do ((i 0 (+ i 1)))
((= i 8))
(list-set! y 0 (- 8.5 i))
(list-set! y 1 (- 8.5 i))
(set! nx (dislin-nxposn 1.0))
(set! ny (dislin-nyposn (list-ref y 0)))
(dislin-messag (list-ref ctyp i) nx (- ny 20))
(dislin-curve x y 2))
(dislin-disfin)))
etc.
==
b) a basic binding to the rng stream library from Pierre L'Ecuyer,
University of Montreal:
==
(module testRngStream
(import (RngStreamBigloo "RngStreamBigloo.scm")))
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; testRngStream.c
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(define sum 0.0)
(define sum3 0.0)
(define sumi 0)
(define gar (make-vector 4))
(define germe (vec2ulong* (vector 1 1 1 1 1 1)))
(define g1 (RngStream_CreateStream "g1"))
(define g2 (RngStream_CreateStream "g2"))
(define g3 (RngStream_CreateStream "g3"))
(set! sum (+ (RngStream_RandU01 g2)
(RngStream_RandU01 g3)))
(print (acc-info-state g2))
(print (acc-info-state g3))
(RngStream_AdvanceState g1 5 3)
(set! sum (+ sum
(RngStream_RandU01 g1)))
etc.
==
c) a binding to the Mie scattering code from the scatter lib.
Nonetheless to say: the bindings are available for Linux and Mac OSX
and last but not least Bigloo.
At the moment I am using Bigloo and the rng-stream binding for doing
Monte Carlo search algorithms in atmospheric sciences (aerosols and
radiative transfer through the atmosphere).
Btw: It would be cool to have a binding to the gnu scientific library.
I had my hands on it some months ago. However, Bigloo its
cigloo-program did not work well. Lately there have been some updates
to Bigloo its cigloo. It would be interesting to see whether it now can
cope with gsl its insane C type model.
Schneewittchen
Brad Lucier
>Is there a good random number
> generation library for Bigloo or Chicken? Both languages have complete
> communication with C. Then the answer is: Keep enjoying the same C or
> Fortran libraries that you are used to, even after migrating to Scheme.
The base random number generator specified in SRFI-27 is better than in
most random number libraries in C. In fact, it's better than the
TR1-specified generator for C++, but there is a C++ implementation of
the algorithms in SRFI-27 from Pierre L'Ecuyer's web site (reference
at the SRFI 27 documentation). It has the special property that one
can run independent experiments, each with independent streams of
random variates.
I recommend this SRFI highly. It also has some simple code for, e.g.,
generating normal variates and exponential variates, etc., from the
basic uniform generator.
Brad
Keith H Duggar
> Edu wrote:
> >Is there a good random number
> > generation library for Bigloo or Chicken? Both languages
> > have complete communication with C. Then the answer is:
> > Keep enjoying the same C or Fortran libraries that you
> > are used to, even after migrating to Scheme.
>
> The base random number generator specified in SRFI-27 is
> better than in most random number libraries in C.
Interesting statement considering that probably almost every
prng has been implemented at some point in C in some library.
> In fact, it's better than the TR1-specified generator for
> C++
IIRC TR1 does not "specify" a particular generator. Rather
it specifies requirements and gives a particular /example/
which meets those requirements.
> but there is a C++ implementation of the algorithms in
> SRFI-27 from Pierre L'Ecuyer's web site (reference at the
> SRFI 27 documentation).
Yes and there are C++ implementations of "better" generators
some of which would be difficult to implement efficiently in
Scheme given their extensive use of bit twiddling.
> It has the special property that one can run independent
> experiments, each with independent streams of random
> variates.
What precisely do you mean by that? What class of generators
is /not/ capable of providing "independent" streams? How are
CMRRNGs "special" is this regard? But yes, SRFI-27 is a
reasonably good choice for a "default" generator.
> I recommend this SRFI highly. It also has some simple
> code for, e.g., generating normal variates and exponential
> variates, etc., from the basic uniform generator.
Simple but quite "slow" given the use of transcendentals.
Given that Tamas mentioned both performance and MCMC he
probably will care about speed at some point; and at that
time he should look into faster methods for generating
non-uniform deviates. Also given the MCMC he would do well
to consider generators with periods even longer than SRFI-27.
-- Keith --