If you have a filename or list of filenames, you may want to strip the extension. There are a few ways of “detecting” which part of the filename is the extension, but may not work if your file has multiple extensions (e.g. .tar.gz), contains spaces or periods, or meets other weird criteria. If you know what the extension is, or at least how long it is, you can just pull those characters off the end. This can be done with the ${<varname>::0-<n>} syntax, which will strip <n> characters off the end.

For example, the following code:

echo ${fname::0-4}

will print


It can sometimes be useful to estimate the Snellen or logMAR acuity of a patient based on the size of the font they read at near. While there are tables available showing the conversions, this can not cover all font sizes and reading distances. With some basic trigonometry, you can do the calculations yourself.

First, let’s draw out the problem:

Here, d is the reading distance and h is the height of the letter read by the patient. If the chart uses the N scale, the letter size is measure in points where N1 = 1 point = 1/72 inches.

Let’s assume the patient reads N5 (h) at a distance of 40cm (d). We need d and h to be in the same units, so we convert N5 to metric like so:

N5 = 5/72 inches = 0.0694 inches
1 inch = 2.54cm
Therefore N5 = 0.0694 x 2.54 = 0.176cm

From here we have a small adjustment to make; font sizes are measured as the height from the lowest tail to the highest stem or accent of any letter in that font. This is known as the em height – This wikipedia article explains this concept in detail. The character | is a rough estimation of em height, but most letters are much smaller than that – around the same hight as the letter x. This x-height is what we want to use in our calculation. While this differs between fonts, it is usually around half of the em height, so we multiply our value by 0.5:

h = 0.176 x 0.5 = 0.088cm.

So we have d = 40cm and h = 0.088cm. From here we can calculate Θ:

Θ = atan(h/d) = atan(0.088/40) = 0.126° = 7.6 minutes of arc

Finally, we need to convert Θ to our Snellen fraction. We know than 6/6 (or 20/20) corresponds to an optotype subtending 5 minutes of arc. We can therefore calculate MAR (minimum angle of resolution) as:

MAR = Θ/5 = 7.6/5 = 1.5

and from here, the logMAR and Snellen equivalents:

logMAR = log(1.5) = 0.18

Snellen = 6/(6xMAR) = 6/(6×1.5) = 6/9

Therefore, N5 is approximately equivalent to 6/9 at a distance of 40cm.

Imagine you have two text files, one with a list of names and another with a list of birth dates, which each name corresponding to the date of birth on the same line number in the other file, like so:

Anthony Kiedis
Chad Smith
John Frusciante

You would like to join these files together into one file with the format <name>:<date_of_birth>. In linux, this can be done with paste, like so:

paste -d':' names.txt dob.txt

Here, -d is the delimiter option. This specifies which character separates data from file 1 and file 2. Running the command above produces this output:

Anthony Kiedis:1-Nov-1962
Chad Smith:25-Oct-1961
John Frusciante:5-Mar-1970

Rotating axis labels in Gnuplot

Posted: 27th October 2015 by Tim in Gnuplot
Tags: , , , , , , , ,

In gnuplot, labels on the X and Y axes are aligned horizontally by default, and written over the top of each other if the labels are too long. To fix this, you can rotate the labels using the set xtics rotate [by <angle>] [left|right] command. For example, you can rotate x-axis labels by 60 degrees with the following code:

set xtics rotate by 60 right

We use right alignment here, otherwise the labels run from the base of the graph upwards.

The following full gnuplot code:

set terminal svg
set format x '%+-.6f' # to make the labels longer
set xtics rotate by 60 right
plot cos(x)

will generate this graph:

Your browser doesn’t support SVG, sorry

Bash gotcha: function variable scope

Posted: 11th October 2015 by Tim in Bash, Linux
Tags: , , , , , , ,

Consider the following bash script:

#!/usr/bin/env bash

function myFunc
    echo "myFunc: setting myvar=$myvar"

echo "before myFunc: myvar=$myvar"
echo "after myFunc: myvar=$myvar"

