==[]-- Basic Slide Rule Operations

Setting the values on a scale

This is the most basic skill of all. Some of the numbers are written right on a scale, slightly more are present only as silent tick marks and all the infinite rest should be "interpolated" between tick marks.

Setting of the values comes in tree slightly different varieties:

The last two can be generalized -- any tick mark (or even interpolated value) can be placed over any number on the adjacent scale. The significance of this variety is clearly seen from the fact that it does not involve cursor. Also, special rules often have special marks (usually in a form of arrows or colored and/or named ticks) that allow easy calculation of the formulas from that specific area. Only 2 scales on body can be adjacent to the slide and only 2 scales on the slide can be adjacent to body.

Using the slide rule notation these operations are written as:

In fact, commonly used notation aX->bY usually means |->bY; aX->|.

4 Digits

The following article posted by Chris Redding.

Many of you know that if you have a number near 1, you can can get extra precision e.g. .963*23 = (1 - .037)*23 = 23 - .037*23 = 23 - .851 = 22.149. We can extend this to other products. There is a little pencil & paper work for addition and subtraction. An Addiator on the reverse of the slide rule is ideal. Suppose we have a product 35.76*829.4. The problem is then 3.576*8.294 and remember 10^3. It is a judgment call but lets divide 3.576 by 4 and 8.294 by 8. We subtract 3.576 from 4 and get .424. On the slide rule find .424/4 and .294/8. We have .106 and .0368. Multiply these and get .00390. Add these three last numbers and get .0731. Multiplying this by 32 we get 2.34. Subtract this from 32 and get 29.66. Applying the power of ten we have 29660. The answer from my calculator is 29659.344. We have four significant figures in our answer. This will work for quotients too.

Reading the values from a scale

Reading operation can be written in short notation as |=>R(r) where R is a scale and r is a result value.

Basic unary operation

Combining the setting value on the scale with a cursor with the following reading the value under cursor from different scale produces simplest possible slide rule operation that allows to calculate some formula.

In short notation this is written as |->uU; |=>vV, or, with further simplification: uU=>vV. This operation allows to perform calculations in the following unusual way:
If we match value u on scale U with formula d=f(u) against v on scale V with formula d=g(v) then, because d is the same for both formulas, u and v are in the following algebraic relationship: f(u)=g(v). This can be interpreted to calculate either


For example, the value u on scale C with formula d = log10x and the vaue v on scale A with formula d = (1/2)*log10x are in relationship log10u = (1/2)*log10v. This relationship can be used to calculate either

u = 10(1/2)*log10v = v1/2,
v = 102*log10u = u2

If one of the U or V is on body and another is on slide, then these formulas depend on some constant (position of the slide), thus allowing to use slide rule as a function table for the whole family of functions.

Reversing the slide

Interesting technic is available for most slide rules: slide can be taken out from it's grooves in a body and placed back "upside down". This means that face of the slide still faces towards user, but left index (of e.g. C scale) is now on the right side of the slide rule and right index is on the left.

This actions changes formulas of the scales located on the slide from d = f(u) to d = 1-f(u). In some cases this increases range of function that can be represented by appropriate choice of a pair of slide rule scale.

Unary formula examples

Let us consider Mannheim slide rule layout
A[B,C]D. The values on C and A scales are in the relation
const + log C =1/2 log A
This allows to calculate formulas
C = const * sqrt(A)
A = const * C2
where const is some constant, that depends on the position of the slide.

Reversing slide turns C into CI (C inverted) with formula d = 1 - log10x. The relation between these scales now is

const + 1 - log CI =1/2 log A
This allows to calculate formulas
CI = const / sqrt(A)
A = const / CI2

Basic ternary operation

Usual math operations are mostly binary or unary (take 2 or 1 argument to produce a resut). Examples: addition, multiplication, subtraction, division -- are binary, negation and square root are unary.

Unlikely, the basic slide rule operation is ternary in nature, that is, it has 3 operands. This operation can be described in the following way: move u on scale U to v on scale V and read the result r from scale R under w on scale W. In short notation this is written as uU->vV; wW=>R(r). In practice, however, you will often be required to use cursor to perform this: |->vV; uU->|; |->wW; |=>R(r). Please note, that operation takes 3 arguments (u, v, w) to produce a result (r).

If U, V, W and R have formulas (respectively) d=f(u), d=g(v), d=h(w), d=t(r) then (see picture) t(r)-g(v) = h(w)-f(u), or

r = t-1(h(w)-f(u)+g(v)).

