Although, today I implemented a heap from scratch in C for the first time in a while. It was therapeutic, somehow, to be doing low-level algorithmic stuff.

Here’s a list of what works in UNR out of the box:

• Everything.

Okay, technically I don’t know that everything works – I haven’t tried Bluetooth or the card reader or most of the buttons on the display (in fact I suspect that at least the screen rotation button will need some custom fiddling), but the two main things that other people seemed to have trouble with in older versions of Ubuntu – WiFi and the touchscreen – work beautifully. Well, I haven’t tried to use WiFi yet, ’cause all the routers around me are locked, but it can see them.

I am well pleased. I’ll post some thoughts on UNR after I’ve played with it for a while.

Ah… Just noticed that the touchscreen doesn’t quite go to the edge of the screen. I can live with that. If that’s what everyone else is complaining about then, frankly, what a bunch of whingers.

Edit: Oh, I see, menus and whatnot are at the edge of the screen, which makes the touchscreen thing important. Well, I found the touchscreen maker’s site the other day and they seemed to have well-maintained Linux drivers (there’s an installer for the last several Ubuntu versions, including 9.10), so I’ll see what can be done about it later.

Instead of getting an iPod, I bought an iriver. Part of the rationale was that it supported Ogg Vorbis. It also turned out to be chunky and awful and churn through AA batteries, but meh.

I deliberated for a while about getting an iPhone, but on the verge of making the decision there was some controversy or other about the app store, which pushed me over the line to go for the Android-powered HTC Hero instead. The idea of an open platform for app development appealed to me enormously. So far I haven’t actually done any of said development, but it’s nice to know that I could in theory.

I don’t actually have a problem with Apple, and in fact I think their focus on a simple, seamless UI is something that should be imitated far more often. But being a geek, I actually like something with a few visible seams, because they can be picked apart. Like Shamus, I’m not really their target market.

Anyway, less than a week after the iPad announcement, I find myself having bought a Vye Mini-v S37 at auction. Notionally the idea is to have something small and light to travel with, especially on our honeymoon in May – an argument supported by its the fact that it has a CF card reader, will let me dump photos onto it. But really I just thought it was cool. Obviously I’m planning to put Linux on it (probably Xubuntu)… although I can’t find anywhere that explicitly says that someone’s tried that and everything works, which means that it could be… interesting. It’ll be disappointing if I’m stuck with Vista.

So the relevance of this to a blog about software and stuff (other than the fact that I’ve been otherwise occupied with work and wedding plans and the box set of Buffy and am struggling a bit to find something to write to break the silence) is that I’ll be posting some updates on how Linux holds up in the tablet-netbook-thing niche.

Update: Apparently the Vye S37 is also sold as the Kohjinsha SH8. That link is to a blog describing an attempt to get Ubuntu 7.10 working on said Kohjinsha (and I thought this blog was too topic-specific ). So it looks like the problems, if I have them, will be WiFi and the touch screen… although I’m also quite optimistic about Ubuntu’s progress over the intervening two years.

Update 2: The Ralink RT73 WiFi adapter allegedly works out of the box in 9.10. Should be okay on that front.

We haven’t done an exhaustive search yet, but I’ve been running a simulated-annealing-ish script for a while, and it looks like the most attacks is 34 (17 pairs of mutual attacks), in two configurations:

QQ.    .QQ.
QQQ or QQQQ
QQQ    .QQ.

…either of which can be expanded by adding gaps between the queens, or rotating by multiples of 45 degrees.

Q.Q..   .Q.Q.   Q...Q..
.....   Q.Q.Q   .......
Q.Q.Q   .Q.Q.   ..Q...Q
.....   ..Q..   .......
Q.Q.Q           Q...Q..
                .......
                ..Q...Q

Q...Q...

Update: Python code below the fold.

import random
from numpy import array, exp

def print_board((n, queens, board)):
    for row in board:
        for val in row:
            print ('.','#')[val],
        print

def new_board(n=8):
    board = array([[False] * n for i in range(n)])
    queens = []
    while len(queens) < n:
        x = random.randint(0, n-1)
        y = random.randint(0, n-1)
        if not (x,y) in queens:
            queens.append((x, y))
            board[x,y] = True
    return (n, queens, board)

