Mercurial > public > cpp-enigma

annotate enigma/rotor.h @ 9:7362965f53b1

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Added tests for the hill climbing functions in the plugboard class.
author Brian Neal <bgneal@gmail.com>
date Fri, 29 Jun 2012 21:19:00 -0500
parents 1459e74fda3f
children
rev   line source
bgneal@0 1 #ifndef CPP_ENIGMA_ROTOR_H
bgneal@0 2 #define CPP_ENIGMA_ROTOR_H
bgneal@0 3 // Copyright (C) 2012 by Brian Neal.
bgneal@0 4 // This file is part of Cpp-Enigma, the Enigma Machine simulation.
bgneal@0 5 // Cpp-Enigma is released under the MIT License (see License.txt).
bgneal@0 6 //
bgneal@0 7 // rotor.h - This file contains the rotor class.
bgneal@0 8
bgneal@0 9 #include <string>
bgneal@0 10 #include "enigma_types.h"
bgneal@1 11 #include "enigma_utils.h"
bgneal@0 12
bgneal@0 13
bgneal@0 14 namespace enigma
bgneal@0 15 {
bgneal@0 16 class rotor_error : public enigma_error
bgneal@0 17 {
bgneal@0 18 public:
bgneal@0 19 explicit rotor_error(const std::string& what_arg)
bgneal@0 20 : enigma_error(what_arg)
bgneal@0 21 {}
bgneal@0 22 };
bgneal@0 23
bgneal@0 24 // The rotor class represents the Enigma Machine rotors (Walzen).
bgneal@0 25 //
bgneal@0 26 // A rotor has 26 circularly arranged pins on the right (entry) side and 26
bgneal@0 27 // contacts on the left side. Each pin is connected to a single contact by
bgneal@0 28 // internal wiring, thus establishing a substitution cipher. We represent this
bgneal@0 29 // wiring by establishing a mapping from a pin to a contact (and vice versa for
bgneal@0 30 // the return path). Internally we number the pins and contacts from 0-25 in a
bgneal@0 31 // clockwise manner with 0 being the "top".
bgneal@0 32 //
bgneal@0 33 // An alphabetic or numeric ring is fastened to the rotor by the operator. The
bgneal@0 34 // labels of this ring are displayed to the operator through a small window on
bgneal@0 35 // the top panel. The ring can be fixed to the rotor in one of 26 different
bgneal@0 36 // positions; this is called the ring setting (Ringstellung). We will number
bgneal@0 37 // the ring settings from 0-25 where 0 means no offset (e.g. the letter "A" is
bgneal@0 38 // mapped to pin 0 on an alphabetic ring). A ring setting of 1 means the letter
bgneal@0 39 // "B" is mapped to pin 0.
bgneal@0 40 //
bgneal@0 41 // Each rotor can be in one of 26 positions on the spindle, with position 0
bgneal@0 42 // where pin/contact 0 is being indicated in the operator window. The rotor
bgneal@0 43 // rotates towards the operator by mechanical means during normal operation as
bgneal@0 44 // keys are being pressed during data entry. Position 1 is thus defined to be
bgneal@0 45 // one step from position 0. Likewise, position 25 is the last position before
bgneal@0 46 // another step returns it to position 0, completing 1 trip around the spindle.
bgneal@0 47 //
bgneal@0 48 // Finally, a rotor has a "stepping" or "turnover" parameter. Physically this
bgneal@0 49 // is implemented by putting a notch on the alphabet ring and it controls when
bgneal@0 50 // the rotor will "kick" the rotor to its left, causing the neighbor rotor to
bgneal@0 51 // rotate. Most rotors had one notch, but some Kriegsmarine rotors had 2
bgneal@0 52 // notches and thus rotated twice as fast.
bgneal@0 53 //
bgneal@0 54 // Note that due to the system of ratchets and pawls, the middle rotor (in a 3
bgneal@0 55 // rotor Enigma) can "double-step". The middle rotor will advance on the next
bgneal@0 56 // step of the first rotor a second time in a row, if the middle rotor is in
bgneal@0 57 // its own turnover position.
bgneal@0 58 //
bgneal@0 59 // Note that we allow the stepping parameter to be None. This indicates the
bgneal@0 60 // rotor does not rotate. This allows us to model the entry wheel and
bgneal@0 61 // reflectors as stationary rotors.
bgneal@0 62
bgneal@0 63 class rotor
bgneal@0 64 {
bgneal@0 65 public:
bgneal@0 66 // rotor constructor:
bgneal@0 67 //
bgneal@0 68 // model_name - e.g. "I", "II", "III", "Beta", "Gamma"
bgneal@0 69 //
bgneal@0 70 // wiring - this should be a string of 26 alphabetic characters that
bgneal@0 71 // represents the internal wiring transformation of the signal as it enters
bgneal@0 72 // from the right side. This is the format used in various online
bgneal@0 73 // resources. For example, for the Wehrmacht Enigma type I rotor the
bgneal@0 74 // mapping is "EKMFLGDQVZNTOWYHXUSPAIBRCJ".
bgneal@0 75 //
bgneal@0 76 // ring_setting - this should be an integer from 0-25, inclusive, which
bgneal@0 77 // indicates the Ringstellung. A value of 0 means there is no offset; e.g.
bgneal@0 78 // the letter "A" is fixed to pin 0. A value of 1 means "B" is mapped to
bgneal@0 79 // pin 0.
bgneal@0 80 //
bgneal@0 81 // stepping - this is the stepping or turnover parameter. It should be
bgneal@0 82 // a string such as "Q". This will indicate that when the rotor transitions
bgneal@0 83 // from "Q" to "R" (by observing the operator window), the rotor will "kick"
bgneal@0 84 // the rotor to its left, causing it to rotate. If the rotor has more than one
bgneal@0 85 // notch, a string of length 2 could be used, e.g. "ZM". Another way to think
bgneal@0 86 // of this parameter is that when a character in the stepping string is visible
bgneal@0 87 // in the operator window, a notch is lined up with the pawl on the left side
bgneal@0 88 // of the rotor. This will allow the pawl to push up on the rotor *and* the
bgneal@0 89 // rotor to the left when the next key is depressed.
bgneal@0 90 //
bgneal@0 91 // Note that for purposes of simulation, our rotors will always use
bgneal@0 92 // alphabetic labels A-Z. In reality, the Heer & Luftwaffe devices used
bgneal@0 93 // numbers 01-26, and Kriegsmarine devices used A-Z. Our usage of A-Z is
bgneal@0 94 // simply for simulation convenience.
bgneal@0 95 // display.
bgneal@0 96
bgneal@1 97 rotor(const char* name, const char* wiring, int ring_setting = 0, const char* stepping = nullptr);
bgneal@0 98
bgneal@0 99 // Returns the rotor name:
bgneal@0 100 const std::string& name() const { return rotor_name; }
bgneal@0 101
bgneal@1 102 // Spin the rotor such that the char val appears in the operator window:
bgneal@1 103 void set_display(char val)
bgneal@1 104 {
bgneal@1 105 pos = display_map[val - 'A'];
bgneal@1 106 display_val = val;
bgneal@1 107 }
bgneal@0 108
bgneal@0 109 // Returns what is currently being displayed in the operator window:
bgneal@1 110 char get_display() const { return display_val; }
bgneal@1 111
bgneal@1 112
bgneal@1 113 // sets the ring setting to n, where n [0-25]:
bgneal@1 114 void set_ring_setting(int n);
bgneal@1 115
bgneal@1 116 // get the current ring setting:
bgneal@1 117 int get_ring_setting() const { return ring_setting; }
bgneal@0 118
bgneal@0 119 // Simulate a signal entering the rotor from the right at a given pin:
bgneal@0 120 // n must be an integer between 0 and 25.
bgneal@0 121 // Returns the contact number of the output signal (0-25).
bgneal@1 122 int signal_in(int n) const
bgneal@1 123 {
bgneal@1 124 // determine what pin we have at that position due to rotation
bgneal@1 125 const int pin = (n + pos) % 26;
bgneal@1 126
bgneal@1 127 // run it through the internal wiring
bgneal@1 128 const int contact = entry_map[pin];
bgneal@1 129
bgneal@1 130 // turn back into a position due to rotation
bgneal@1 131 return alpha_mod(contact - pos);
bgneal@1 132 }
bgneal@0 133
bgneal@0 134 // Simulate a signal entering the rotor from the left at a given contact position n.
bgneal@0 135 // n must be an integer between 0 and 25.
bgneal@0 136 // Returns the pin number of the output signal (0-25).
bgneal@1 137 int signal_out(int n) const
bgneal@1 138 {
bgneal@1 139 // determine what contact we have at that position due to rotation
bgneal@1 140 const int contact = (n + pos) % 26;
bgneal@1 141
bgneal@1 142 // run it through the internal wiring
bgneal@1 143 const int pin = exit_map[contact];
bgneal@1 144
bgneal@1 145 // turn back into a position due to rotation
bgneal@1 146 return alpha_mod(pin - pos);
bgneal@1 147 }
bgneal@0 148
bgneal@0 149 // Return true if this rotor has a notch in the stepping position and false otherwise:
bgneal@1 150 bool notch_over_pawl() const
bgneal@1 151 {
bgneal@1 152 return step_map[display_val - 'A'];
bgneal@1 153 }
bgneal@0 154
bgneal@0 155 // Rotate the rotor forward one step:
bgneal@1 156 void rotate()
bgneal@1 157 {
bgneal@1 158 pos = (pos + 1) % 26;
bgneal@1 159 display_val = pos_map[pos];
bgneal@1 160 }
bgneal@0 161
bgneal@0 162 private:
bgneal@0 163 std::string rotor_name;
bgneal@0 164 std::string wiring_str;
bgneal@0 165 int ring_setting;
bgneal@0 166 int pos;
bgneal@1 167 char display_val;
bgneal@1 168 alpha_int_array entry_map;
bgneal@1 169 alpha_int_array exit_map;
bgneal@1 170 alpha_int_array display_map;
bgneal@1 171 alpha_int_array pos_map;
bgneal@1 172 alpha_bool_array step_map;
bgneal@0 173 };
bgneal@0 174 }
bgneal@0 175
bgneal@0 176 #endif