Note, that here R is scale on body, and W is scale on slide. This case is most useful -- since the result obtained on a body scale can often be used in subsequent calculations without reading. However, situation when the result is read from some slide scale is also valid. Referring to the same picture, now r is one of the input parameters and w is a result uU->vV; rR=>W(w) yields w = h-1(t(r)-g(v)+f(u)).

Important example

In the basic ternary opration scales U and W may coincide, as well as R and V. When both scales U and W coincide with scale C and R and V -- with scale D (both C and D have formula d=log10x) the operation becomes uC->vD; wC=>D(r) and it allows to calculate
r = 10(log w-log u+log v) = vw/u       (1)

Scales C and D are present on every slide rule, that is why this operation is so important.

Reversing the slide

Surprisingly enough, reversing the slide that proved so fruitful for basic unary opartion does not give any new formulas for basic ternary operation. If
uU->vV;wW=>R(r)      (2)
calculates some formula then
wWI->vV;uUI=>R(r)      (3)
calculates the same formula with reversed slide and vice versa.

Proof. Indeed, let U, V, W, R have formulas d=f(u), d=g(v), d=h(w), d=t(r) respectively. Then operation (2) yieds formula

r = t-1(-f(u)+g(v)+h(w))      (4)
Reversing the slide changes U and W into UI and WI with formulas d=1-f(u), d=1-h(w). Thus, (3) yields
r = t-1(-(1-h(w))+g(v)+(1-f(u))) = t-1(-f(u)+g(v)+h(w))      (5)
which coincides with (4).

Multiplying two numbers

Set 1C over v on D, read v*w under w on C. This is what each and every slide rule manual says about multiplication on the slide rule.

Note however, that this is exactly (1) with u=1. This shows that multiplication is just a particular case of one of the basic ternary operations. Using other ternary operations (produced by different choice of scales) it is possible to construct additional multiplication algorithms.

For example, polyphase layout (K,A[B,CI,C]D) allows the following 11 ways to multiply 2 numbers u and v:
Scales Algorithm Comment
[D,C] 1C->vD; uC=>D(r) Standard multiplication
[D,CI] uCI->vD; 1C=>D(r) AKA multiplicaton by means of red digits
[A,B] 1C->vA; uB=>A(r) Like standard, but using A/B scales
[CI,D] vCI->uD; 1D=>CI(r)  
[D,A,B,CI] vCI->uA; uB=>D(r)  
[D,C,CI] uCI->1D; vC=>D(r)  
[B,A] vB->1D; uA=>B(r)  
[A,B,C] uB->vA; uC=>A(r)  
[B,A,C] uC->uA; vA=>B(r)  
[B,A,D] vB->uA; uD=>B(r)  
[A,B,D] uB->uD; vB=>A(r) May be useful
[C,D] vC->1D; uD=>C(r)  
Dave Martindale (in his Thu, 02 Aug 2001 posting to slide rule list) suggested the following method: uC->1D; |->1C; vC->|; 1D=>C(u*v)

This method requires 2 slide movements, but it uses only left and right indexes of scale D, thus actually, using only one scale.

Dividing two numbers

Like multiplication, division, as described by slide rule manual (uC->vD; 1C=>D(r=v/u)) is the particular case of (1), with w=1. Note that this is exactly the same basic operation that was used to produce multiplication algorithm.

Again by using different choice of scales it is possible to come up with different u/v algorithms. Polyphase layout (K,A[B,CI,C]D) allows the following:
Scales Agorithm
[CI,D] uCI->1D; vD=>CI(r)
[D,CI] uCI->1D; vCI=>D(r)
[A,B,C] vB->uA; 1C=>A(r)
[B,A,C] 1C->vA; uA=>B(r)
[B,A,D] uB->vA; 1D=>B(r)
[A,B,D] vB->1D; uB=>A(r)
[A,B,C] vC->uA; vB=>A(r)
[A,B,C] vC->vA; uB=>A(r)
[D,A,B,C] vC->uA; uB=>D(r)
[C,A,B,D] uB->vD; uA=>C(r)
[B,A,D] uB->vD; vA=>B(r)
[B,A,D] vB->vD; uA=>B(r)
[C,D] uC->vD; 1D=>C(r)
[D,C] vC->1D; uC=>D(r)
[D,C] vC->uD; 1C=>D(r)
[C,D] 1C->vD; uD=>C(r)
[D,C,CI] 1C->uD; vCI=>D(r)
[CI,C,D] vC->uD; 1D=>CI(r)
[CI,C,D] 1C->uD; vD=>CI(r)
[C,CI,D] vCI->1D; uD=>C(r)
[CI,A,B,D] vB->uD; vA=>CI(r)

[ Index page | Emulator | Notation | Deframe | Feedback ]