Scheming

Loop-Unrolling Macros in Clojure

2010-06-04T18:30:00.003-04:00

I've been fooling around with clojure a bit lately. Something fun: a dotimes-like macro, but it completely unrolls your loop at compile time: (defmacro dotimes-unroll "Just like dotimes, but completely unrolls the given loop. The number of iterations must read as a number." [[i n] & body] (assert (number? n)) (if (= n 0) `nil `(let [~i ~(- n 1)] (dotimes-unroll [~i ~(- n

Distribution for the Ratio of Two Uniform Deviates

2010-03-04T17:47:00.003-05:00

Weird: the distribution for the ratio of two uniform deviates is constant for ratios smaller than 1, and falls like r^2 for larger ratios. p(r) = 1/2 if r < 1, and 1/(2r^2) if r >= 1 when r = a/b, where a,b ~ U(0, A). What's up with that?

Another Library: 1-D Root Finding in Ocaml

2010-01-09T22:36:00.002-05:00

...and here's another library for 1-D root finding (non-linear equation solving) in OCaml. Get it with git clone git://github.com/farr/ocaml-solve.git I'm particularly proud of this one for two reasons: All the algorithms, even the ones requiring derivatives, use bracketing. If a step in the algorithm would fall outside the brackets for the root, the algorithms perform a bisection step

Polynomials in OCaml

2010-01-09T18:12:00.003-05:00

I just posted some code on GitHub to manipulate polynomials in one variable in OCaml. It's pretty simplistic, and only works for polynomials whose coefficients are floating-point real numbers (so beware of roundoff error!), but I have found it to be useful in many quick-and-dirty situations. To grab it, use git clone git://github.com/farr/ocaml-poly.git

Profiling Using MzScheme and Errortrace

2009-01-08T13:13:00.005-05:00

Lately I've needed to do some profiling in PLT Scheme, and the usual process in DrScheme hasn't been working for me. If you don't know, here's the usual process: Language --> Choose Language Show Details Debugging and Profiling Run Program View --> Show Profile Robby suggested using the errortrace library directly from mzscheme. It worked perfectly. Here's how you can duplicate my success

Interpolation in OCaml

2008-12-03T13:05:00.002-05:00