The code here is fairly simple – we set a variable myvar, call a function and print the value of myvar to the terminal. However, even though we don’t pass myvar to the function, that value is still changed:

before myFunc: myvar=1
myFunc: setting myvar=123
after myFunc: myvar=123

Somehow, myFunc changed the value of myvar. This is because, unless specified otherwise, this variable is in the global scope. This can sometimes be useful, but it can also be confusing for programmers used to the scoping rules of other languages.

To keep myvar contained to function scope only, we can use the local keyword like so:

function myFunc
    local myvar=123
    echo "myFunc: setting myvar=$myvar"

With this specified, the code behaves more like we would expect:

before myFunc: myvar=1
myFunc: setting myvar=123
after myFunc: myvar=1

How to get a Makefile directory path

Posted: 27th September 2015 by Tim in Linux, Make
Tags: , , , , , ,

Sometimes in a Makefile you need to reference something from the directory where the Makefile lives. $(PWD) won’t work in this instance, since that will return the path from where make was called which may be different if, for example, you use the --directory option. In this case, we can use the following code to find Makefile’s directory:

$(dir $(realpath $(firstword $(MAKEFILE_LIST))))

Let’s pull this apart and look at each component. For this example, our Makefile path is /tmp/path/to/my/Makefile and contains the following:

include other/Makefile
	@echo $(PWD)
	@echo $(dir $(realpath $(firstword $(MAKEFILE_LIST))))

First, MAKEFILE_LIST will contain all of the Makefiles which have been loaded. If you havent’t included any others, only one will be listed here:
$(MAKEFILE_LIST) = Makefile other/Makefile

Since we’re only interested in the current Makefile, we strip off the includes:
$(firstword $(MAKEFILE_LIST)) = Makefile

Now that we have one file, find the absolute path:
$(realpath $(firstword $(MAKEFILE_LIST))) = /tmp/path/to/my/Makefile

Finally, strip off the file name, leaving only the directory path:
$(dir $(realpath $(firstword $(MAKEFILE_LIST)))) = /tmp/path/to/my/

So, if we call make --directory=/tmp/path/to/my default from the /tmp directory, the following will be printed:


If you’re interested in the path of the last included Makefile, use lastword instead of firstword. For example, you may use lastword from other/Makefile to find that directory.

Power crosses are useful diagrams for doing lens power calculations in optics. Drawing the power crosses in LaTeX can be tedious, especially if you need to draw multiple power crosses in the same document. The code below creates a new command, \powercross{front@90}{front@180}{back@90}{back@180}, which will draw the power crosses for you and calculate the final lens power based on the powers of the front and back lens surfaces. All values will be rounded to two decimal places.

Note: you need have \usepackage{fp} in the preamble in order for this code to work.

% usage: \powercross{front@90}{front@180}{back@90}{back@180}
        % crosses

        % arithmetic symbols

        % calculate resulting lens (requires fp)

        % labels

For example, this code:


will produce the following:

Power cross diagram generated in LaTeX

If you’re using a linux terminal and need to convert all upper case characters to lowercase, there are a number of ways you can do it. One of the easiest is to use tr:

tr '[:upper:]' '[:lower:]'

For example:

$ echo "HeLlo WOrlD" | tr '[:upper:]' '[:lower:]'
hello world

:upper: and :lower: can be reversed if you want to create an upper case string instead:

$ echo "HeLlo WOrlD" | tr '[:lower:]' '[:upper:]'

Accessing fields by index in Awk

Posted: 11th August 2015 by Tim in Awk
Tags: , , , , ,

In awk, fields are accessed by number; $1 for the first field, $2 for the second, etc. But sometimes the field number you want to access is not known until run time. In these cases, you can access the field using the $(<index>) syntax. The constant NF contains the number of fields available.

For example, you can print all fields with their field index like so:

echo "Hello, World" | awk '{ for (i = 1; i <= NF; ++i) { print i, $(i); } }'

The code above will print:

