The L scale is laid out to give common logarithms, i.e., base 10. Apart from their great utility in computational work, base 10 logs also pop in a broad range of applications: the pH scale in chemistry, the magnitude scale in astronomy, the Richter scale in earth science, the decibel scale in audiology, and more. Even crazier is that for centuries, astrologers used common logs when casting a horoscope!
Notably, when I took a freshman trigonometry class in college (but not as a freshman!), we used tables of common logs for all of our computations. Pocket calculators were still on the drawing board, and I suppose a slide rule was deemed too much of a luxury for us starving undergrads. (Tuition was $6.50 a credit hour, and the typical mathematics text book was $5).
Before we get going, let me say a few things about language. You might remember in Some Terminology, I mentioned that the word mantissa could be taken in two ways, depending on context. So far, we've used it to mean any number lying between 1 and 10 on the C or D scales. This also corresponds to how one expresses a number in scientific notation: a number from 1 (inclusive) to 10 (exclusive) multiplied by 10 raised to a power.
But with calculations involving common logs, it is more accurate to refer to the mantissa as that fractional portion (between 0 and 1) of the logarithm; the characteristic is the whole number part indicating the order of magnitude. For example:
log(127)
= log(10^2 * 1.27)
= log(10^2) + log(1.27)
= 2 + 0.1038
Here, 2 is the characteristic and 0.1038 is the mantissa. (And remember when working with logarithms or a slide rule, that symbol "=" is subject to a raised eyebrow, as is the case with any analog computation).
So, when doing common logs on a slide rule, the argument will be between 1 and 10 (let's call that the basic range), and the resulting mantissa will lie between 0 and 1. The characteristic is maintained mentally.
With that, let's get going with some problems.
Common Logs of Arguments Between 1 and 10
The basic approach is: find the argument on the D scale, and read the result off of the L scale. However some slide rules place the L scale on the slide rather than the stator, in which case use C instead of D.
Our first problem is very straightforward, since the argument is already in the basic range.
Exercise 1.1: Find log(3.75).
- Set the cursor at 3.75 on the D scale.
- Read the result under the hairline on the L scale: 0.574.
 |
| Cursor to D:3.75, result at L:0.574 |
For emphasis, since 3.75 is between 1 and 10, the final result 0.574 must fall between 0 and 1. The characteristic is 0, of course.
Common Logs of Arguments Greater Than 10
Now the characteristic plays a more meaningful role. The idea is to massage the argument into a power of 10 times a number within the basic range.
Exercise 2.1: Find log(48.2).
The argument can be rewritten as 10^1 * 4.82, and we're good to go as before. Simply remember that characteristic, 1, until the end.
- Set the cursor at 4.82 on the D scale.
- Read the number under under the hairline on L: 0.683.
- Form the result by appending this to the characteristic: 1.683.
 |
| Cursor to D:4.82, read L:0.683, prefix characteristic: 1.683 |
Exercise 2.2: Find log(1250).
Again, we start by thinking (thanks to John Napier):
log(1250)
= log(10^3 * 1.250)
= log(10^3) + log(1.250)
= 3 + log(1.250).
- Set the cursor at 1.250 on the D scale.
- Read the number under the hairline on the L scale: 0.1.
- Form the result by appending this to the characteristic: 3.1.
 |
| Cursor to 1.250, read L:0.1, prefix characteristic: 3.1 |
A little shortcut might prove useful: if the argument exceeds 1, the characteristic will always be one less than the number of digits to the left of the decimal point. For example:
123.45 .......... characteristic is 2
6789.0123 .... characteristic is 3
13 ................. characteristic is 1
4.567 ............ characteristic is 0
10,000 .......... characteristic is 4
Common Logs of Arguments Less Than 1
Example 3.1: Find log(0.15).
Suppose we try our usual Naperian manipulation at the outset:
log(0.15)
= log[10^(-1) * 1.5]
= log[10^(-1)] + log(1.5)
= -1 + log(1.5).
Ugh! For arguments lying between 0 and 1, we surely dread that subtraction, just knowing it's prone to missteps in the heat of battle.
Luckily, there's another way around this to greatly lessen our mental anguish. Consider yet another of John Napier's rules: log(x) = -log(1/x). Now think about that for a moment in the context of the problem we're working on.
CI is already set up to give the reciprocal of numbers in our so-called basic range of 1 to 10. Therefore, all we have to do is find 1/x on CI (instantaneous!), read the corresponding logarithm on L (ditto, ditto!), and plop a minus sign in front (ditto cubed!) and we're done!
Note: Either CI or DI (if available) are okay. Use whichever is most convenient on your rule. In the former case, however, you'll want the slide rule to be closed, i.e., with C and D aligned.
So the procedure for arguments between 0 and 1 is:
- shift the argument to fall in the basic range and find its logarithm,
- count the number of zeros to the right of the decimal point in the original argument and prefix it to the result of the first step
- prefix a minus sign to the whole affair.
- Set the cursor at 1.5 (mentally altered from 0.15) on the CI scale.
- Read the number under the hairline on the L scale: 0.824.
- Prefix a minus sign to give the result: -0.824.
 |
| Cursor to CI:1.5, read L:0.824, prefix minus sign: -0.824 |
Let's try it with an even smaller argument.
Exercise 3.2: Find log(0.007).
- Set the cursor at 7.0 on the CI scale.
- Read the number under the hairline on L: 0.155.
- There are two zeros following the decimal point in the argument, so prefix a 2.
- Prefix a minus sign. The result is: -2.155.
 |
| Cursor to CI:7.0, read L:0.155, prefix 2, prefix minus: -2.155 |
So there you have it, a surefire technique for finding logarithms of any number in the function's domain, big or small, and with no addition or subtraction required.
Next installment: Powers of Ten with the L Scale