I just wrote some code to do polynomial interpolation in O'Caml. The full darcs repository is at http://web.mit.edu/farr/www/onumerics/; here's the guts of the code. Eventually (depending on my time and level of continued interest), this may turn into a more general O'Caml numerical library. As usual, it's released under the GPL. (* interp.ml: Interpolation. Copyright (C) 2008 Will

Very Basic Matrix Library for PLT Scheme

2008-06-11T20:20:00.001-04:00

I just uploaded to PLaneT a very simple matrix library. The library provides a matrix datastructure, iterators over matrices and vectors, algebraic operations on matrices, and matrix-vector and matrix-matrix products. There is also an initial module import language which provides all of scheme except the +, -, * and / operations, which instead are generalized for all reasonable combinations of

Quick Note on Continuations to comp.lang.scheme

2007-09-07T16:10:00.000-04:00

I just posted a quick note on continuations to c.l.s. I'm afraid it's pretty basic, and doesn't really do the topic justice, but maybe the original poster will find it helpful. I'm noting it here because no ever seems to explain continuations the way I did in my note (at least, I haven't seen any explanations like this), which uses "return points" to illustrate what continuations do. I don't

One More Reason to Love Module Systems and Hygiene

2007-08-15T10:57:00.000-04:00

I just released an Automatic Differentiation PlaneT Package, and am now converting my numerical relativity code to use it. The package exports procedures like +, -, =, etc, which are modified from the standard ones so it can compute derivatives of numerical procedures which use them. Of course, these modified procedures are slower than their standard cousins. My numerical relativity code

Automatic Differentiation PlaneT Package Released

2007-08-15T10:38:00.000-04:00

I just released a PlaneT Package which, when used as a PLT Scheme module's initial language import, allows to compute derivatives of functions written in the module exactly. (I've written about the technique here and in the posts which follow.) I'm going to use this code to compute some derivatives of gravitational actions in code which would be extremely complicated to do by hand. Enjoy!

Persistency and Lazy Memoization in a Pairing Heap

2007-08-08T09:13:00.000-04:00

I just released a pairing heap PlaneT package. Because the datastructure is both persistent and has amortized space bounds, it requires a neat trick to implement, which I will discuss below. A pairing heap is an adaptive datastructure for a collection of objects which supports the following operations [edit: You can also read about an alternative implementation here in the Scheme Cookbook.

I Just Voted "Yes" on R6RS

2007-08-06T13:10:00.000-04:00

Yep, I did. I'm including my explanation below, because I think that R6RS has come under a lot of fire lately. (By the way, for those who say, "why doesn't the standard come with a small base, and then lots of libraries attached to it?", it does! Try reading it, why don't you.) Even if you don't agree with my choice, don't forget to vote if you signed up (just one of many

A Question (and an Answer, sort of) About Scheme FFIs

2007-07-23T16:32:00.000-04:00

Recently, I received the following email from Raoul Duke: hi, I'm trying to learn up on what Scheme has the easiest FFI for talking to C (more ideally C++, but I assume nobody really does that). I've been reading up and it seems like PLT isn't bad. I came across your blog - might you have any opinions or recommendations about PLT vs. Chicken vs. Bigloo vs. Gambit vs. etc.? many thanks!

N-Body Utilities Coming Real Soon Now (TM)

2007-06-17T13:10:00.000-04:00

It's been a while since I posted here, but never fear: I've been busy. I've been working on an updated set of N-Body utilities for another paper examining the efficiency of our algorithm (see astro-ph/0611416, to be published in ApJ 663 (2007) 1420) relative to drift-kick-drift leapfrog in a treecode. I've got code up and running, and am beginning simulations to compare the two algorithms.

Pure Scheme Code for SO(3,1)

2007-04-29T14:55:00.000-04:00

Jens Axel Soegaard wrote a comment on my last post asking for the Scheme code for comparison, so here it is. Note that the code provides a (moderately efficient, but conses too much) matrix inversion routine in pure Scheme (you want to look at the matrix module, for matrix-inverse)---some people may find that useful independently. Sorry it's so long, but there's a lot of background stuff to

Why Use the FFI for Simple Numerical Operations in MzScheme?

2007-04-28T21:16:00.000-04:00

Brad Lucier (of Numerical Partial Differential Equations in Scheme fame) posted a comment on my last post announcing the code for numerical manipulation of Lorentz group elements which reads: I'm surprised that you decided to use the C FFI to manipulate 4x4 matrices; they are so small that it would seem better just to use mzscheme's numerical facilities which are getting better all the time.

SO(3,1) (Lorentz Group) Manipulations from PLT Scheme

2007-04-28T18:03:00.000-04:00

I just released a PlaneT package which manipulates elements of the Lorentz group (here). Get it using (require (planet "SO31.ss" ("wmfarr" "SO31.plt" 1 0))) At the moment, it only runs on Mac OS 10.3 or 10.4, ppc, because it uses some C code I wrote (for efficiency), and I haven't had the patience to understand all the hoops I need to jump through to get PLT Scheme to compile this to a

Linear Algebra in PLT Scheme

2007-04-26T14:45:00.000-04:00

Last night, I posted a library which uses BLAS and LAPACK from within PLT Scheme to perform simple numerical linear algebra. In doing so, I've learned a lot about the FFI for PLT Scheme. The conclusion: it's great! In particular, the "custom _fun types", discussed here are tremendously helpful! Particularly when interfacing to Fortran libraries, where every argument to a function must be

Pearls Before Breakfast

2007-04-09T11:50:00.000-04:00

Nothing to do with Scheme, but a really neat article here in the Washington Post. I'm really busy now, but I'm glad I took the time out to read this article. Found via the fascinating blog of Terrence Tao.

Eager Comprehensions for Arrays

2007-03-03T20:31:00.000-05:00

I just submitted a package to PlaneT for eager comprehensions (SRFI-42) for arrays (SRFI-25). It's a pretty short module, so I've also pasted it below. #| array-ec.ss: SRFI-42 comprehensions for SRFI-25 arrays. Copyright (C) 2007 Will M. Farr This library is free software; you can redistribute it and/or modify it under the terms of the GNU Lesser General Public License as published by the

Barnes-Hut Tree Code Submitted to PlaneT

2007-02-18T22:20:00.000-05:00

I've just submitted some new code to PlaneT which implements Barnes-Hut Trees in PLT Scheme. It's surprisingly (to me) fast, creating a 100K-body tree in about 30 seconds on my old PowerBook G4 800 Mhz. This is just another step in my code clean-up in preparation for comparing our algorithm to the standard leapfrog algorithm of cosmological codes.

N-Body Simulation Initial Conditions

2007-02-18T03:07:00.000-05:00

I just packaged up some code for PlaneT which creates gravitational N-body initial conditions. I assume it'll appear in the next few days. It's not very extensive as of yet (only does cold and hot constant spatial density spherical distributions and the venerable Plummer model), but that's really all I've needed over the past year or so to test my algorithms. The paper is undergoing its final

The Paper is Out!

2006-11-15T17:00:00.000-05:00

It's out! The paper of the century---get your copy before they're sold out at the newsstand. (If you're into N-body simulation methods, that is.) Seriously: I'm very glad to have it out the door. The ball is now in ApJ's court, and I can get back to focusing on my thesis (for which I just submitted a title: "Numerical Relativity from a Gauge Theory Perspective"). Section 6.2.1 uses

SRFI-42 Comprehensions for SRFI-4 Vectors

2006-11-07T20:36:00.000-05:00

I spend quite a bit of time working with SRFI-4 homogeneous numeric vectors. Below is some code which adds some SRFI-4-vector generators and comprehensions to SRFI-42's Eager Comprehensions. I am impressed at the modularity in SRFI-42! #| Derived (almost verbatim) from the code for vector comprehensions in the SRFI-42 reference implementation. The copyright on that code is: Copyright (C)

Updated Scheme Code for Derivatives

2006-10-24T13:16:00.000-04:00

I've updated my functional differential geometry code to use the same techniques I've been writing about these past few days in OCaml for computing derivatives. It should (haven't rigorously tested this) improve the performance of computing structure constants (which involve the commutator of two tangent vectors in the group, and therefore taking second derivatives, and therefore multiple tags

Better Jacobians in Computing Derivatives

2006-10-23T15:41:00.000-04:00

And another fix to the code computing derivatives: before I was trying to compute the Jacobian of functions with only one call to the function: let jacobian f args = let n = Array.length args in let tags = Array.init n (fun _ -> new_tag ()) in let dargs = Array.mapi (fun i arg -> D(tags.(i), arg, one)) args in let result = f dargs in Array.init n (fun i ->

Correction to Automatic Differentiation Code

2006-10-19T13:46:00.000-04:00

I've uncovered a *large* inefficiency in the OCaml code I posted for Automatic Differentiation. The problem is that I don't take any care to avoid duplication of tags in a nested D(tag, x, dx) expression. That's not a problem in a computation with only one tag, but if you're trying to take the jacobian of some multi-dimensional function, you have derivatives wrt each of the arguments floating

``Automatic Differentiation'' in OCaml

2006-10-16T16:07:00.000-04:00

Below I've posted an OCaml functor which lifts an input module of mathematical functions (+,-,*,/,sin,cos,...) to equivalent functions which also support computing derivatives without any truncation error (i.e. (d sin) is (exactly) the function cos). This technique is commonly called automatic differentiation in C++ (where it is accomplished at compile time through template metaprogramming),

Working Toward Gauge-Covariant Derivatives

2006-08-28T17:08:00.000-04:00

I've posted the latest version of my functional differential geometry code (darcs pull http://web.mit.edu/farr/www/SchemeCode/ should get it for you). I now have code for arbitrary linear representations of lie groups. I'm working up to implementing the gauge covariant derivative (a generalization of the covariant derivative of GR to arbitrary symmetry operations). Unfortunately, the code is

Adventures in OCaml Land: Barnes-Hut Trees

2006-08-22T18:00:00.000-04:00

I'm presently working on a simple cosmological gravitational n-body code (if you don't know a "gravitational n-body code" is, you can get a really great introduction to gravitational simulation here). The simplest way to evaluate the forces on a body (the fundamental part of calculating its trajectory in an n-body simulation) is to iterate over all other bodies summing the standard Newtonian

One More Example of Python Generators in Scheme

2006-08-18T14:50:00.000-04:00

I've had some spare time at work these past few days waiting for modestly long-running data analysis procedures to complete. Unfortunately, this spare time comes in ~5 min chunks, so it's not really worth a serious context switch into other work-related stuff. So, I've been doing a lot of little things---like web browsing about Python generators in scheme. I'm unable to resist posting my own

SRFI-11 For Bigloo

2006-08-02T14:34:00.000-04:00

Tired of using multiple-value-bind all the time in Bigloo, I've packaged up SRFI-11 for Bigloo. You can find it here. It even builds the _e library target for the interpreter's new library-load command. Enjoy your let-values.

Yet Another Sudoku Solver

2006-07-10T19:55:00.000-04:00

While flying home from vacation, I composed the following Sudoku solver. It seems to solve all the puzzles I throw at it, but definitely is not the most efficient algorithm possible. Basically it applies the Sudoku constraints (no repeat numbers in a row, column, or 3x3 block) to the puzzle (represented as a vector of vectors, with lists for elements which may have more than one possible number

Defining your own Lie Group

2006-07-05T21:30:00.000-04:00

Today I was asked how to define your own Lie Group using my functional differential geometry software (see this post and subsequent posts). Basically, you have to provide five things: Chi : G -> R^n. This is the coordinate function on the group manifold. Chi^-1 : R^n -> G. The inverse of Chi. e \in G. The identity element. inverse: G -> G. The inverse function (on the group manifold: g ->

Figured it Out

2006-06-27T00:20:00.000-04:00

The bit at the end of the last post where I was worried about the commutator (lie bracket in the lie algebra of vector fields, not vectors at the identity) of two left-invariant vector fields not being itself left-invariant was just a mistake. I shouldn't expect [extend(d/dtheta), extend(d/dphi)] = d/dpsi, but rather [extend(d/dtheta), extend(d/dphi)] = extend(d/dpsi)! If you do that, then it

Lie Groups Mostly Working

2006-06-26T10:50:00.000-04:00

It's working! (Mostly.) See: ;; Welcome to DrScheme, version 350.1-svn21jun2006. ;; Language: Swindle. ;; Require some modules (require "lie-group-SO3.ss") (require "lie-groups.ss") (require "manifolds.ss") (require "tuples.ss") ;; ;;; Compute the structure constants for SO3 in the ;;; x,y,z coordinate system. Exactly what you ;;; would expect. (structure-constants SO3 SO3-

Functional Differential Geometry in PLT Scheme

2006-06-24T22:22:00.000-04:00

I've been working a bit lately with Gerry Sussman and Jack Wisdom to extend their software for functional differential geometry to handle Lie Groups (which, after all, are just manifolds). My thesis will probably have to do with treating General Relativity as an SO(3,1) gauge theory, so I'm particularly interested in the Special Orthogonal Lie Groups. (Jack, as a solar-system dynamicist, is

SRFI-78 for Bigloo

2006-06-20T16:41:00.000-04:00

I've just posted an implementation of SRFI-78: Lightweight Testing for Bigloo. You can get it here. It leaves out the check-ec form because there's no implementation of SRFI-42 for Bigloo yet, but otherwise it's complete. The framework is very lightweight---it took about 10 minutes to port. I want the framework so that I can test my new SRFI-4 implementation for Bigloo before I post it, so

Fun With Streams

2006-06-08T23:09:00.000-04:00

Or: a bit of Haskell in PLT Scheme. In a one-off version of the n-body integrator I've been working on (seemingly in perpetuity, but probably finishing soon with a couple of papers), I had occasion to iterate a function to convergence. (i.e. to compute (f (f (f ... (f x)))) until the result converges.) Well, it's pretty easy to write: (define (iter-to-convergence f) (lambda (x) (let loop

Tidbits

2006-03-08T02:35:00.000-05:00

My god! It's been about a month since I last posted (about PLT Scheme's new JIT). Just to prime the pump (hopefully more to follow more quickly): There's a very interesting discussion on the Ocaml mailing list about Software Transactional Memory for concurrent programming. In particular, see the referenced papers here and here. The basic idea is to wrap up all accesses to shared memory in a

PLT Gets JIT

2006-02-01T11:32:00.000-05:00

According to this message to the PLT Scheme mailing list, PLT Scheme just got a JIT compiler. It only works on the non-3m (i.e. Boehm conservative collector) version of PLT Scheme, but it seems to provide some speedups. Subsequent messages suggest that they're working on a "proper" JIT compiler targeting LLVM which should provide even more speed. Very nice! Update: I've been using the JIT

Bitten By the Hygiene Bug

2005-12-13T15:04:00.000-05:00

I've noticed that I haven't posted here for a while---been really busy working on the code for the paper on n-body integrators. I'm finally running some real "experiments" (the numerical kind), and am discovering the joy of tight binary orbits in the middle of a star cluster (hint: lots of small steps for the binary = lots of roundoff error over cluster timescales). Hopefully I've got that

Bigloo 2.7a Released

2005-11-22T08:19:00.000-05:00

In case you hadn't noticed: Bigloo 2.7a was released yesterday (or maybe over the weekend). You can get my OS X package for it if you don't like to compile things yourself.

Continuations in Unfriendly Environments

2005-10-20T13:26:00.000-04:00

I'm sure many people already have seen the paper (and probably attended the conference), but have a look at this paper from Greg Pettyjohn, John Clements, Joe Marshall, Shriram Krishnamurthi, and Matthias Felleisen! It describes a technique that can be used to implement continuations in unfriendly environments where stack inspection is not available (i.e. portable ANSI C, JVM, .NET, etc.) The

Exciting and Depressing

2005-10-17T02:37:00.000-04:00

Ever have something happen that's terribly exciting, as long as you don't think about it too much? I just had a mental breakthrough with my integrators: I realized a way to think about what's going on that makes everything perfectly clear. Then I implemented this in about 174 lines of Bigloo code. "That's great!" you say. I agree completely. Unfortunately, if I can't quite remain lost in the

Shared State in PLT Scheme's Swindle

2005-10-13T00:45:00.000-04:00

I just spent about six hours debugging a version of my integrator that runs in PLT Scheme (got tired of not having the class creation options available at runtime in Bigloo) because of a shared state problem. If you define a Swindle class with the slot option :initvalue then is only evaluated once; every object of this class shares the same value. Not good if you want to have

SRFI-32 for Bigloo

2005-09-30T13:39:00.000-04:00

I needed some fast vector sorting routines for my n-body integrator. To that end, I've packaged up the withdrawn SRFI 32 for Bigloo. The SRFI is technically withdrawn, but even half of a half-standard is better than none (and this way I don't have to delve into sorting myself---I'm sure Olin Shivers is way better at that than I am).

Wolfram Tones

2005-09-29T16:52:00.000-04:00

Here's an idea sure to appeal to nerds everywhere (including me): cellphone ring tones generated by cellular automata. Though it's a bit hard to stomach how much Wolfram exaggerates his contributions to the science of complexity and the study of cellular automata and related computational algorithms, it's still an interesting idea. Discovered through this New York Times article. In addition

Srfi-4 Vectors in Bigloo

2005-09-29T14:36:00.000-04:00

I just thought I'd drop a quick note about srfi-4-like vectors in Bigloo. For those who don't know, srfi-4 specifies an interface for homogeneous numeric vector types. For those of us who do numerical computing, this is a big win---boxing a double, for example, every time you reference or store into a vector is just impossibly inefficient if you want to get anything numerical done. But, Bigloo

Economic Integration

2005-09-24T14:30:00.000-04:00

Check this out (from an article in the New York Times): A school board election will take place in October. While the board has continued to endorse economic integration, some supporters worry that that could change one day. "It's not easy and it can be very contentious in the community," said Walter C. Sherlin, who retired two years ago as an associate superintendent. "Is it worth doing? Look

Unemployment

2005-09-24T12:01:00.000-04:00

Just read an interesting paragraph in an essay about the internet bubble: The prospect of technological leverage will of course raise the specter of unemployment. I'm surprised people still worry about this. After centuries of supposedly job-killing innovations, the number of jobs is within ten percent of the number of people who want them. This can't be a coincidence. There must be some kind of

The Flu

2005-09-22T09:25:00.000-04:00

Not that I have it (or usually get it, being young and in good shape). However, this article in the New York Times today points out that vaccines are "apparently ineffective" in preventing the flu for elderly people: The fact that the vaccine study showed that inoculations have had only a modest effect in the elderly is particularly worrisome, because this is a group that tends to suffer high

Bigloo Finalization Library

2005-09-20T23:15:00.001-04:00

I've just posted a library which allows finalization of Bigloo objects before they're reclaimed by the GC. You can view the documentation and download the library here. Manuel provided the hint to look at doc/README.finalizer, but I didn't like the way finalization was done in the example there, and it seemed a bit out of date. So, I wrapped up my own finalization library. I worry that I

Bigloo 2.7a Beta Mac OS X Package

2005-09-20T13:22:00.002-04:00

I've just posted a Mac OS X installer for the latest (Sept 20) beta of Bigloo. You can read more about it here. It's been quite a lot of work to compile Bigloo properly on OS X (which you can read about on the Bigloo mailing list), and Manuel has been a huge help. Many of these things are happening automatically now, but I figured that, since I've already put in the effort, I might as well

Bigloo Internals, More Dynamic Linking and Shark...

2005-09-14T00:53:00.000-04:00

without much Scheme-y stuff in sight. Over the past few days Manuel Serrano has been helping me improve the speed of my n-body integrator by changing the behavior of Bigloo's threading when run in single-threaded mode on OS X. There is a function in runtime/Clib/cthread.c called denv_get which, I assume, gets some representation of the current dynamic environment. Since the cthread.c

Hybrid Cars and Pork

2005-09-07T18:07:00.000-04:00

In today's New York Times: "I would like to get more hybrids out of our system because I do think it's something that is here to stay," William Clay Ford Jr., chairman and chief executive of Ford Motor, told reporters in Detroit on Aug. 23. Last fall, Ford introduced a hybrid version of its Escape sport utility vehicle, the first of several hybrids planned. At the same time, the energy bill

Bigloo Tracing

2005-09-06T23:37:00.000-04:00

I just saw that I'm being syndicated at planet scheme. Looks like it hasn't quite made it to planet lisp-like number of contributors (or probably readers). But, in honor of the nevertheless auspicious occasion I plan to say something scheme-y after the past few days of political posts (which, by the way, have probably alienated my one reader---sorry dude, but I call it the way I see it :) ).

What are they doing?

2005-09-06T00:49:00.000-04:00

Yet more incompetence from our lovely executive branch: FEMA ignores an offer of help from Chicago. Even before the storm hit the Gulf Coast on Monday, he [Chicago Mayor Daly] said, the city's Office of Emergency Management and Communications had contacted emergency response agencies in Illinois and Washington. In the event of a disaster, the city offered to send 44 Chicago Fire Department

Labor Day

2005-09-05T10:43:00.000-04:00

From a NY Times Op-Ed: ...But because the French work 35 hours a week, Americans sneer, forgetting that in many years French workers have a higher productivity rate than their American counterparts - proof that you can work better by working less. Americans also forget that going to work every day is often more a chore than a pleasure. You seem more and more disillusioned about work: only a

Science and Politics in the NY Times Magazine

2005-09-04T12:20:00.000-04:00

There's an interesting article in the New York Times Magazine today about politics and science. The article discusses possible reasons for why most (nearly all?) scientists think the Bush administration has done an abysmal job listening to and properly reacting to scientific developments and studies. It's probably a good factual review of several instances where science was suppressed/changed

Google Helper for Mac

2005-09-04T03:18:00.000-04:00

Google Mail Helper is available for the Mac! I'm now using it, but I'm wracked with guilt over my desertion of the wonderful soul who created Gee. Poor Lloyd---and because it never rains but when it pours, Lloyd looks to have lost a bunch of photos in a Linux drive crash. Bummer. I guess people may still use Gee for other Atom feeds, but mail helper has much better features for Gmail (not

Chlorine Tidbits

2005-09-04T02:13:00.000-04:00

Some sites regarding chlorine exposure in swimmers are interesting, since I just got back into swimming. The information is somewhat sketchy on the web (and most sites are trying to sell you something---as in http://www.karinya.com/chlorine.htm), but there are some seemingly-authoritative pages. This review points out that there isn't a very good understanding of the effects of chlorine and

Sean Carroll's Blog

2005-09-02T01:50:00.000-04:00

I just discovered Sean Carroll's Blog (he blogs along with several other physicists at cosmicvariance). Great stuff! I particularly enjoyed the political cartoons #1 and #2. Of course, the physics is neat, too. I haven't hung out much with Sean (just a bit when I was visiting Chicago as a prospective grad student), but now I can follow him vicariously and wonder what Chicago would have

bdepend Problems Solved

2005-08-31T13:52:00.000-04:00

I just figured out why I was having problems with module initialization. I also solved a long-standing mystery in my own mind: what the hell are those .mco files that Bigloo produces all the time? In fact, .mco files are module checksums---reproduced (I assume) every time the interface to a module changes. So, bdepend does, in fact, know about dependencies on (import ...) modules; it just uses

Bigloo GC and SIGINT

2005-08-19T17:17:00.000-04:00

I've noticed in my work with Bigloo that sometimes when a process running from the REPL is sent SIGINT (C-c), the GC hangs in the function GC_lock. I don't know if it's related to dynamic-load-ing on OS X, or whether this is a general problem, and the GC is not very resistant to SIGINT. I suppose it could also be my optimization options on the compiled C code (I'm optimizing pretty heavily for

Inconsistent Module Initialization

2005-08-16T13:59:00.000-04:00

I've been getting a lot of errors like the following lately from Bigloo: *** ERROR:body:Inconsistent module initialization Module `body' is inconsistently initialized by module `__nbody'. At least of the two modules must be recompiled (see also -unsafev option). and I think I finally realized what the problem is. I have a bunch of modules which are all separately compiled, and then put

Perserverance: 1 Static Linking: 0

2005-08-15T02:59:00.000-04:00

Finally! I've figured out how to make dynamic linking of module files work with bigloo on Mac OS X! Details follow (though I should warn you that this is a total hack right now). There are two steps involved: 1. Alter the bigloo compilation process so it builds the proper dynamic libraries and 2. Make sure that the executable bigloo is linked against the dynamic libraries, and not the static

Latest in the Quest for Speed

2005-08-09T20:02:00.000-04:00

I found an interesting post which claims that Chicken is a bit faster than Gambit on floating-point code. There's a paper by Brad Lucier which talks about using Gambit to make a PDE solver, which would seem to refute this (Chicken doesn't achieve C speeds on numerics), but I suspect that his sparse matrix-vector multiply was memory-bound, so the speed of the code didn't matter too much. In any

Gambit Isn't Fast Without (declare (unsafe))

2005-08-09T11:04:00.000-04:00

Gambit, nice as it is about loading compiled code into an REPL, isn't fast numerically unless you compile using (declare (unsafe)). (At least it wasn't in my recent quick tests of some floating-point code.) Bigloo is much better at eliminating type checks and producing fast numerical code, even in safe mode. So, I guess it's back to Bigloo, because I don't want to have to worry about blowing

Gambit-C

2005-08-07T22:40:00.000-04:00

I've just discovered a new scheme implementation which may be even better than Bigloo for my needs: Gambit-C. Gambit runs on Mac OS X, and compiles to C, just like Bigloo. However the compilation strategy is a bit different. Bigloo aims for roughly idiomatic C code (and relies on the C compiler for many optimizations), while Gambit really uses C as a portable assembly language (and therefore

More Bigloo Macros

2005-08-04T13:51:00.000-04:00

Regarding my previous post about Bigloo Macros and the REPL, I have realized that it's vital to export the macro-expander function from the module in which the macro is defined. Not doing this prevents recognizing the expander when (eval '(define-expander ....)) is evaluated. (Maybe this was obvious to everyone else, but I didn't realize it for a while.)

MzScheme and GSL Random Numbers

2005-07-01T04:19:00.000-04:00

I just used the foreign interface to PLT Scheme to wrap up the GSL random number generators. I've posted the code here; it hasn't been extensively tested, but I think it'll work OK. As an aside, I really, really like the foreign interface to PLT Scheme---it's by far the best one I've ever dealt with. This paper explains the rationale. Definitely The Right Way to do it.

Bigloo, Macros and the REPL

2005-06-25T00:17:00.000-04:00

I've just spent quite a while trying to make Bigloo do what I want with macros. What I want: To be able to write macros within a module which I can use while compiling code in that module or other modules which import the macro-module. To be able to write macros which are imported into an repl which incorporates the module in which they are written. Doing this has required a bit of

Making Scheme behave like Fortran 95

2005-06-23T22:16:00.000-04:00

I just coded up a macro which makes Bigloo scheme behave more like Fortran 95 with respect to vectors. Usage: (with-vectors (a b c) (a <- (+ b c))) (with-vectors (a b c) (<- (+ a b c))) (with-vectors (a b c) (a <- (+ b 2)) (print "I can insert statements, too.") (c <- (+ a b))) The second form above returns a fresh vector whose elements are the sums of the corresponding

Typed Vectors in Bigloo

2005-06-22T19:23:00.000-04:00

I learned at the beginning of the month how to make a typed vector (also called monomorphic, I think) in Bigloo scheme. I had known that Bigloo would automatically unbox vectors of doubles or integers if it could infer the type of them, but you can't guarantee this. This kept me from using Bigloo for my numerical projects---it's essential that such vectors be unboxed, and I didn't want to leave

All the President's Men...

2005-06-01T10:36:00.000-04:00

I still remember reading All the President's Men when I was maybe in middle school. My parents were coming of age during that era, and reading the book made me feel like I was equally involved in the scandal. Learning yesterday that Deep Throat has finally come forward brought all that to mind again. I hope someone writes a book about him---it sounds like he is maybe a bit conflicted about his

Almost beaten to the punch!

2005-05-31T01:02:00.000-04:00

The shark-profile package has only been out for a few days, and I've been scooped! I'm glad that someone with more stamina and skill than I have has fixed the interrupt/floating-point interaction for SBCL on OS X. I've been using SB-SPROF a bit tonight, and it seems to be stable now. In consolation, I suppose there may still be people who wish to use shark instead of SB-SPROF, and I got

Profiling lisp with SBCL and Mac OS X

2005-05-27T03:32:00.000-04:00

I just posted some code for profiling with shark (part of the CHUD toolkit on Mac OS X) and SBCL. I've been writing some fancy n-body integrators using common lisp for a research project, and wanted to profile the code. SBCL comes with a profiler (sb-sprof), but it doesn't work well---at all---on Mac OS X (see the reply to this message of mine for a description of the problem). So, I cooked up

Go New York Times!

2005-05-22T11:39:00.000-04:00

Check this out: While the proposal to close the case was ultimately rejected by senior officials, documents show that the inquiry was at a virtual standstill when an article in The New York Times on March 4, 2003, reported that at least one of the prisoner's deaths had been ruled a homicide, contradicting the military's earlier assertions that both had died of natural causes. Activity in the

First Post

2005-05-21T16:54:00.000-04:00

I've finally broken down and started a blog. Typically for me, it came impulsively as I was searching for information on the best way to rip books on tape (CD) in iTunes, and stumbled on http://aldoblog.com/blog/471. Since we're flying to California, Oregon and then the Netherlands this summer, we've got some 30 hours of time on planes, and thought we'd get some books on tape for Rachel's iPod.