- Setting the values on a scale
- Reading the values from a scale
- Basic unary operation
- Basic ternary operation
- Multiplying two numbers
- Dividing two numbers

Setting of the values comes in tree slightly different varieties:

- moving cursor line to the desired number point on one of the scales (no matter on slide rule body, or on a slide);
- moving the slide, so that desired number point on one of its scales appears under the hairline
- moving slide so, that index mark, either left ('1') or right ('10'), appears over the desired number over the body scale that is adjacent to the slide
- moving slide so, that desired number on a scale adjacent to the body appears over the left or right index of the body scale that is adjacent to the slide

Using the slide rule notation these operations are written as:

- Moving cursor line to the number
`a`on a scale`X`:`|->aX` - Moving the slide, so that number
`a`on a scale`X`moves under hairline:`aX->|`. Here X -- is one of the scales, located on the slide. - Moving the index of a slide to the number
`a`on a body scale`X`:`1C->aX`where`C`is a slide scale adjacent to`X`. - Moving the number
`a`on a lide scale`X`to index of body scale:`aX->1D`where`C`is a slide scale adjacent to`X`.

Hi,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.

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)*

__For example__, the value *u* on scale C with formula
*d = log _{10}x*

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.

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.

Reversing slide turns C into CI (C inverted) with formula
*d = 1 - log _{10}x*. The relation between these scales now
is

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)`.

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)*,

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)`*w = h ^{-1}(t(r)-g(v)+f(u))*.

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

*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

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) |

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

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) |