1 Hello,
2 World

Reading a file line by line in Bash

Posted: 26th July 2015 by Tim in Bash, Linux
Tags: , , , , , , ,

There are a few ways to read a file in bash, each with their own caveats. If you’re looking to read a file line-by-line verbatim, including blank lines, then using a simple while loop should do the trick. For example, the following code will print the contents of a file with line numbers:

while IFS='' read -r line

    echo "$line_no: $line"
done < /etc/kderc

This will print something like:

1: [Directories]
2: kioskAdmin=root:
3: profileDirsPrefix=/usr/share/kde-settings/kde-profile/
4: userProfileMapFile=/etc/kde-user-profile
6: [Directories-default]
7: prefixes=/usr/share/kde-settings/kde-profile/default/

Creating temporary files in Java

Posted: 9th July 2015 by Tim in Java
Tags: , , , , ,

Sometimes it is necessary to use temporary files in your program. One concern when creating these files is thread safety; two processes creating a temporary file with the same name. This concern can be largely ignored using Java’s File.createTempFile, which guarantees the file path is unique amongst all java processes running on that JVM.

For example:

import java.io.File;
import java.io.IOException;

class TempFile {
    public static void main(String[] args) throws IOException {
        File tempFile = File.createTempFile("prefix_", "_suffix");

will print something like:

Pause in Bash

Posted: 27th June 2015 by Tim in Bash, Linux
Tags: , , , , , , ,

Sometimes it is useful to pause a script until the user is ready to proceed. In Windows Batch scripting, this can be done with the PAUSE command. In Bash, the same thing can be done using read with the right parameters:

read -rn1 -p "Press any key to continue"

This command is doing the following:

  • -r disables backslash escaping. Without this option, typing only \ will not continue execution.
  • -n1 instructs the command to read only one character.
  • -p "Press any key..." is the prompt, or message printed to the screen.

Note that, like Batch’s PAUSE command, some keys which don’t result in a character being typed, like ALT, CTRL, SHIFT and CAPS LOCK, will not continue execution. Most other keys will work though.

Small Angle Approximations and Skinny Triangles are concepts which simplify trigonometric calculations. The concept is based on right-angle or isosceles triangles where one side is very small compared to the other two. In these cases, some approximations can be made in place of trigonometric calculations, which may be used for estimations when information required to compute an exact value is missing, or where an estimated value is good enough.

Consider the following triangle:

Small Angle Approximation - 45 degree triangle

On this right-angle triangle, the blue arc a represents the the edge of a circle if the shape was a slice of a full circle (ie: the shape bounded by the green, blue and bottom black lines would be a portion of a circle). From this, we see that r represents the radius of the circle, y is the triangle height and h is the hypotenuse. Θ is the angle from the middle of the circle, which we represent in radians for this approximation.

When Θ = π/4 (0.785 radians / 45°) as shown above, we can’t see any obvious relationship between these values:
when r = 100:
h = 141.4
y = 100
a = 78.5
sinΘ = 0.707
tanΘ = 1
cosΘ = 0.707
1 – (Θ²/2) = 0.692

But watch what happens as Θ decreases (all triangles drawn to scale).

Small Angle Approximation - 26.6 degree right angle triangle

Θ = 0.464 radians (26.6°)
when r = 100:
h = 111.8
y = 50
a = 46.4
sinΘ = 0.448
tanΘ = 0.500
cosΘ = 0.894
1 – (Θ²/2) = 0.892

Small Angle Approximation - 14.0 degree right-angle triangle

Θ = 0.244 radians (14.0°)
when r = 100:
h = 103.1
y = 25
a = 24.4
sinΘ = 0.242
tanΘ = 0.249
cosΘ = 0.970
1 – (Θ²/2) = 0.970

As you can see, for small values of Θ:

  • rh
  • ya
  • sinΘtanΘΘ
  • cosΘ ≈ 1 – (Θ²/2)

As Θ approaches zero, the errors in these approximations also approach zero. As you can see, Θ doesn’t need to be that small for these approximations to be accurate enough for quick calculations. These approximations are used in a number of fields, as diverse as astronomy, optics and aircraft navigation to name a few.

Awk is a useful language for many command line tasks. Often awk is used on the command line on its own or with strings piped to it, but it is possible to turn that awk code into an executable script.

Consider the following script. This file contains awk code with a shebang of awk -f. The -f is important here; without it, the script won’t work. The code itself is the same as you would use on the command line.

#!/usr/bin/awk -f

# This code will print out the users who have bash as their default shell.


    if (substr($7, length($7)-3) == "bash")
        print $1, "is using", $7;

This script can then be called with an /etc/passwd style file to print the users who have bash as their default shell. For example:

$ ./passwd.awk /etc/passwd
root is using /bin/bash
tim is using /bin/bash

Fetch more depth in a shallow git clone

Posted: 6th May 2015 by Tim in Git
Tags: , , , ,

If you’ve made a shallow clone of a repository but suddenly find yourself needing more history, you can fetch this history using one of these two commands:

All history:
git fetch --unshallow

Only the last 123 updates:
git fetch --depth=123

For the second command, 123 can be replaced with any number. If the depth requested is larger than the history of the repository, all records will be fetched.

Exit command in R

Posted: 26th April 2015 by Tim in R
Tags: , , , , , ,

R is quite different from most other programming languages. One common feature of other languages is the exit routine, or something with a similar name. In R, that function is stop, and takes an error message string as an argument. For example:

stop("I don't work on weekends")

will print:

Error: I don't work on weekends

and exit the program.

There are a number of software packages available for creating chemistry diagrams in LaTeX. One of those packages is ChemFig. ChemFig is a powerful package, with many features which aren’t available in other packages. The syntax is fairly easy to follow once you understand the structure, but going in blind can be a bit daunting. This post will describe the basic syntax.

For all examples below, \usepackage{chemfig} needs to be in the preamble. No other configuration needs to be set, and no other packages are required.

Let’s take a basic example, the water molecule. This can be drawn in a number of ways:

\chemfig{H-O-H} will create an image that looks much like the ASCII code:
ChemFig H2O molecule inline

This is useful for simple molecules, but it only shows the covalent bonds. If we also want to represent the angles between the bonds, we can do this in one of three ways:

  1. Add an angle step; a number between 0 and 7, where 0 means an upward (north) bond, 2 means a bond to the right (east), and so on. Each step adds 45 degrees.
    ChemFig H2O molecule with angle step
  2. Set the angle explicitly. This angle is added to the horizontal (east) in an anti-clockwise direction, and can be negative. For example, an upward bond would have an angle of 90.
    ChemFig H2O molecule with angle set at 104.5 degrees
    (angle here is 104.5 degrees)
  3. Set the angle relative to the previous angle (or 0 if no branches have been added).
    ChemFig H2O molecule with angle set at 104.5 degrees
    (angle here is also 104.5 degrees)

Some molecules contain a double covalent bond. These bonds can be represented using an equals sign:

ChemFig oxygen molecule

You may have noticed that each branch is taken from the last atom/sub-molecule listed, but sometimes that’s not what you want. You can use brackets to indicate that no connection should be made from a branch. For example, methane can be drawn like so:

ChemFig methane molecule

With these features, you should be able to create most simple chemistry diagrams in LaTeX, such as D-glucose:


ChemFig D-glucose molecule

ChemFig is much more powerful than described here. The docs on the project website are very thorough and clear, should you wish to do more than what is described here.

Removing Git Tags

Posted: 26th March 2015 by Tim in Git
Tags: , , , , , , , , , , , ,

If you’ve accidentally added a git tag, or if you want to remove old tags, these tags can be removed with the following three commands:

git tag -d <my_tag>
git push origin :<my_tag>
git push --tags

For example, if you want to remove the tag bad_tag, you would use these commands:

git tag -d bad_tag
git push origin :bad_tag
git push --tags

Linux Terminal Clock

Posted: 9th March 2015 by Tim in Bash, Linux
Tags: , , , , , , , , ,

Ever wanted to have a real-time clock on your linux terminal? We can create one with a single line of bash, like so:

while echo -en "$(date)\r"; do sleep 1; done

Let’s look at how this works:

  • date is a common unix tool used to print the current date and time. The $(...) means that the date command is run, and the output is placed here instead. For example, if logged in as root, echo "I am $(whoami)!" is the same as echo "I am root!".
  • echo -en will print the output of $(date). -e allows escaped characters (the \r in this case), and -n means echo will not add a newline character to the end of the line.
  • \r is a carriage return character. This returns the cursor to the beginning of the current line, which means the next thing to print will overwrite anything on that line.
  • while <condition>; do <commands>; done is a standard while loop; <commands> will be run while <condition> returns true (ie: execution is successful).
  • sleep 1 will pause program execution for 1 second.

Altogether, it means we will print the date every second, overwriting the previously printed date, until we end the program (ctrl-c) or until the echo command fails (which is unlikely to happen).

With Docker, you can specify the command to run inside the container on the command line. But what if you want to run multiple commands? You can’t escape the && syntax, or wrap the command in quotes, as Docker won’t recognise it. The trick here is to use

sh -c '<command1 && command2 [&& command3 [...]]>'

For example, to run date and whoami in a vanilla ubuntu container, we would run the following:

$ docker run ubuntu:latest sh -c 'date && whoami'
Wed Feb 18 00:42:53 UTC 2015

This works because sh -c '<date && whoami>' is one call; the commands will be split and executed from within sh.

Listing directories only in linux

Posted: 9th February 2015 by Tim in Linux
Tags: , , , , , ,

The ls command will list files and directories in the current directory. But what if you only want to list the directories? There are a few ways to do this. One of the easiest ways is this:

ls -d */

The -d flag instructs ls to display directories instead of displaying directory contents. The */ instructs ls to perform the listing on subdirectories only. The output will look something like this:

$ ls -d */

Test if a directory is empty in Bash

Posted: 29th January 2015 by Tim in Bash, Linux
Tags: , , , , , ,

Using Bash, there are a number of ways to test if a directory is empty. One of those ways is to use ls -A to list all files, including those starting with . and see if anything is printed. This can be done like so:

if [ ! "$(ls -A <path>)" ]
    echo "<path> is empty!"
    echo "<path> is not empty"

Or inline:

if [ ! "$(ls -A <path>)" ]; then echo "empty!"; fi

Or, for a slightly less readable version:

test "$(ls -A <path>)" || echo "empty!"

This works because test "" is true, and any other string value is false. If the directory is empty, ls -A will return an empty string.

There are many ways in the linux terminal to print the nth word of a given file or output. One way to do this without worrying about tabs, extra spaces or word length is to use awk. With awk, this can be done on one line by using the {print $<n>} syntax.

For example, the ps command may print this:

$ ps
  PID TTY          TIME CMD
 3677 pts/1    00:00:00 bash
 3699 pts/1    00:00:00 ps
 3700 pts/1    00:00:00 awk

To print only the fourth column (CMD), we can pipe the output to awk like so:

$ ps | awk '{print $4}'

There are a number of ways to print a number with zero-padding (leading zeros), depending on the variable type you are wanting to print. One easy way to add zero padding to any type is to use the str(<number>).zfill(<length>). This will convert any number type to a string before adding the extra zeros. For example:

def zeroPad(number, length):
    return str(number).zfill(length)

This function can be called using many different types. We can use this function like this:

print zeroPad(123, 5)
print zeroPad(12.3, 5)
print zeroPad('123', 10)

to print this:


Windows 8 comes with a disk partition utility, but it’s difficult to find. There are a few ways to run the utility, the easiest being:

Open the windows run prompt (windows key + r), and run diskmgmt.msc

Alternatively, for the graphically inclined, open the control panel and search for partition