def eval_attack((n, queens, board)):
    attacks = 0
    for (x,y) in queens:
        for (dx,dy) in ((-1,-1),(-1,0),(-1,1),
                        (0,-1),(0,1),
                        (1,-1),(1,0),(1,1)):
            (cx, cy) = (x, y)
            while True:
                cx += dx
                cy += dy
                if cx < 0 or cx >= n or cy < 0 or cy >= n:
                    break
                if board[cx,cy]:
                    attacks += 1
                    break
    return attacks

def move_queen((n, queens, board), q=None, dest=None):
    if q is None:
        q = random.randint(0, n-1)
    if dest is None:
        while True:
            x = random.randint(0, n-1)
            y = random.randint(0, n-1)
            if not board[x,y]:
                dest = (x,y)
                break
    prev = queens[q]
    queens[q] = dest
    board[prev] = False
    board[dest] = True
    return (q, prev)

def find_most_attack(board=None, n=8, temp=2.0, threshold=10000):
    if board is None:
        board = new_board(n)

    best = 0
    meta_best = best
    since_improve = 0
    while True:
        (prev_q, prev_pos) = move_queen(board)
        score = eval_attack(board)
        if score > best:
            best = score
            since_improve = 0
            if best >= meta_best:
                meta_best = best
                print_board(board)
                print score
        else:
            since_improve += 1
            if since_improve > threshold:
                since_improve = 0
                board = new_board(n)
                best = 0
            elif random.random() >= exp((score - best)/temp):
                move_queen(board, prev_q, prev_pos)

A backup resolution, in case the rabbit hole turns out to stink, is to switch to vi.

Fibonacci MIDI (9.8KB)

Fibonacci MP3 (3.0MB)

It could generously be described as “atonal crap”, but it sort of has moments of not-completely-awful-ness. Sort of.

Python code below the fold.

This produces output that can be included in a Lilypond file. For the record: I’m not actually expecting anyone to actually do this (other than me), I’m just sort of documenting it for posterity.

SCALE = ['c','cis','d','dis','e','f','fis',
         'g','gis','a','ais','b']

class Fibonacci:
    def __init__(self, mod, offset=0, coeff=1, a=0, b=1):
        self.mod = mod
        self.offset = offset
        self.coeff = coeff
        self.a = a
        self.b = b

    def next(self):
        val = self.coeff * self.a + self.offset
        (self.a, self.b) = (self.b, (self.a + self.b) % self.mod)
        return val

def note(n):
    suffix = ''
    while n < 0:
        suffix += ','
        n += len(SCALE)
    while n >= len(SCALE):
        suffix += '\''
        n -= len(SCALE)
    return SCALE[n] + suffix

def make_music(n, voices):
    for (rests, note_seq, time_seq) in voices:
        print '{',

        count = rests * 16

        while rests > 0:
            if rests >= 4:
                print 'r1',
                rests -= 4
            elif rests >= 2:
                print 'r2',
                rests -= 2
            elif rests >= 1:
                print 'r4',
                rests -= 1

        while count < n:
            time = 2**time_seq.next()
            print '%s%d' % (note(note_seq.next()), time),
            count += 64 // time
        print '}'

if __name__ == '__main__':
    make_music(9312, [
            (0, Fibonacci(12, 12), Fibonacci(4, 0)),
            (23, Fibonacci(12, 5), Fibonacci(5, 0)),
            (46, Fibonacci(12, 0), Fibonacci(3, 0)),
            (69, Fibonacci(12, -7), Fibonacci(2, 0))
            ])

Don’t have time for a fully explanatory post right now; I just wanted to get something on here so that the new blog doesn’t stagnate before it’s even started. So here’s a bullet-point-form introduction:

• Zendo is a game where players try to guess the Master’s secret rule by probing it with examples.
• Inductive logic is… the same thing, really, except generalised to not necessarily include players, a Master, or… plastic pyramids.
• Doing either of these things algorithmically is, in general, hard. But in an interesting way.

Also: colours!

This is a bit of an experiment. Until recently I thought the one-person-with-multiple-blogs-for-different-topics thing was a bad case of over-engineering. But I have a new theory that goes like this: none of you should have to read through my random thoughts on gardening and moustache-growth updates on the slight offchance that I might say something intelligent about computers or whatever. Unless you’re my stalker, in which case you should probably stop doing that.

So this is an attempt to keep the “nonsense that only I care about” stuff separate from the… well, the “nonsense that only I care about but is to do with computing”. It’s also supposed to motivate me to do something about the dozen or so projects I have on the backburner at any given time. (Hey, it could work. You never know.)

Stay tuned for ramblings on all things programming, software, and computer-science-and-engineering-y.