## Archive for March, 2012

### Making change with shell

2012-03-13

I was flicking through Wikström’s «Functional Programming Using Standard ML», when I noticed he describes the problem of making up change for an amount of money m using coins of certain denominations (18.1.2, page 233). He says we “want a function change that given an amount finds the smallest number of coins that adds to that amount”, and “Obviously, you first select the biggest possible coin”. Here’s his solution in ML:

```exception change;
fun change 0 cs = nul
| change m nil = raise change
| change m (ccs as c::cs) = if m >= c
then c::change (m-c) ccs
else change m cs;
```

It’s pretty neat. The recursion proceeds by either reducing the magnitude of the first argument (the amount we are giving change for), or reducing the size of the list that is the second argument (the denominations of the coins we can use); so we can tell that the recursion must terminate. Yay.

It’s not right though. Well, it gives correct change, but it doesn’t necessarily find the solution with fewest number of coins. Actually, it depends on the denominations of coins in our currency; probably for real currencies the “biggest coin first” algorithm does in fact give the fewest number of coins, but consider the currency used on the island of san side-effect, the lambda. lambdas come in coins of Λ1, Λ10, and Λ25 (that’s not a wedge, it’s a capital lambda. It’s definitely not a fake A).

How do we give change of Λ30? { Λ10, Λ10, Λ10 } (3 tens); what does Wikström’s algorithm give? 1 twenty-five and 5 ones. Oops.

I didn’t work out a witty solution to the fewest number of coins change, but I did create, in shell, a function that lists all the possible ways of making change. Apart from trivial syntactic changes, it’s not so different from the ML:

```_change () {
# \$1 is the amount to be changed;
# \$2 is the largest coin;
# \$3 is a comma separated list of the remaining coins

if [ "\$1" -eq 0 ] ; then
echo ; return
fi
if [ -z "\$2" ] ; then
return
fi
_change \$1 \${3%%,*} \${3#*,}
if [ "\$1" -lt "\$2" ] ; then
return
fi
_change \$((\$1-\$2)) \$2 \$3 |
while read a ; do
echo \$2 \$a
done
}

change () {
_change \$1 \${2%%,*} \${2#*,},
}
```

Each solution is output as a single line with the coins used in a space separated list. change is a wrapper around _change which does the actual work. The two base cases are basically identical: «”\$1″ -eq 0» is when we have zero change to give, and we output an empty line (just a bare echo) which is our representation for the empty list; «-z “\$2″» is when the second argument (the first element of the list of coins) is empty, and, instead of raising an exception, we simply return without output any list at all.

The algorithm to generate all possible combinations of change is only very slightly different from Wikström’s: if we can use the largest coin, then we generate change both without using the largest coin (first recursive call to _change, on line 12) and using the largest coin (second recursive call to _change, on line 16). See how we use a while loop to prepend (cons, if you will) the largest coin value to each list returned by the second recursive call. Of course, when the largest coin is too large then we proceed without it, and we only have the first recursive call.

