Graphviz Diagrams

The following images show regular 5x5 grids with a nearest neighbor, ring or complete topology:

I recently found out that drawing these kind of images is easily possible using Graphviz and Python. A small script that automates creation of these images with arbitrary number of rows and columns can be downloaded here. The script creates a .svg file, which can be conveniently postprocessed with Inkscape. Usage of the script is as follows:

python ./graphviz_grid.py <num_rows> <num_cols> <ring|nn|compl> <outfilename.svg>

Measure your fame!

It recently occurred to me that Google Plus shows the amount of accesses on every G+ profile. Greatly amazed that Google Plus facilitates so much narcissism, I wanted to track the amount of accesses to my profile over time.

Here are two small and very simple scripts that can be used to record and visualize the amount of accesses for a G+ profile.

g+.py downloads the current amount of accesses from a G+ profile page. I recommend making a cron job that executes it daily. It is also possible to track other people's 'fame', since the amount of accesses of a G+ profile is public.

g+viz.py simply visualizes the recorded amount of accesses over time. The practical value of these plots is that they can be used to estimate how much resonance is created by the activity on a given profile.

Spiral Matrix

Have you ever tried to assign integer values to a square matrix in spiral order? Eg. for a 5x5 matrix this would look as follows:

1	2	3	4	5
16	17	18	19	6
15	24	25	20	7
14	23	22	21	8
13	12	11	10	9

If this is what you have been lying wake at night for, here comes an iterative solution using Python/Numpy:

#!/usr/bin/env python

""" create a spiral array """

import numpy

def spiral(n):

     mat = numpy.zeros([n,n])

    dirs = [

        numpy.array([0,1]),  #right

        numpy.array([1,0]),  #down

        numpy.array([0,-1]), #left

        numpy.array([-1,0]), #up

    ]

    ptr = numpy.array([0,-1])

    ptr_prime = ptr

    cur_dir_ind = 0

    for i in range(1,n*n+1):

        #adjust direction if necessary

        while(True):

                ptr_prime = ptr + dirs[cur_dir_ind]

                if ptr_prime[0]<0 or ptr_prime[0]>=n or ptr_prime[1]<0 \\ 

                   or ptr_prime[1] >= n:

                        cur_dir_ind = (cur_dir_ind + 1) % len(dirs)

                elif mat[ptr_prime[0],ptr_prime[1]] > 0.0:

                        cur_dir_ind = (cur_dir_ind + 1) % len(dirs)

                else:

                    break

        #update ptr;

        ptr = ptr_prime

        mat[ptr[0],ptr[1]] = i

    

    return mat

7 Wonders

This post is about the board game 7 Wonders. Sometimes there is a bit of confusion about calculating the victory points from the green cards (scientific structures). Each of the green cards has a symbol (tablet, compass or gear). The player receives 7 victory points for a set of all three symbols and additionally the number of the symbols squared for every symbol. Moreover there is a purple 'joker' card (guild) that can count as any type of green card.

The following few lines of Python can be used to compute the maximum amount of victory points that can be obtained for a given amount of tablet, compass, gear and joker cards. It does this by recursively finding the best allocation for the purple joker cards.

 

#!/usr/bin/env python

""" compute max nr of points for science cards """

#type1 : gear

#type2 : tablet

#type3 : compass

def get_score(type1, type2, type3):

    a = type1**2+type2**2+type3**2

    b = min([type1, type2, type3]) * 7 #sets

   return a+b

def max_points(type1=0, type2=0, type3=0, joker=0):

    if joker==0:

        return get_score(type1, type2, type3)

    else:

        return max([

            max_points(type1+1,type2 , type3 , joker-1),

            max_points(type1 ,type2+1, type3 , joker-1),

            max_points(type1 ,type2 , type3+1, joker-1)

        ])

Exercise Sounds with SuperCollider

Imagine you are instructing a group of athletes doing circuit training. The circuit training consists of stress and relaxation phases, which will be repeated in multiple series. At the end of a series there is usually a longer relaxation phase ('Serienpause').

To determine beginning and end of the individual phases, it is straight forward to use a stopwatch. However, the stopwatch will draw away most of your attention and you will not be able to correct the athletes any longer. Therefore, an acoustic signal is desirable that indicates the individual phases. The waveform of the signal might look as shown below:

The pulses indicate the seconds during the stress phase and the noisy parts mark the relaxation phase.

Such an audio signal can be synthesized using a software synthesizer, eg. SuperCollider. An exemplary audio file that was created with SuperCollider can be listened to here. It consists of 3 series with 2 stress phases (30s), a relaxation phase (20s) and a longer relaxation phase at the end of the series (30s).

The SuperCollider code, that was used to generate the audio file, can be downloaded here. It can be easily adapted to account for other durations of the individual phases.

Presentations and Age-related Vision Changes

It is well known that people's vision degrades as they age. Imagine you are making slides for a presentation and want to optimize them for an audience with potential vision difficulties.

This script can be used to estimate how an elderly person  might perceive your slides (needs ImageMagick, GMIC). An example slide is shown below.

The script applies a general blur to the slides, a yellow tint to account for yellowing of the lens and reduced color vision. At last, it applies a vignette to account for the loss of peripheral vision.

Presenting a Bibtex Bibliography on a Website

Imagine you are given a long Bibtex file, that needs to be presented on a website. In order to achieve some flexibility in presenting the data, a MySQL database is to be used. This rules out alternatives such as bibtex2html, which creates static html pages.

A Python script that can be used to parse the Bibtex file and write it into the database can be downloaded here. Pybtex is used to conveniently parse the Bibtex file. The database layout for the different publication types (article, inproceedings, incollection, etc.) is hardcoded into the script, but should be easily adaptable to your needs.