Simple Shell Scripting for Scientists, Day Two: Exercises
These are exercises for you to try once you have attended the second day of the Simple Shell Scripting for Scientists course. Solutions to this exercise will be examined on the third day of this course, so you must attempt this exercise before then or you may find it very difficult to follow the rest of this course.
The course notes for this day of the course are available (as a PDF) here.
These exercises were designed to be done on
PWF Linux.
It is recommended that you try them on a PWF Linux
system, as that is the environment in which they have been tested. However,
they should work on most modern Linux distributions that have gnuplot
4.0
or higher (with PNG support),
and Eye of GNOME 2.9.0
or higher (or another appropriate PNG
viewer), installed.
If you don't do these exercises under PWF Linux
you may need to recompile the iterator
program (see the
README
file in the archive
of files from the second day of the course for details). You should also
have a look at the compatibility notes.
In order to do these exercises, you'll need to get hold of the files used in class. If you are doing these on PWF Linux, then after you have logged in, type the following:
cd "${UX}"/Lessons/Shell-Scripting-Scientists
./setup-day-two.sh
You'll be asked for a directory into which the files should be placed, the
files will be unpacked to that directory and then set up for you. Look at
the README
file in the directory to which the files have been
unpacked for instructions on how to run the script constructed in class.
If you are not doing these exercises on PWF Linux,
then you'll need to get copies of the files that were used in class onto your
own system and set up properly. These files are available in an archive here.
You'll also need to unpack the archive and set things up with this setup-day-two.sh
script. Download the archive
and setup-day-two.sh
script to the
same directory. cd
to the directory into which you downloaded
those two files. Make sure the setup-day-two.sh
script is
executable by typing:
chmod +x setup-day-two.sh
and then run it by typing:
./setup-day-two.sh
The setup-day-two.sh
script will ask you for a directory into
which it should unpack the archive and will then set everything up for you.
Once the archive is successfully unpacked, see the README
file
for details of what it contains. This file also gives brief instructions on
how to recompile the iterator
source code, in case the
precompiled version of iterator
included in the archive won't run
on your system.
On day two of this course we created several scripts that run a program with a given parameter set or run a program several times, once for each of a collection of parameter sets. We've looked at different ways of specifying those parameter sets (on the command line and via standard input). We're now going to look at ways of changine our scripts to make our exploration of the program's parameter space even more versatile.
Change to the directory containing the iterator
program and the
answers
and scripts
subdirectories. First of all,
make sure that the multi-run-while.sh
shell script in the
scripts
subdirectory has been modified as we did during the
course. You can do this by overwriting the copy in the scripts
subdirectory with the copy provided in the answers
subdirectory like this:
cp -pf answers/multi-run-while.sh scripts/multi-run-while.sh
(You only need to to do this once.)
There are three parts to this exercise, which you should attempt in the order given:
Improve the run_program
function in multi-run-while.sh
so that as well as running iterator
it also runs gnuplot
(using the iterator.gplt
file) to plot a graph of the output.
See the course notes for one approach to
this
task.
Now create a new shell script based on multi-run-while.sh
that will run iterator
three times for each parameter set
the script read
s in on standard input, changing the
third parameter each time as follows:
For a given parameter set a b c d, first your script should run
iterator
with the parameter set:
a b 10 d
…then with the parameter set:
a b 100 d
…and then with the parameter set:
a b 1000 d
See the course notes for a more detailed description of this task.
Now create a new shell script, based on the script you created in the previous part of the exercise, that does the following:
Instead of running iterator
three times for each parameter
set it read
s in, this script should accept a set of values on
the command line, and use those instead of the hard-coded 10, 100, 1000
previously used.
Thus, for each parameter set it read
s in on standard input,
it should run iterator
substituting, in turn, the values from
the command line for
the third parameter in the
parameter set it has read
in.
So, if the script from the previous part of the exercise was called
multi-10-100-1000.sh
, and we called this new script
multi-iterations.sh
(and stored both in the scripts
subdirectory), then - assuming we are in the directory containing the
iterator
program and the scripts
subdirectory -
running our new script like this:
cat scripts/param_set | scripts/multi-iterations.sh 10 100 1000
should produce exactly the same output as running the script you wrote in the previous part of this exercise with the same input file:
cat scripts/param_set | scripts/multi-10-100-1000.sh
See the course notes for a hint on how to do this part of the exercise.
(If you can't see the point of the shell scripts you've been asked to write for the last two parts of this exercise, see the course notes for a possible scenario in which they would be useful.)
We're going to be looking at the solutions to the above exercise on the next day of this course, so it is essential that you attempt the exercise before then.
If you are not doing these exercises under PWF Linux then you should be aware of the following issues which may arise when using other Linux/Unix systems:
The compiled version of the iterator
program provided in
this archive was compiled on an
Intel Core 2 Duo Processor E6300 under openSUSE 11.2 (2.6 kernel,
GLIBC 2.10.1), using GCC 4.4. It is not guaranteed to work on any other
Linux/Unix distribution and/or architecture. If it will not run then you'll
have to compile it from source. See the README
file in the
archive for details.
You may have problems if you are using a shell other than bash.
You may also have problems if you are using a version of bash
earlier than version 2.04. Note that the scripts used in this course were all
written to run under bash 4.0,
but it is believed that they will run under bash
2.04 or higher (no promises, though). At least one of the scripts used in
this course (hello-function.sh
) won't run properly under versions
of bash earlier than 2.04 (this
script isn't needed for these exercises, though).
You will have problems if you are using a version of mktemp
earlier than version 1.3, as versions of mktemp
prior to version 1.3 did not support the ‑t
option.
In particular, versions of mktemp
derived from BSD (such as that provided with MacOS X) do not support this
option. If you want to use the scripts from this course with such versions of
mktemp
you will need to
modify the scripts to explicitly create files and directories in /tmp
instead of using the ‑t
option.
The gnuplot
commands
used have only been tested with gnuplot
4.0 and 4.2.
They will probably work with gnuplot
3.7 or higher, but this has not been tested.
The version of gnuplot
you use must have PNG
support. This usually depends on how your version of gnuplot
has been compiled. To find out if it has PNG
support, start gnuplot
and
type the following:
show version long
If under Compile options
either +PNG
or +GD_PNG
is listed, then your version of gnuplot
has been compiled with PNG
support.
If you do not have Eye of GNOME (eog
)
on your system, almost any other PNG
viewer will do. Most modern web browsers can view PNG
files. A list of some applications that support the PNG
format is given here.