The list of coins is managed as two function arguments. \$2 is the largest coin, \$3 is a comma separated list of the remaining coins (including a trailing comma, added by the wrapping change function). See how, in the first recursive call to _change \$3 is decomposed into a head and tail with \${3%%,*} and \${3#*,}. As hinted at in the previous article, «%%» is a greedy match and removes the largest suffix that matches the pattern «,*» which is everything from the first comma to the end of the string, and so it leaves the first number in the comma separated list. «#» is a non-greedy match and removes the smallest prefix that matches the pattern «*,», so it removes the first number and its comma from the list. Note how I am assuming that all the arguments do not contain spaces, so I am being very cavalier with double quotes around my \$1 and \$2 and so on.

It even works:

```\$ change 30 25,10,1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
10 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
10 10 1 1 1 1 1 1 1 1 1 1
10 10 10
25 1 1 1 1 1
```

### Taking the bash out of Mark

2012-03-05

Mark Dominus, in his pretty amusing article about exact rational arithmetic in shell gives us this little (and commented!) shell function:

```        # given an input number which might be a decimal, convert it to
# a rational number; set n and d to its numerator and
# denominator.  For example, 3.3 becomes n=33 and d=10;
# 17 becomes n=17 and d=1.
to_rational() {
# Crapulent bash can't handle decimal numbers, so we will convert
# the input number to a rational
if [[ \$1 =~ (.*)\.(.*) ]] ; then
i_part=\${BASH_REMATCH[1]}
f_part=\${BASH_REMATCH[2]}
n="\$i_part\$f_part";
d=\$(( 10 ** \${#f_part} ))
else
n=\$1
d=1
fi
}
```

Since I’m on a Korn overdrive, what would this look like without the bashisms? Dominus uses BASH_REMATCH to split a decimal fraction at the decimal point, thus splitting ‘fff.iii’ into ‘fff’ and ‘iii’. That can be done using portable shell syntax (that is, blessed by the Single Unix Specification) using the ‘%’ and ‘#’ features of parameter expansion. Example:

```\$ f=3.142
\$ echo \${f%.*}
3
\$ echo \${f#*.}
142
```

In shell, «\${f}» is the value of the variable (parameter) f; you probably knew that. «\${f%pattern}» removes any final part of f that matches pattern (which is a shell pattern, not a regular expression). «\${f#pattern}» removes any initial part of f that matches pattern (full technical details: they remove the shortest match; use %% and ## for greedy versions).

Thus, between them «\${f%.*}» and «\${f#*.}» are the integer part and fractional part (respectively) of the decimal fraction. The only problem is when the number has no decimal point. Well, Dominus special cased that too. Of course the “=~” operator is a bashism (did perl inspire bash, or the other way around?), so portable shell programmers have to use ‘case’ (which traditionally was always preferred even when ‘[' could be used because 'case' didn't fork another process). At least this version features a secret owl hidden away (on line 3):

```to_rational () {
case \$1 in
(*.*) i_part=\${1%.*} f_part=\${1#*.}
n="\$i_part\$f_part"
d=\$(( 10 ** \${#f_part} )) ;;
(*) n=\$1 d=1 ;;
esac
}
```

The '**' in the arithmetic expression raised a doubt in my mind and, *sigh*, it turns out that it's not portable either (it does work in 'ksh', but it's not in the Single Unix Specification). Purists have to use a while loop to add a '0' digit for every digit removed from f_part:

```to_rational () {
case \$1 in
(*.*) i_part=\${1%.*} f_part=\${1#*.}
n="\$i_part\$f_part"
d=1;
while [ -n "\${f_part}" ] ; do
d=\${d}0
f_part=\${f_part%?}
done ;;
(*) n=\$1 d=1 ;;
esac
}
```

Traditional shell didn't support this «\${f%.*}» stuff, but it's been in Single Unix Specification for ages. It's been difficult to find a Unix with a shell that didn't support this syntax since about the year 2000. It's time to start to be okay about using it.

### Interactive Shells and their prompts

2012-03-04

What can we say about what the “-i” option to shell does? It varies according to the shell. Below, I start with PS1 set to “demo\$ “, which is not my default. (you can probably work it out from the transcript, but) it might help to know that my default shell is bash (for now). There’s nothing special about ‘pwd’ in the examples below, it’s just a command with a short name that outputs something.

```demo\$ echo pwd | ksh
/home/drj/hackdexy/content
demo\$ echo pwd | bash
/home/drj/hackdexy/content
demo\$ echo pwd | ksh -i
\$ /home/drj/hackdexy/content
\$
demo\$ echo pwd | bash -i
drj\$ pwd
/home/drj/hackdexy/content
drj\$ exit
demo\$ echo pwd | bash --norc -i
bash-4.2\$ pwd
/home/drj/hackdexy/content
bash-4.2\$ exit
demo\$ echo pwd | sh -i
\$ /home/drj/hackdexy/content
\$
sh: Cannot set tty process group (No such process)
demo\$ . ../bin/activate
(hackdexy)demo\$ echo pwd | ksh -i
(hackdexy)demo\$ /home/drj/hackdexy/content
(hackdexy)demo\$
(hackdexy)demo\$ deactivate
```

What have we learnt? (when stdin is not a terminal) shells do not issue prompts unless the “-i” option is used. That’s basically what “-i” does. bash, but not ksh, will echo the command. That has the effect of making bash’s output seem more like an interactive terminal session.

Both ‘bash’ and ‘ksh’ changed the prompt. ‘bash’ changed the prompt because it sources my ‘.bashrc’ and that sets PS1; ‘ksh’ changed my prompt, apparently because PS1 is not an exported shell variable, and so ‘ksh’ does not inherit PS1 from its parent process, and so sets it to the default of “\$ “. If we stop ‘bash’ from sourcing ‘.bashrc’ by using the ‘–norc’ option (‘–posix’ will do as well) then it too will use its default prompt: the narcissistic “bash-4.2\$ “.

‘sh’ (dash on my Ubuntu laptop, apparently), is like ‘ksh’ in that it does not echo the commands. But it does output a narked warning message.

The last command, after using ‘activate’ from virtualenv, demonstrates that ‘activate’ must export PS1. I think that is a bug, but I would welcome comment on this matter.

I guess most people use ‘bash’ and mostly set PS1 their ‘.bashrc’, so wouldn’t notice any of this subtlety (for example, they will not notice that ‘activate’ exports PS1 because the ‘.bashrc’ will set it to something different).

I note that the example login and ENV scripts given in The KornShell Command and Programming Language (p241 1989 edition) set PS1 is the login script only, and do not export it. Meaning that subshells will have the default prompt. I quite like that (it also means that subshells from an ‘activate’d shell will have the ‘activate’ prompt). Why doesn’t anyone do it like that any more?