Some Software

This is a snapshot of some of the software I've worked on or played with recently. Mostly the programs are relatively short and not all of them are finished or functional. Sometimes I'll start a program to try to understand something, or as a way to try out assignments, or build parts of programs to use in assignments.

Some of these were finished, but the finished bits were deleted so I can use them in assignments in the future. Many are unfinished or only barely finished - sometimes I decided I understood the problem well enough to stop and do something else, sometimes time got too short and I abandoned the program, sometimes I just got bored.

In a few places there are multiple implementations for a problem. Sometimes these are in different languages, sometimes they're different algorithms, sometimes they just correspond to my restarting a problem after a bit and deciding to start more or less from scratch again.

In any case, I tend to keep things around as I find that I use and reuse bits and pieces of programs as time goes on - so I figured I might as well put them on this web site for all and sundry to enjoy.

If you are a student and have been assigned one of these problems in a class, you should be aware that searching the web is not something restricted to students. I've had good luck myself in finding the source code for students who have copied programs off the web and your instructors are likely to know how to do the same thing.

None of these bits of stuff are guaranteed to be correct. In more than a few cases they're far, far from correct. Don't say I didn't warn you.

Some of these entries have descriptions, some not. I'm adding descriptions slowly, but I'd rather write code than documentation (sigh), so it doesn't happen that quickly. You should expect to have to browse undocumented source code and worse yet source code that is work in progress. I like my programming style, but not everyone does. Go fig.

I've been interested in functional languages for a while and have been actively coding smallish (but getting larger) projects in haskell more and more commonly. I'm not sure its appropriate for everything, but functional techniques are so powerful that they should be added to more languages.

Addition chains in haskell. Not the best solution, but a fun problem.

addition chains again

experiments with wavelets in haskell

wordsquares in haskell

Arithmetic on lists of bits. Every CS student should do this at least once and should build floating point numbers from integers once.

Monads fascinate me, I understand them on some level, and can use them on other levels, but a complete understanding still eludes me. This is a bunch of programs I've written to experiment with monads.

This was the basis for an assignment in one of my classes. Finding roots of functions with the secant method. The secant method is a very good thing to play with - you can learn a lot from it.

John Horton Conway's Fractran. This needs quite a bit more experimenting - it looks like there may be some fun stuff lurking behind the surface.

Experiments with fourier transforms in haskell

program to generate lists of strings in regular languages. My version isn't quite right. It works fine on infinite lists, but not so good on finite ones.

Experiments with the sequence variously called the Collatz sequence, the Ulam sequence, the hailstone function and so on. Another good thing to play with. This kind of simple yet extendible algorithm is a good learning tool - you can try all kinds of different things and get a chance to play with more and more complicated stuff - but still its based on something simple enough to understand and play with with relatively easily.

Parsers using the monadic parser library in haskell.

Anagrams in haskell. I wanted to experiment with a trie kind of implementation - and there are a couple such here. The trie was easy - getting from there to the solution was a bit tougher. It wasn't that it was that hard, just that formulating the program correctly took a bit of thought. In part this was because I wanted to represent the solutions in a tree form. Running this with /usr/dict/words as its input doesn't work yet - it takes up way too much space.

Another homework assignment. This is fun because the rules are actually programs (in the small).

Part of the experiments I've done with effects like the image on my home page.

C++ programs. Some are experiments designed to try out specific things (specifically to test hyphotheses I have about the way the language works), some are ideas for assignments.

If you approximate an image with an iterated function system, you can get some nice effects. This also can use a bit more experimentation. In particular I've been thinking about taking two images and using ifs's to "morph" between them - could you do animation that way? It would be very impressionistic, but might be interesting. This is some experiments along the way to that.

In the Cryptonomicon there is some mention of the Riemann Zeta function in cryptography. I didn't see quite how that might be used so started playing with the zeta function and lots of variants of it.