Doswa

MathJax in Markdown

2011-07-20T00:00:00-07:00

I had some issues getting MathJax running smoothly alongside Markdown. The main issue stemmed from Markdown not providing a way to temporarily escape from its text transformations, so some L_AT^EX would get interpreted as Markdown.

The only way I know of to prevent text transformations in Markdown is through the code block (prefix with 4+ spaces) and inline code (surround with `) features. However, both of those wrap the result in some HTML tag (<pre> for the first, <code> for the second). I decided to use the inline code feature as the basis for inserting my math.

I can insert math by typing, for example `$ \del \cdot \vec{B} = 0 $`. To make this work, I had to use the following MathJax configuration:

MathJax.Hub.Config({
    tex2jax: {
        skipTags: ['script', 'noscript', 'style', 'textarea', 'pre']
    }
});

This prevents MathJax from skipping <code> tags. This could potentially cause issues if I used the sequences \(, \[, or $$ in a normal (non-math) code block, but I think it's safe to say that those sequences won't show up in most of my code.

The next step was to make sure MathJax <code> tags weren't actually styled like "normal" <code> tags. To do this, I added this to my MathJax configuration:

MathJax.Hub.Queue(function() {
    // Fix <code> tags after MathJax finishes running. This is a
    // hack to overcome a shortcoming of Markdown. Discussion at
    // https://github.com/mojombo/jekyll/issues/199
    var all = MathJax.Hub.getAllJax(), i;
    for(i = 0; i < all.length; i += 1) {
        all[i].SourceElement().parentNode.className += ' has-jax';
    }
});

with this in my CSS:

code.has-jax {font: inherit; font-size: 100%; background: inherit; border: inherit;}

Jekyll syntax highlighting with Pygments on Arch Linux

2011-07-19T00:00:00-07:00

I had some trouble getting Jekyll's syntax highlighting working on Arch Linux. Every time I added a code block using the {% highlight %} tag, the contents of the tag would just disappear.

My installation was:

# Install pacgem
$ wget https://aur.archlinux.org/packages/pacgem/pacgem.tar.gz
$ tar xzf pacgem.tar.gz
$ cd pacgem
$ makepkg -s
$ pacman -U pacgem-*.tar.xz

# Install Jekyll
$ pacgem jekyll

# Install Pygments
$ sudo pacman -S python-pygments

Jekyll uses the Albino wrapper for the Python Pygments library to handle syntax highlighting. My first test was to see if Albino was working correctly. I tested it out using the example from the project page:

    require 'albino'
    puts Albino.colorize('puts "Hello World"', :ruby)

Sure enough, there was no output. That meant I was on the right track: the issue was in Albino, not Jekyll. My next step was to figure out what Albino was doing internally to call pygmentize (the command line tool for Pygments). Albino spawns the pygmentize process on line 88 of /usr/lib/ruby/gems/1.9.1/gems/albino-1.3.3/lib/albino.rb. I inserted a puts command right before that line to see exactly what it was doing. The command it was calling internally looked like this:

pygmentize -l ruby -f html -O encoding=utf-8

To test it out, I ran the following:

$ echo 'puts "Hello World"' | pygmentize -l ruby -f html -O encoding=utf-8

*** Error while highlighting:
TypeError: Can't convert 'bytes' object to str implicitly
   (file "/usr/lib/python3.2/codecs.py", line 355, in write)

It's one of those dreaded Python 3 bytes/str issues. I decided to try leaving out the encoding to see if I could easily bypass the issue:

$ echo 'puts "Hello World"' | pygmentize -l ruby -f html
<div class="highlight"><pre><span class="nb">puts</span> <span class="s2">&quot;Hello World&quot;</span>
</pre></div>

Looks like it worked! There might be some encoding issues later on, so I made a mental note to test it out after I was done. The next step was to prevent Albino from adding the -O encoding=utf-8 part to the command. On line 78 of the Albino file mentioned above (lib/albino.rb), the command line options for pygmentize are set:

    @options = { :l => lexer, :f => format, :O => "encoding=#{encoding}" }

I just wanted to get Jekyll running, so I made a quick hack and removed the -O option:

    @options = { :l => lexer, :f => format }

I went back to by Albino test program and verified that things worked:

$ ruby -e "require 'albino'; puts Albino.colorize('puts \'Hello World\'', :ruby)" 
<div class="highlight"><pre><span class="nb">puts</span> <span class="s1">&#39;Hello World&#39;</span>
</pre>
</div>

Things were looking good! I went back to Jekyll and tried out a test page, and the highlighting seemed to work fine. One thing was left to check: did I screw anything up by removing the encoding from the command line call? I threw a couple non-ASCII characters in my code block as a test:

    # coding: utf-8
    # Calculate ∇·f(x,y,z), where f:ℝ³→ℝ³ is a vector field
    def divergence(x, y, z, ε=1e-10)
        f0 = yield(x,y,z)
        δx = (yield(x+ε,y,z)[0] - f0[0]) / ε
        δy = (yield(x,y+ε,z)[1] - f0[1]) / ε
        δz = (yield(x,y,z+ε)[2] - f0[2]) / ε
        δx + δy + δz
    end
    puts divergence(1,2,3) {|x,y,z| [-y,x*y,z]}

After rendering, it looked like it worked. My input text was in UTF-8, and I haven't tried anything else. There's a good chance it won't work if you use a different encoding.

Screenshot script for GNOME Shell

2011-05-01T00:00:00-07:00

I decided to ditch Compiz, but I missed the screenshot plugin that allows you to take a screenshot by holding a key and selecting a region of the screen with the mouse. I made this script to mimic this behavior in GNOME Shell.

    #!/usr/bin/env python

    import os
    import glob
    import subprocess
    import time

    # File to save to
    BASENAME = os.environ.get('HOME')+'/Desktop/screenshot'
    SUFFIX = '.png'

    # Delay after an ImageMagick `import` failure before trying again. This
    # is necessary because the mouse isn't always available right after
    # the Gnome Shell 'Activities' screen closes.
    DELAY = 0.1

    # Number of DELAYs before giving up. This is to keep from getting stuck
    # in an infinite loop in case the failure isn't because of the expected
    # reason.
    RETRIES = 10

    def choose_fname(basename, suffix):
        fnames = glob.glob(basename+'*'+suffix)
        max_id = 0
        for fname in fnames:
            id = fname[len(basename):-len(suffix)]
            try:
                id = int(id)
            except ValueError:
                continue

            if id > max_id:
                max_id = id
        return basename+str(max_id+1)+suffix

    def screenshot(fname):
        time.sleep(0.1)
        p = subprocess.Popen(('import', fname))
        returncode = p.wait()
        return returncode == 0

    def main():
        fname = choose_fname(BASENAME, SUFFIX)
        tries = 0
        while not screenshot(fname) and tries < RETRIES:
            time.sleep(DELAY)
            tries += 1

    if __name__ == '__main__':
        main()

Kaoss Guitar (Update 2)

2010-08-27T00:00:00-07:00

The touchscreen is now working. I'm using the internal pull-up resistor on the ADC pin to detect when the touchscreen isn't touched. The algorithm looks something like this:

    uint16_t x = touch_get_x();
    // ADC values go from 0-1023, so a value over 1000 indicates
    // that the screen isn't being touched and the resistor is
    // what's pulling the value high. The value when someone
    // is touching the screen varies from around 100 to 900.
    if(x > 1000) {
        // Screen is not being touched
    } else {
        // Screen is being touched
        x = touch_normalize_x(x);
        // ...
    }

AVRDUDE 5.10 with FTDI bitbang on Linux

2010-08-24T00:00:00-07:00

Programming an ATmega168 using SparkFun's FTDI Basic Breakout. This guide works for other FT232R-based devices as well.

First, install the dependencies. On Ubuntu 10.04, this should take care of all of them:

sudo apt-get install patch build-essential libreadline-dev libncurses-dev libusb-dev libftdi-dev automake autoconf bison flex
sudo apt-get build-dep avrdude avrdude-doc

Next, create a working directory for the build and cd into it:

mkdir avrdude
cd avrdude

Now download the D2xx driver from FTDI. Only download the one that corresponds to your OS (either 64 bit or 32 bit).

# For 64-bit:
wget http://www.ftdichip.com/Drivers/D2XX/Linux/libftd2xx0.4.16_x86_64.tar.gz
# For 32-bit:
wget http://www.ftdichip.com/Drivers/D2XX/Linux/libftd2xx0.4.16.tar.gz

Download AVRDUDE and the FTDI bitbang patches:

wget http://download.savannah.gnu.org/releases-noredirect/avrdude/avrdude-5.10.tar.gz
for i in 8 7 6 5 4 3 2 1 0; do wget -O patch-$i.diff http://savannah.nongnu.org/patch/download.php?file_id=1851$i; done

Extract everything, put the drivers into place, and apply the patches:

tar xzf avrdude-5.10.tar.gz
tar xzf libftd2xx*.tar.gz
cd avrdude-5.10
for file in ../patch-*.diff; do patch -p0 < $file; done
cp ../libftd2xx*/static_lib/* .
cp ../libftd2xx*/*.h .
cp ../libftd2xx*/*.cfg .

Configure and compile AVRDUDE.

./configure CFLAGS="-g -O2 -DSUPPORT_FT245R" LIBS="./libftd2xx.a.0.4.16 -lpthread -ldl -lrt"
make

If you're using SparkFun's FTDI Basic Breakout board, you can use the following to update your AVRDUDE configuration. If you're using some other FTDI breakout board, you'll need to modify the miso, sck, mosi, and reset options. FTDI has a listing of which bits correspond to which pins on page 1 of the bit-bang mode datasheet.

echo '
programmer
  id    = "ftdi";
  desc  = "SparkFun FTDI Basic Breakout";
  type  = ft245r;
  miso  = 1;  # RXD
  sck   = 3;  # CTS
  mosi  = 0;  # TXD
  reset = 4;  # DTR
;' >> avrdude.conf;

If you're using SparkFun's FTDI Basic Breakout, you can make your connections as follows. Otherwise, make your connections according to the pins you chose in the previous step (more details in my previous post on the subject.

FTDI -> MCU (ATmega168 PDIP pin)
--------------------------------
DTR -> RESET (1)
RXI -> MISO (18)
TXO -> MOSI (17)
5V -> VCC (7 & 20)
CTS -> SCK (19)
GND -> GND (8 & 22)

Now try it out to make sure everything worked. On Ubuntu, sudo is required because of the default permissions applied to USB devices. The -B 1 option sets the programming speed to the lowest possible. You can omit that option if your AVR is clocked higher than 8MHz. If this runs successfully, your AVR's high fuse byte should be printed to the terminal in hexadecimal.

sudo ./avrdude -C avrdude.conf -c ftdi -p m168 -P ft0 -U hfuse:r:-:h -B 1

If everything worked well, you can now install AVRDUDE.

# If you're using Ubuntu, you can use checkinstall to build a .deb package and install it:
sudo checkinstall
# Otherwise, just use `make install`:
sudo make install

You should now be able to use AVRDUDE without specifying a configuration file:

sudo avrdude -c ftdi -p m168 -P ft0 -U hfuse:r:-:h -B 1

Quantum lolcats

2010-07-02T00:00:00-07:00

"Funny fact: lolcats cannot be put in a Schroedinger state, because quantum rules don't work on a macro level." - qvantamon on MetaFilter

Kaoss Guitar (Update 1)

2010-04-18T00:00:00-07:00

For a while, a friend and I have been planning to build a specialized MIDI controller into a guitar to control a Korg Kaoss Pad KP2. The idea came from the guitar used by Matt Bellamy of Muse (check out a video of it).

We ordered the electronics for the guitar from SparkFun Electronics and Digi-Key. When the project is over, I plan to add up the total cost and post a bill of materials. I suspect it will total to around $100.

Today we tested out the 4.3" touchpad from SparkFun using an Arduino. I have just finished setting up an ATmega328P on a breadboard and got a basic blink program running. The final product will be running on a plain AVR without the Arduino libraries/bootloader.

One problem I ran into using my FTDI programmer was the clock rate. A fresh ATmega328P comes running at 1 MHz, significantly lower than the default 16 MHz on Arduino-prepared ATmegas. As a result, I kept getting errors like this:

david@second:~$ avrdude -c ftdi -p atmega168 -P ft0
avrdude: BitBang OK 
avrdude: pin assign miso 1 sck 3 mosi 0 reset 4
avrdude: drain OK 

 ft245r:  bitclk 230400 -> ft baud 115200
avrdude: ft245r_program_enable: failed
avrdude: initialization failed, rc=-1
         Double check connections and try again, or use -F to override
         this check.


avrdude done.  Thank you.

Eventually I found AVRDUDE's -B option. It adjusts the clock rate that's fed into the SCK pin on the AVR. I found that a value of -B 76800 works well, but if you're running into this problem, I recommend starting with -B 1 and going up until it stops working. To be explicit, this is the command that I found works:

david@second:~$ avrdude -c ftdi -p atmega168 -P ft0 -B 76800

Client-side Prediction

2010-04-03T00:00:00-07:00

I was reading about client-side prediction in the context of video game physics today and thought of an idea: client-side prediction on streamed video (e.g. on Skype or similar video chats). Each pixel could be assigned a velocity and "color velocity" ($ \frac{d \, \text{red}}{dt} $, $ \frac{d \, \text{blue}}{dt} $, $ \frac{d \, \text{green}}{dt} $). A velocity grid method like the one described in Practical Fluid Dynamics 1 and 2 comes to mind.

Using Cairo in Pygame

2010-03-29T00:00:00-07:00

This is a method of using Cairo with Pygame. It works by sharing the same block of memory for the Cairo drawing surface and the Pygame image surface. The only trick to it is making sure that Cairo and Pygame use the same format to store the pixel data in.

    #!/usr/bin/env python
    import cairo
    import pygame
    import math
 
    size = 400, 400
 
    # Initialize pygame with 32-bit colors. This setting stores the pixels
    # in the format 0x00rrggbb.
    pygame.init()
    screen = pygame.display.set_mode(size, 0, 32)
 
    # Get a reference to the memory block storing the pixel data.
    pixels = pygame.surfarray.pixels2d(screen)
 
    # Set up a Cairo surface using the same memory block and the same pixel
    # format (Cairo's RGB24 format means that the pixels are stored as
    # 0x00rrggbb; i.e. only 24 bits are used and the upper 16 are 0).
    cairo_surface = cairo.ImageSurface.create_for_data(
        pixels.data, cairo.FORMAT_RGB24, size[0], size[1])
 
    # Draw a white circle to the screen using pygame.
    radius = int(min(size)/2*0.7)
    pos = [int(a/2) for a in size]
    pygame.draw.circle(screen, (255,255,255), pos, radius)
 
    # Draw a smaller black circle to the screen using Cairo.
    context = cairo.Context(cairo_surface)
    context.set_source_rgb(0, 0, 0)
    context.arc(size[0]/2, size[1]/2, min(size)/2*0.5, 0, 2*math.pi)
    context.fill()
 
    # Flip the changes into view.
    pygame.display.flip()
 
    # Wait for the user to quit.
    while pygame.QUIT not in [e.type for e in pygame.event.get()]:
        pass

Tested on Python 2.6.4, pycairo 1.8.6, Cairo 1.8.8, pygame 1.8.1, numpy 1.3.0.

Relation between motor's torque/speed and its voltage/current.

2010-01-23T00:00:00-08:00

The torque of a motor is proportional to the current flowing through it ($\tau \propto i$).
The angular velocity of a motor is proportional to the voltage across it ($\omega \propto v$).

Details and derivation here: motor.pdf.

Wacom Jitter Fix (for Linux)

2010-01-01T00:00:00-08:00

My Wacom Bamboo Fun tablet has been exceptionally jittery on my Lenovo ThinkPad. I assume this is probably caused by EM noise from the computer (though I'm not sure). [Update: it's actually caused by a noisy power supply.] Today I decided I should try to fix that.

Here's an image to demonstrate the problem (click to enlarge):

On Ubuntu, there's a package called wacom-tools that includes a configuration utility named xsetwacom. The xsetwacom utility has a couple parameters to help against noise: RawSample and Suppress. RawSample allows you to adjust the number of samples taken from the tablet before the coordinates are committed to the mouse pointer on screen. Suppress prevents the mouse pointer from moving unless it has been moved by a given amount. So, all you need to do is tune those parameters to something that works well for your setup. I found the following to be acceptable:

xsetwacom set "Wacom BambooFun 4x5" RawSample 9
xsetwacom set "Wacom BambooFun 4x5" Suppress 10

Note that those commands are specifically for the Wacom BambooFun 4x5 tablet. You will probably need to replace that part with something else. You can find out what you should replace it with by executing this command and looking over its output:

xidump --list

Now, I wanted these commands to be run automatically every time I logged in, so I created a small script at ~/.local/bin/wacom_init and put the following in it:

    #!/bin/sh
    xsetwacom set "Wacom BambooFun 4x5" RawSample 9
    xsetwacom set "Wacom BambooFun 4x5" Suppress 10

Finally, I went in my menu to System → Preferences → Startup Applications and created an entry to automatically run the command /home/david/.local/bin/wacom_init.

All done!

DIY aux input on Alpine car stereo (M-BUS)

2010-01-01T00:00:00-08:00

If anything in this article is unclear or confusing, please let me know in the comments and I'll do my best to clarify.

Disclaimer: by following the instructions below, you may end up destroying your stereo, car, MP3 player, interpersonal relationships, and everything else you hold dear. I am not responsible for any of this. That being said, it worked fine for me.

This method will work on any Alpine stereos with an 8-pin M-BUS connector in the back. (The stereo I performed this on was an Alpine CDM-9821.) The connector itself should look something like this:

After some searching around, I located the functions of each pin on this connector at pinouts.ru. The pins on interest are the bottom three:

This corresponds perfectly with the contacts on a 3.5mm headphone plug:

So all that's left to do is make an adapter between the two. I ordered these parts from Digi-Key: CP-1080-ND, AE9918-ND, and CP1-3513-ND.

Gather up some solder, a soldering iron, and wire. Make the following connections:

"Audio Ground" pin from the M-BUS connector goes to the pin closest to the hole on the 3.5mm audio jack
"Right Audio Input" goes to the pin farthest from the hole
"Left Audio Input" goes to the only remaining pin.

You should end up with an adapter cable like this:

Plug the M-BUS connector into the back of your stereo and mount the audio jack somewhere on the dash.

Now turn on your car. If all went well, nothing will start on fire. Hold the "Setup" button on the stereo and enable aux input in the menu. Now hit the "Source" button until you get to AUX. At this point, you should be able to plug in an MP3 player and have the audio routed to your car's speakers.

Python/Unix Calculator

2010-01-01T00:00:00-08:00

    david@second:~$ cat /home/david/.local/bin/=

    #!/usr/bin/env python
    __import__("sys").argv[1:] and __import__("subprocess").Popen(("bc","-lq"),?
    stdin=__import__("subprocess").PIPE).communicate(" ".join(__import__("sys")?
    .argv[1:]+["\n"])) or __import__("os").waitpid(__import__("subprocess")?
    .Popen(("bc","-lq")).pid,0)

    david@second:~$ = '5*5 + 5'
    30
    david@second:~$ =
    3+1
    4
    last*2
    8
    david@second:~$

SparkFun's FTDI Basic Breakout as an AVR programmer

2009-12-20T00:00:00-08:00

This guide has been merged into my AVRDUDE 5.10 bitbang guide. Original post follows (left here for reference).

Now open up avrdude.conf in a text editor. Add this entry by the other programmers:

# FTDI basic breakout
programmer
  id = "ftdi";
  desc = "FTDI Basic Breakout";
  type = ft245r;
  miso = 1; # RxD
  sck = 3; # CTS
  mosi = 0; # TxD
  reset = 4; # DTR
;

Now you can attach your FTDI Breakout to the target AVR like this:

FTDI -> MCU (ATmega168 PDIP pin)
--------------------------------
DTR -> RESET (1)
RXI -> MISO (18)
TXO -> MOSI (17)
5V -> VCC (7 & 20)
CTS -> SCK (19)
GND -> GND (8 & 22)

With the 3x2 ICSP header on the Arduino, that would look like this:

        +----------------+
[RXI]--o| 1 MISO   +5V 2 |o--[5V]
[CTS]--o| 3 SCK   MOSI 4 |o--[TXO]
[DTR]--o| 5 RESET  GND 6 |o--[GND]
        +----------------+

Note that may need to supply the AVR with an external oscillator or clock source. For virgin ATmega168s, you won't need to (because it initially uses the internal oscillator), but you'll need an external crystal oscillator if you're using one that came out of an Arduino.

From there you can use AVRDUDE like normal using the -c ftdi switch. For example, to read fuse bytes:

sudo ./avrdude -C avrdude.conf -c ftdi -p m168 -P ft0 -U hfuse:r:-:h -U lfuse:r:-:h -U efuse:r:-:h

Edit 2010-04-18:

I just found out that new AVRs need to have the clock rate adjusted before this will work. This is because AVRs come with the internal clock set to 1 MHz (actually, 8 MHz with the CKDIV8 fuse bit set) instead of the Arduino default 16 MHz. This can be done with AVRDUDE's -B option. This option determines what clock is fed into the AVR's SCK pin. I recommend starting with a value of -B 1 and working your way up to a reasonable clock speed. Here is the adjusted command for new AVRs:

sudo ./avrdude -C avrdude.conf -c ftdi -p m168 -P ft0 -U hfuse:r:-:h -U lfuse:r:-:h -U efuse:r:-:h -B 1

Accessing AVR GPIOs via bit fields

2009-12-08T00:00:00-08:00

I noticed that the TMS320F2809 examples accessed GPIOs by bits rather than as 32-bit ints. For example, it's possible to set a GPIO like this on the TMS320F280x:

    GpioDataRegs.GPADAT.bit.GPIO12 = 1; // Sets GPIO12 to high.

Normally when working with AVRs, I would set bits like this:

    PORTB |= (1<<PB3); // Sets port b, bit 3 to high.

After a bit of tinkering, I came up with this (for AVRs):

    portb.bit.b3 = HIGH; // Sets port b, bit 3 to high.

I personally think it looks a bit cleaner, so I'll probably be using it in the future. If you're interested in trying it out, you can download a full example here: bitfields.zip.

Side note: It is also possible to access GPIOs as 32-bit ints on the TMS320F280x like this:

    GpioDataRegs.GPADAT.all |= (1<<12); // Sets GPIO12 to high.

Edit: Looks like I'm not alone.

Computers are toys, not tools.

2009-08-25T00:00:00-07:00

RK4 in Haskell

2009-07-31T00:00:00-07:00

Ran across this today. It's a well written implementation of RK4.

4th order Runge-Kutta (RK4) integration in Haskell

Line Segment to Circle Collision/Intersection Detection

2009-07-13T00:00:00-07:00

Style and Notation

All variables are represented in italics except in the diagrams and Python code.
Vectors are shown in bold except in the diagrams and Python code.
The notation |a| is used to represent the length of a vector named a.

Introduction to the problem

Start by defining a few points (vectors from the world origin):

Now, from these points, you can easily calculate two useful values, the segment vector, seg_v (from seg_a to seg_b) and the position of circ_pos relative to seg_a, pt_v.

seg_v = seg_b - seg_a

pt_v = circ_pos - seg_a

Closest point to the circle's center on the segment

The next step is to find the closest point to the circle's center on the segment (labeled "closest" on the diagram). To do this, we must project pt_v onto seg_v:

To project on vector onto another, take the dot product of the vector and the unit vector of the projection target. That is:

$$|proj_v| = \mathbf{pt_v} \cdot \frac{\mathbf{seg_v}}{|seg_v|}$$

Note that this dot product returns a scalar value (the length of proj_v), not a vector.

We now need to take a small break from the main goal and look into a special case: the ends of the segment. If |proj_v| is less than 0 or greater than |seg_v|, the closest point to circ_pos on the segment will be one of the segment's endpoints. That is:

if |proj_v| < 0:
    closest = seg_a
if |proj_v| > |seg_v|:
    closest = seg_b

Next, calculate the actual proj_v vector, rather than just its length (|proj_v|). To do this, simply multiply by the seg_v unit vector:

$$\mathbf{proj_v} = |proj_v| \frac{\mathbf{seg_v}}{|seg_v|}$$

The only thing left to do is to convert this into world coordinates (rather than coordinates relative to seg_a) to get the closest point:

closest = seg_a + proj_v

Checking for a intersection

Now that we've calculated the closest point on the segment (the variable "closest"), we can check if the circle and segment intersect. To do this, first find the vector from closest to circ_pos:

dist_v = circ_pos - closest

If the length of this vector is less than the circle's radius, the circle and segment are intersecting:

if |dist_v| < circ_rad:
    They are intersecting
else:
    They are not intersecting

Collision response

A useful bit of data in collision response is the amount of overlap between two shapes and the direction a shape must be moved in order to resolve the collision. This can be represented as a vector that points in the same direction as dist_v whose length is equal to the difference between circ_rad and |dist_v|.

$$\mathbf{offset} = (circ_{rad} - |dist_v|) \frac{\mathbf{dist_v}}{|dist_v|}$$

Python implementation

Here is a Python implementation of everything in this post. For the sake of clarity, I avoided optimizations. vec is assumed to be a fully implemented 2d vector class:

    def closest_point_on_seg(seg_a, seg_b, circ_pos):
        seg_v = seg_b - seg_a
        pt_v = circ_pos - seg_a
        if seg_v.len() <= 0:
            raise ValueError, "Invalid segment length"
        seg_v_unit = seg_v / seg_v.len()
        proj = pt_v.dot(seg_v_unit)
        if proj <= 0:
            return seg_a.copy()
        if proj >= seg_v.len():
            return seg_b.copy()
        proj_v = seg_v_unit * proj
        closest = proj_v + seg_a
        return closest

    def segment_circle(seg_a, seg_b, circ_pos, circ_rad):
        closest = closest_point_on_seg(seg_a, seg_b, circ_pos)
        dist_v = circ_pos - closest
        if dist_v.len() > circ_rad:
            return vec(0, 0)
        if dist_v.len() <= 0:
            raise ValueError, "Circle's center is exactly on segment"
        offset = dist_v / dist_v.len() * (circ_rad - dist_v.len())
        return offset

Similar algorithms

Collisions involving stadiums (a type of rounded rectangle) can be calculated in a similar manner. A stadium is essentially a line segment with a radius.

A stadium-point collision is the same as a segment-circle collision with a circle whose radius is equal to the stadium's radius.

A stadium-circle collision is the same as a segment-circle collision with a circle whose radius is equal to the sum of the original circle's radius and the stadium's radius.

Download

segment_circle.zip - An implementation in Python and Cython.

If you find this post useful or have any questions, please leave a comment.

JavaScript Image Animation

2009-06-24T00:00:00-07:00

I made a small script to produce an animation with a series of images and JavaScript. I only tested it in Firefox 3, but I don't see any reason why it wouldn't work in other browsers.

Try it or download it.

Sage Bug #1483 inspired me to make this, since the sagenb.org server doesn't have ImageMagick installed.

PHPNotify: Debug Notifications From PHP

2009-05-13T00:00:00-07:00

This is a little program to help debug AJAX (or anything else) from PHP.

Read the README file to instructions on setting it up on Ubuntu. Note that you must first install python-notify through apt-get for this to work correctly.

Download PHPNotify

If the function name notify() conflicts with any of your functions, you can change it on lines 2 and 3 of prepend.php

Improved RK4 Implementation

2009-04-21T00:00:00-07:00

This is a Python implementation of the RK4 numerical integrator that works with differential functions of all orders. That is, any function in the form $ F(x, y, y\prime, y\prime\!\prime, \dots, y^{(n)}) $.

If you're new to numerical integration or even RK4 integration, please read my other post first. It's easier to understand because it's a less generalized function.

    def rk4(t0, h, s0, f):
        """RK4 implementation.
        t = current value of the independent variable
        h = amount to increase the independent variable (step size)
        s0 = initial state as a list. ex.: [initial_position, initial_velocity]
        f = function(state, t) to integrate"""
        r = range(len(s0))
        s1 = s0 + [f(t0, s0)]
        s2 = [s0[i] + 0.5*s1[i+1]*h for i in r]
        s2 += [f(t0+0.5*h, s2)]
        s3 = [s0[i] + 0.5*s2[i+1]*h for i in r]
        s3 += [f(t0+0.5*h, s3)]
        s4 = [s0[i] + s3[i+1]*h for i in r]
        s4 += [f(t0+h, s4)]
        return t+h, [s0[i] + (s1[i+1] + 2*(s2[i+1]+s3[i+1]) + s4[i+1])*h/6.0 for i in r]

An example usage of this function is:

    def damped_spring_accel(t, state):
        x = state[0]
        v = state[1]
        stiffness = 1
        damping = 0.005
        return -stiffness*x - damping*v

    t = 0
    h = 1/40.0
    s = [50, 5]

    while t<100:
        t, s = rk4(t, h, s, damped_spring_accel)
    print "Final state: t=%.2f x=%.2f v=%.2f"%(t,s[0],s[1])

On a side note, I recently found out about Sage (sagemath.org and sagenb.org). Its plotting capabilities and convenient mathematical notation are especially useful. Plus, it uses Python!

Chain (warning: Java inside)

2009-01-24T00:00:00-08:00

I made a little Processing sketch based on the same physics as JavaScript physics.

Source code: Chain Link

JavaScript physics

2009-01-16T00:00:00-08:00

I made a very basic physics demo in JavaScript to practice using the MooTools library. It uses Verlet integration as outlined in Thomas Jakobsen's paper.

To try out the demo, go to the demo page.

Generalizing derivatives and integrals

2009-01-03T00:00:00-08:00

Disclaimer: This is sloppy math. Don't take it too seriously.

Start with a simple expression, $ x^k $, and take a few derivatives:

$$ \frac{\partial}{\partial x} x^k = k x^{k-1} $$

$$ \frac{\partial^2}{\partial x^2} x^k = (k-1) k x^{k-2} $$

$$ \frac{\partial^3}{\partial x^3} x^k = (k-2) (k-1) k x^{k-3} $$

$$ \frac{\partial^4}{\partial x^4} x^k = (k-3) (k-2) (k-1) k x^{k-4} $$

A pattern is emerging:

$$ \frac{\partial^n}{\partial x^n} x^k = (k-n+1)...(k-1)k x^{k-n} = c x^{k-n} $$

where c is the coefficient.

Now the hard part is finding the pattern in the coefficient. This needs to be taken out of the '...' form. Focus on that:

$$ c = (k-n+1)...(k-1)k $$

This is a series of numbers, each one larger than the next. This looks like a factorial, so divide k! by that:

$$ \frac{k!}{c} = \frac{k!}{(k-n+1)...(k-1)k} = \frac{1(2)(3)...k}{(k-n+1)...(k-1)k} $$

Note how the top goes from 1 to k and the bottom goes from k-n+1 to k. That means that k-n+1 to k is a subset of 1 to k, so just divide that part out:

$$ \frac{k!}{c} = \frac{1(2)(3)...k}{(k-n+1)...(k-1)k} = 1(2)(3)...(k-n) = (k-n)! $$

Now solve for c:

$$ \frac{1}{c} = \frac{(k-n)!}{k!}$$, so $$c = \frac{k!}{(k-n)!} $$

Puts this back into the original equation to get:

$$ \frac{\partial^n f(x)}{\partial x^n} = c x^{k-n} = \frac{k!}{(k-n)!} x^{k-n} $$

So, the $ n^{\text{th}} $ derivative of $ x^k $ is equal to:

$$ \frac{k!}{(k-n)!} x^{k-n} $$

Verify this with a couple of derivatives:

$$ \frac{\partial}{\partial x} x^2 = \frac{k!}{(k-n)!} x^{k-n} = \frac{2!}{(2-1)!} x^{2-1} = \frac{2}{1} x^1 = 2x $$

$$ \frac{\partial^2}{\partial x^2} 4 x^4 = 4 (\frac{k!}{(k-n)!}) x^{k-n} = 4 (\frac{4!}{(4-2)!}) x^{4-2} = 4 (\frac{24}{2}) x^2 = 4(12) x^2 = 48 x^2 $$

And a couple of integrals:

$$ \frac{\partial^{-1}}{\partial x^{-1}} x^2 = \frac{k!}{(k-n)!} x^{k-n} = \frac{2!}{(2+1)!} x^{2+1} = \frac{2}{6} x^3 = \frac{1}{3} x^3 $$

$$ \frac{\partial^{-7}}{\partial x^{-7}} 3 x^4 = 3 (\frac{k!}{(k-n)!}) x^{k-n} = 3 (\frac{4!}{(4+7)!}) x^{4+7} = 3 (\frac{24}{39916800}) x^{11} = \frac{1}{554400} x^{11} $$

Extending derivatives and integrals into fractions

2009-01-03T00:00:00-08:00

Disclaimer: This is sloppy math. Don't take it too seriously.

In the previous post, I wrote about a way to generalize derivatives and integrals into one function. What happens if a number other than an integer is passed to that function?

Here is the generalization from the last post:

\[ \frac{\partial^n}{\partial x^n} x^k = \frac{k!}{(k-n)!} x^{k-n} \]

Set k = 2 and n = 1/2:

\[ \frac{\sqrt{\partial}}{\sqrt{\partial x}} x^2 = \frac{2!}{(2-\frac{1}{2})!} x^{2-\frac{1}{2}} = \frac{2!}{1.5!} x^{1.5} \]

Now there's a problem. Since a! is only defined for integers 0 or greater, a different way of calculating factorials is needed. Luckily, there exists a Gamma function defined for all real and complex numbers such that:

\[ \Gamma(n+1) = n! \]

Substitute the Gamma function into the other equation and simplify:

\[ \frac{\sqrt{\partial}}{\sqrt{\partial x}} x^2 = \frac{2!}{1.5!} x^{1.5} = \frac{2}{\Gamma(1.5+1)} x^{1.5} = \frac{2}{\Gamma(2.5)} x^{1.5} = \frac{2}{(\frac{3 \sqrt{\pi}}{4})} x^{1.5} \] \[ = \frac{2}{1} (\frac{4}{3 \sqrt{\pi}}) x^{1.5} = \frac{8}{3 \sqrt{\pi}} x^{1.5} = \frac{8 \sqrt{\pi}}{3 \pi} x^{1.5} \approx 1.505 x^{1.5} \]

So, the half derivative of $ x^2 $ is approximately equal to $ 1.505 x^{1.5} $.

This can be used for 'fractional integration' as well, if a negative number is used for n.

Fourth order Runge-Kutta numerical integration

2009-01-02T00:00:00-08:00

Here's a Python implementation of RK4, hardcoded for double-integrating the second derivative (acceleration up to position). For a more generalized solution, see my other implementation. I tried to keep this as simple as I could, so people can easily see the relation between the 'math form' and 'code form' of the algorithm.

    def rk4(x, v, a, dt):
        """Returns final (position, velocity) tuple after
        time dt has passed.

        x: initial position (number-like object)
        v: initial velocity (number-like object)
        a: acceleration function a(x,v,dt) (must be callable)
        dt: timestep (number)"""
        x1 = x
        v1 = v
        a1 = a(x1, v1, 0)

        x2 = x + 0.5*v1*dt
        v2 = v + 0.5*a1*dt
        a2 = a(x2, v2, dt/2.0)

        x3 = x + 0.5*v2*dt
        v3 = v + 0.5*a2*dt
        a3 = a(x3, v3, dt/2.0)

        x4 = x + v3*dt
        v4 = v + a3*dt
        a4 = a(x4, v4, dt)

        xf = x + (dt/6.0)*(v1 + 2*v2 + 2*v3 + v4)
        vf = v + (dt/6.0)*(a1 + 2*a2 + 2*a3 + a4)

        return xf, vf

Here is an example usage of the function and a comparison to Euler integration:

    def accel(x, v, dt):
        """Determines acceleration from current position,
        velocity, and timestep. This particular acceleration
        function models a spring."""
        stiffness = 1
        damping = -0.005
        return -stiffness*x - damping*v

    t = 0
    dt = 1.0/40 # Timestep of 1/40 second
    state = 50, 5 # Position, velocity
    euler = 50, 5 # For comparison with Euler integration

    print "Initial    -position: %6.2f, velocity: %6.2f"%state

    # Run for 100 seconds
    while t < 100:
        t += dt
        state = rk4(state[0], state[1], accel, dt)

        # Integrate using Euler's method
        euler = (
            euler[0] + euler[1]*dt,
            euler[1] + accel(euler[0],euler[1],dt)*dt
        )

    print "Final RK4  -position: %6.2f, velocity: %6.2f"%state
    print "Final Euler-position: %6.2f, velocity: %6.2f"%euler

The output of this really shows how much more accurate RK4 integration can be:

Initial    -position:  50.00, velocity:   5.00
Final RK4  -position:  52.18, velocity:  38.05
Final Euler-position: 178.38, velocity: 137.62

As the timestep is decreased (meaning more computation), Euler approaches RK4 (shown at timestep of 1/400 seconds):

Initial    -position:  50.00, velocity:   5.00
Final RK4  -position:  52.28, velocity:  37.92
Final Euler-position:  59.20, velocity:  43.02