X-Git-Url: https://git.njae.me.uk/?a=blobdiff_plain;f=cipher.py;h=86125b38e805654f0957ec5e4fd27d7e285c5177;hb=5334c6e49cc35db0df35322a77ba0efe94a4abdd;hp=cd75d2cc505f61d788ac190cc186810ff32f6b04;hpb=1ca546941ac408759d3b10bc12d00a5d6b1b130a;p=cipher-tools.git

diff --git a/cipher.py b/cipher.py
index cd75d2c..86125b3 100644
--- a/cipher.py
+++ b/cipher.py
@@ -2,11 +2,28 @@ import string
 import collections
 import math
 from enum import Enum
-from itertools import zip_longest, cycle, chain
+from itertools import zip_longest, cycle, chain, count
 import numpy as np
 from numpy import matrix
 from numpy import linalg
 from language_models import *
+import pprint
+
+
+## Utility functions
+cat = ''.join
+wcat = ' '.join
+lcat = '\n'.join
+
+def pos(letter): 
+    if letter in string.ascii_lowercase:
+        return ord(letter) - ord('a')
+    elif letter in string.ascii_uppercase:
+        return ord(letter) - ord('A')
+    else:
+        return ''
+    
+def unpos(number): return chr(number % 26 + ord('a'))
 
 
 modular_division_table = [[0]*26 for _ in range(26)]
@@ -31,7 +48,7 @@ def every_nth(text, n, fillvalue=''):
     ['afkpuz', 'bglqv!', 'chmrw!', 'dinsx!', 'ejoty!']
     """
     split_text = chunks(text, n, fillvalue)
-    return [''.join(l) for l in zip_longest(*split_text, fillvalue=fillvalue)]
+    return [cat(l) for l in zip_longest(*split_text, fillvalue=fillvalue)]
 
 def combine_every_nth(split_text):
     """Reforms a text split into every_nth strings
@@ -43,7 +60,7 @@ def combine_every_nth(split_text):
     >>> combine_every_nth(every_nth(string.ascii_lowercase, 26))
     'abcdefghijklmnopqrstuvwxyz'
     """
-    return ''.join([''.join(l) 
+    return cat([cat(l) 
                     for l in zip_longest(*split_text, fillvalue='')])
 
 def chunks(text, n, fillvalue=None):
@@ -120,14 +137,24 @@ def caesar_encipher_letter(accented_letter, shift):
     >>> caesar_encipher_letter('é', 1)
     'f'
     """
+    # letter = unaccent(accented_letter)
+    # if letter in string.ascii_letters:
+    #     if letter in string.ascii_uppercase:
+    #         alphabet_start = ord('A')
+    #     else:
+    #         alphabet_start = ord('a')
+    #     return chr(((ord(letter) - alphabet_start + shift) % 26) + 
+    #                alphabet_start)
+    # else:
+    #     return letter
+
     letter = unaccent(accented_letter)
     if letter in string.ascii_letters:
+        cipherletter = unpos(pos(letter) + shift)
         if letter in string.ascii_uppercase:
-            alphabet_start = ord('A')
+            return cipherletter.upper()
         else:
-            alphabet_start = ord('a')
-        return chr(((ord(letter) - alphabet_start + shift) % 26) + 
-                   alphabet_start)
+            return cipherletter
     else:
         return letter
 
@@ -156,7 +183,7 @@ def caesar_encipher(message, shift):
     'Jgnnq Yqtnf!'
     """
     enciphered = [caesar_encipher_letter(l, shift) for l in message]
-    return ''.join(enciphered)
+    return cat(enciphered)
 
 def caesar_decipher(message, shift):
     """Decipher a message with the Caesar cipher of given shift
@@ -175,49 +202,74 @@ def caesar_decipher(message, shift):
 def affine_encipher_letter(accented_letter, multiplier=1, adder=0, one_based=True):
     """Encipher a letter, given a multiplier and adder
     
-    >>> ''.join([affine_encipher_letter(l, 3, 5, True) \
-            for l in string.ascii_uppercase])
-    'HKNQTWZCFILORUXADGJMPSVYBE'
-    >>> ''.join([affine_encipher_letter(l, 3, 5, False) \
-            for l in string.ascii_uppercase])
-    'FILORUXADGJMPSVYBEHKNQTWZC'
+    >>> cat(affine_encipher_letter(l, 3, 5, True) \
+            for l in string.ascii_letters)
+    'hknqtwzcfiloruxadgjmpsvybeHKNQTWZCFILORUXADGJMPSVYBE'
+    >>> cat(affine_encipher_letter(l, 3, 5, False) \
+            for l in string.ascii_letters)
+    'filoruxadgjmpsvybehknqtwzcFILORUXADGJMPSVYBEHKNQTWZC'
     """
+    # letter = unaccent(accented_letter)
+    # if letter in string.ascii_letters:
+    #     if letter in string.ascii_uppercase:
+    #         alphabet_start = ord('A')
+    #     else:
+    #         alphabet_start = ord('a')
+    #     letter_number = ord(letter) - alphabet_start
+    #     if one_based: letter_number += 1
+    #     cipher_number = (letter_number * multiplier + adder) % 26
+    #     if one_based: cipher_number -= 1
+    #     return chr(cipher_number % 26 + alphabet_start)
+    # else:
+    #     return letter
     letter = unaccent(accented_letter)
     if letter in string.ascii_letters:
-        if letter in string.ascii_uppercase:
-            alphabet_start = ord('A')
-        else:
-            alphabet_start = ord('a')
-        letter_number = ord(letter) - alphabet_start
+        letter_number = pos(letter)
         if one_based: letter_number += 1
         cipher_number = (letter_number * multiplier + adder) % 26
         if one_based: cipher_number -= 1
-        return chr(cipher_number % 26 + alphabet_start)
+        if letter in string.ascii_uppercase:
+            return unpos(cipher_number).upper()
+        else:
+            return unpos(cipher_number)
     else:
         return letter
 
 def affine_decipher_letter(letter, multiplier=1, adder=0, one_based=True):
     """Encipher a letter, given a multiplier and adder
     
-    >>> ''.join([affine_decipher_letter(l, 3, 5, True) \
-            for l in 'HKNQTWZCFILORUXADGJMPSVYBE'])
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-    >>> ''.join([affine_decipher_letter(l, 3, 5, False) \
-            for l in 'FILORUXADGJMPSVYBEHKNQTWZC'])
-    'ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    >>> cat(affine_decipher_letter(l, 3, 5, True) \
+            for l in 'hknqtwzcfiloruxadgjmpsvybeHKNQTWZCFILORUXADGJMPSVYBE')
+    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
+    >>> cat(affine_decipher_letter(l, 3, 5, False) \
+            for l in 'filoruxadgjmpsvybehknqtwzcFILORUXADGJMPSVYBEHKNQTWZC')
+    'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ'
     """
+    # if letter in string.ascii_letters:
+    #     if letter in string.ascii_uppercase:
+    #         alphabet_start = ord('A')
+    #     else:
+    #         alphabet_start = ord('a')
+    #     cipher_number = ord(letter) - alphabet_start
+    #     if one_based: cipher_number += 1
+    #     plaintext_number = ( 
+    #         modular_division_table[multiplier]
+    #                               [(cipher_number - adder) % 26])
+    #     if one_based: plaintext_number -= 1
+    #     return chr(plaintext_number % 26 + alphabet_start) 
+    # else:
+    #     return letter
     if letter in string.ascii_letters:
-        if letter in string.ascii_uppercase:
-            alphabet_start = ord('A')
-        else:
-            alphabet_start = ord('a')
-        cipher_number = ord(letter) - alphabet_start
+        cipher_number = pos(letter)
         if one_based: cipher_number += 1
         plaintext_number = ( 
             modular_division_table[multiplier]
                                   [(cipher_number - adder) % 26])
         if one_based: plaintext_number -= 1
-        return chr(plaintext_number % 26 + alphabet_start) 
+        if letter in string.ascii_uppercase:
+            return unpos(plaintext_number).upper()
+        else:
+            return unpos(plaintext_number) 
     else:
         return letter
 
@@ -230,7 +282,7 @@ def affine_encipher(message, multiplier=1, adder=0, one_based=True):
     """
     enciphered = [affine_encipher_letter(l, multiplier, adder, one_based) 
                   for l in message]
-    return ''.join(enciphered)
+    return cat(enciphered)
 
 def affine_decipher(message, multiplier=1, adder=0, one_based=True):
     """Decipher a message
@@ -241,7 +293,7 @@ def affine_decipher(message, multiplier=1, adder=0, one_based=True):
     """
     enciphered = [affine_decipher_letter(l, multiplier, adder, one_based) 
                   for l in message]
-    return ''.join(enciphered)
+    return cat(enciphered)
 
 
 class KeywordWrapAlphabet(Enum):
@@ -265,7 +317,7 @@ def keyword_cipher_alphabet_of(keyword, wrap_alphabet=KeywordWrapAlphabet.from_a
     'bayeszcdfghijklmnopqrtuvwx'
     """
     if wrap_alphabet == KeywordWrapAlphabet.from_a:
-        cipher_alphabet = ''.join(deduplicate(sanitise(keyword) + 
+        cipher_alphabet = cat(deduplicate(sanitise(keyword) + 
                                               string.ascii_lowercase))
     else:
         if wrap_alphabet == KeywordWrapAlphabet.from_last:
@@ -274,7 +326,7 @@ def keyword_cipher_alphabet_of(keyword, wrap_alphabet=KeywordWrapAlphabet.from_a
             last_keyword_letter = sorted(sanitise(keyword))[-1]
         last_keyword_position = string.ascii_lowercase.find(
             last_keyword_letter) + 1
-        cipher_alphabet = ''.join(
+        cipher_alphabet = cat(
             deduplicate(sanitise(keyword) + 
                         string.ascii_lowercase[last_keyword_position:] + 
                         string.ascii_lowercase))
@@ -330,9 +382,9 @@ def vigenere_encipher(message, keyword):
     >>> vigenere_encipher('hello', 'abc')
     'hfnlp'
     """
-    shifts = [ord(l) - ord('a') for l in sanitise(keyword)]
+    shifts = [pos(l) for l in sanitise(keyword)]
     pairs = zip(message, cycle(shifts))
-    return ''.join([caesar_encipher_letter(l, k) for l, k in pairs])
+    return cat([caesar_encipher_letter(l, k) for l, k in pairs])
 
 def vigenere_decipher(message, keyword):
     """Vigenere decipher
@@ -340,12 +392,129 @@ def vigenere_decipher(message, keyword):
     >>> vigenere_decipher('hfnlp', 'abc')
     'hello'
     """
-    shifts = [ord(l) - ord('a') for l in sanitise(keyword)]
+    shifts = [pos(l) for l in sanitise(keyword)]
+    pairs = zip(message, cycle(shifts))
+    return cat([caesar_decipher_letter(l, k) for l, k in pairs])
+
+
+def beaufort_encipher(message, keyword):
+    """Beaufort encipher
+
+    >>> beaufort_encipher('inhisjournaldatedtheidesofoctober', 'arcanaimperii')
+    'sevsvrusyrrxfayyxuteemazudmpjmmwr'
+    """
+    shifts = [pos(l) for l in sanitise(keyword)]
     pairs = zip(message, cycle(shifts))
-    return ''.join([caesar_decipher_letter(l, k) for l, k in pairs])
+    return cat([unpos(k - pos(l)) for l, k in pairs])
+
+beaufort_decipher = beaufort_encipher    
+
+beaufort_variant_encipher=vigenere_decipher
+beaufort_variant_decipher=vigenere_encipher
+
+
+def polybius_grid(keyword, column_order, row_order, letters_to_merge=None,
+                  wrap_alphabet=KeywordWrapAlphabet.from_a):
+    """Grid for a Polybius cipher, using a keyword to rearrange the
+    alphabet.
 
-beaufort_encipher=vigenere_decipher
-beaufort_decipher=vigenere_encipher
+
+    >>> polybius_grid('a', 'abcde', 'abcde')['x'] == ('e', 'c')
+    True
+    >>> polybius_grid('elephant', 'abcde', 'abcde')['e'] == ('a', 'a')
+    True
+    >>> polybius_grid('elephant', 'abcde', 'abcde')['b'] == ('b', 'c')
+    True
+    """
+    alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet=wrap_alphabet)
+    if letters_to_merge is None: 
+        letters_to_merge = {'j': 'i'}
+    grid = {l: k 
+            for k, l in zip([(c, r) for c in column_order for r in row_order],
+                [l for l in alphabet if l not in letters_to_merge])}
+    for l in letters_to_merge:
+        grid[l] = grid[letters_to_merge[l]]
+    return grid
+
+def polybius_reverse_grid(keyword, column_order, row_order, letters_to_merge=None,
+                  wrap_alphabet=KeywordWrapAlphabet.from_a):
+    """Grid for decrypting using a Polybius cipher, using a keyword to 
+    rearrange the alphabet.
+
+    >>> polybius_reverse_grid('a', 'abcde', 'abcde')['e', 'c'] == 'x'
+    True
+    >>> polybius_reverse_grid('elephant', 'abcde', 'abcde')['a', 'a'] == 'e'
+    True
+    >>> polybius_reverse_grid('elephant', 'abcde', 'abcde')['b', 'c'] == 'b'
+    True
+    """
+    alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet=wrap_alphabet)
+    if letters_to_merge is None: 
+        letters_to_merge = {'j': 'i'}
+    grid = {k: l 
+            for k, l in zip([(c, r) for c in column_order for r in row_order],
+                [l for l in alphabet if l not in letters_to_merge])}
+    return grid  
+
+
+def polybius_flatten(pair, column_first):
+    """Convert a series of pairs into a single list of characters"""
+    if column_first:
+        return str(pair[1]) + str(pair[0])
+    else:
+        return str(pair[0]) + str(pair[1])
+
+def polybius_encipher(message, keyword, column_order, row_order, 
+                      column_first=False,
+                      letters_to_merge=None, wrap_alphabet=KeywordWrapAlphabet.from_a): 
+    """Encipher a message with Polybius cipher, using a keyword to rearrange
+    the alphabet
+
+
+    >>> polybius_encipher('this is a test message for the ' \
+          'polybius decipherment', 'elephant', \
+          [1, 2, 3, 4, 5], [1, 2, 3, 4, 5], \
+          wrap_alphabet=KeywordWrapAlphabet.from_last)
+    '2214445544551522115522511155551543114252542214111352123234442355411135441314115451112122'
+    >>> polybius_encipher('this is a test message for the ' \
+          'polybius decipherment', 'elephant', 'abcde', 'abcde', \
+          column_first=False)
+    'bbadccddccddaebbaaddbbceaaddddaecbaacadadcbbadaaacdaabedbcccdeddbeaabdccacadaadcceaababb'
+    >>> polybius_encipher('this is a test message for the ' \
+          'polybius decipherment', 'elephant', 'abcde', 'abcde', \
+          column_first=True)
+    'bbdaccddccddeabbaaddbbecaaddddeabcaaacadcdbbdaaacaadbadecbccedddebaadbcccadaaacdecaaabbb'
+    """
+    grid = polybius_grid(keyword, column_order, row_order, letters_to_merge, wrap_alphabet)
+    return cat(polybius_flatten(grid[l], column_first)
+               for l in message
+               if l in grid)
+
+
+def polybius_decipher(message, keyword, column_order, row_order, 
+                      column_first=False,
+                      letters_to_merge=None, wrap_alphabet=KeywordWrapAlphabet.from_a):    
+    """Decipher a message with a Polybius cipher, using a keyword to rearrange
+    the alphabet
+
+    >>> polybius_decipher('bbdaccddccddeabbaaddbbecaaddddeabcaaacadcdbbdaaaca'\
+    'adbadecbccedddebaadbcccadaaacdecaaabbb', 'elephant', 'abcde', 'abcde', \
+    column_first=False)
+    'toisisvtestxessvbephktoefhnugiysweqifoekxelt'
+
+    >>> polybius_decipher('bbdaccddccddeabbaaddbbecaaddddeabcaaacadcdbbdaaaca'\
+    'adbadecbccedddebaadbcccadaaacdecaaabbb', 'elephant', 'abcde', 'abcde', \
+    column_first=True)
+    'thisisatestmessageforthepolybiusdecipherment'
+    """
+    grid = polybius_reverse_grid(keyword, column_order, row_order, letters_to_merge, wrap_alphabet)
+    column_index_type = type(column_order[0])
+    row_index_type = type(row_order[0])
+    if column_first:
+        pairs = [(column_index_type(p[1]), row_index_type(p[0])) for p in chunks(message, 2)]
+    else:
+        pairs = [(row_index_type(p[0]), column_index_type(p[1])) for p in chunks(message, 2)]
+    return cat(grid[p] for p in pairs if p in grid)
 
 
 def transpositions_of(keyword):
@@ -428,7 +597,7 @@ def column_transposition_encipher(message, keyword, fillvalue=' ',
     if emptycolumnwise:
         return combine_every_nth(transposed)
     else:
-        return ''.join(chain(*transposed))
+        return cat(chain(*transposed))
 
 def column_transposition_decipher(message, keyword, fillvalue=' ', 
       fillcolumnwise=False,
@@ -463,7 +632,7 @@ def column_transposition_decipher(message, keyword, fillvalue=' ',
     if fillcolumnwise:
         return combine_every_nth(untransposed)
     else:
-        return ''.join(chain(*untransposed))
+        return cat(chain(*untransposed))
 
 def scytale_encipher(message, rows, fillvalue=' '):
     """Enciphers using the scytale transposition cipher.
@@ -544,14 +713,14 @@ def railfence_encipher(message, height, fillvalue=''):
     sections = chunks(message, (height - 1) * 2, fillvalue=fillvalue)
     n_sections = len(sections)
     # Add the top row
-    rows = [''.join([s[0] for s in sections])]
+    rows = [cat([s[0] for s in sections])]
     # process the middle rows of the grid
     for r in range(1, height-1):
-        rows += [''.join([s[r:r+1] + s[height*2-r-2:height*2-r-1] for s in sections])]
+        rows += [cat([s[r:r+1] + s[height*2-r-2:height*2-r-1] for s in sections])]
     # process the bottom row
-    rows += [''.join([s[height - 1:height] for s in sections])]
-    # rows += [' '.join([s[height - 1] for s in sections])]
-    return ''.join(rows)
+    rows += [cat([s[height - 1:height] for s in sections])]
+    # rows += [wcat([s[height - 1] for s in sections])]
+    return cat(rows)
 
 def railfence_decipher(message, height, fillvalue=''):
     """Railfence decipher. 
@@ -626,11 +795,98 @@ def railfence_decipher(message, height, fillvalue=''):
     down_rows = [rows[0]]
     up_rows = []
     for i in range(1, height-1):
-        down_rows += [''.join([c for n, c in enumerate(rows[i]) if n % 2 == 0])]
-        up_rows += [''.join([c for n, c in enumerate(rows[i]) if n % 2 == 1])]
+        down_rows += [cat([c for n, c in enumerate(rows[i]) if n % 2 == 0])]
+        up_rows += [cat([c for n, c in enumerate(rows[i]) if n % 2 == 1])]
     down_rows += [rows[-1]]
     up_rows.reverse()
-    return ''.join(c for r in zip_longest(*(down_rows + up_rows), fillvalue='') for c in r)
+    return cat(c for r in zip_longest(*(down_rows + up_rows), fillvalue='') for c in r)
+
+def make_cadenus_keycolumn(doubled_letters = 'vw', start='a', reverse=False):
+    """Makes the key column for a Cadenus cipher (the column down between the
+        rows of letters)
+
+    >>> make_cadenus_keycolumn()['a']
+    0
+    >>> make_cadenus_keycolumn()['b']
+    1
+    >>> make_cadenus_keycolumn()['c']
+    2
+    >>> make_cadenus_keycolumn()['v']
+    21
+    >>> make_cadenus_keycolumn()['w']
+    21
+    >>> make_cadenus_keycolumn()['z']
+    24
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['a']
+    1
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['b']
+    0
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['c']
+    24
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['i']
+    18
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['j']
+    18
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['v']
+    6
+    >>> make_cadenus_keycolumn(doubled_letters='ij', start='b', reverse=True)['z']
+    2
+    """
+    index_to_remove = string.ascii_lowercase.find(doubled_letters[0])
+    short_alphabet = string.ascii_lowercase[:index_to_remove] + string.ascii_lowercase[index_to_remove+1:]
+    if reverse:
+        short_alphabet = cat(reversed(short_alphabet))
+    start_pos = short_alphabet.find(start)
+    rotated_alphabet = short_alphabet[start_pos:] + short_alphabet[:start_pos]
+    keycolumn = {l: i for i, l in enumerate(rotated_alphabet)}
+    keycolumn[doubled_letters[0]] = keycolumn[doubled_letters[1]]
+    return keycolumn
+
+def cadenus_encipher(message, keyword, keycolumn, fillvalue='a'):
+    """Encipher with the Cadenus cipher
+
+    >>> cadenus_encipher(sanitise('Whoever has made a voyage up the Hudson ' \
+                                  'must remember the Kaatskill mountains. ' \
+                                  'They are a dismembered branch of the great'), \
+                'wink', \
+                make_cadenus_keycolumn(doubled_letters='vw', start='a', reverse=True))
+    'antodeleeeuhrsidrbhmhdrrhnimefmthgeaetakseomehetyaasuvoyegrastmmuuaeenabbtpchehtarorikswosmvaleatned'
+    >>> cadenus_encipher(sanitise('a severe limitation on the usefulness of ' \
+                                  'the cadenus is that every message must be ' \
+                                  'a multiple of twenty-five letters long'), \
+                'easy', \
+                make_cadenus_keycolumn(doubled_letters='vw', start='a', reverse=True))
+    'systretomtattlusoatleeesfiyheasdfnmschbhneuvsnpmtofarenuseieeieltarlmentieetogevesitfaisltngeeuvowul'
+    """
+    rows = chunks(message, len(message) // 25, fillvalue=fillvalue)
+    columns = zip(*rows)
+    rotated_columns = [col[start:] + col[:start] for start, col in zip([keycolumn[l] for l in keyword], columns)]    
+    rotated_rows = zip(*rotated_columns)
+    transpositions = transpositions_of(keyword)
+    transposed = [transpose(r, transpositions) for r in rotated_rows]
+    return cat(chain(*transposed))
+
+def cadenus_decipher(message, keyword, keycolumn, fillvalue='a'):
+    """
+    >>> cadenus_decipher('antodeleeeuhrsidrbhmhdrrhnimefmthgeaetakseomehetyaa' \
+                         'suvoyegrastmmuuaeenabbtpchehtarorikswosmvaleatned', \
+                 'wink', \
+                 make_cadenus_keycolumn(reverse=True))
+    'whoeverhasmadeavoyageupthehudsonmustrememberthekaatskillmountainstheyareadismemberedbranchofthegreat'
+    >>> cadenus_decipher('systretomtattlusoatleeesfiyheasdfnmschbhneuvsnpmtof' \
+                        'arenuseieeieltarlmentieetogevesitfaisltngeeuvowul', \
+                 'easy', \
+                 make_cadenus_keycolumn(reverse=True))
+    'aseverelimitationontheusefulnessofthecadenusisthateverymessagemustbeamultipleoftwentyfiveletterslong'
+    """
+    rows = chunks(message, len(message) // 25, fillvalue=fillvalue)
+    transpositions = transpositions_of(keyword)
+    untransposed_rows = [untranspose(r, transpositions) for r in rows]
+    columns = zip(*untransposed_rows)
+    rotated_columns = [col[-start:] + col[:-start] for start, col in zip([keycolumn[l] for l in keyword], columns)]    
+    rotated_rows = zip(*rotated_columns)
+    # return rotated_columns
+    return cat(chain(*rotated_rows))
 
 
 def hill_encipher(matrix, message_letters, fillvalue='a'):
@@ -648,15 +904,14 @@ def hill_encipher(matrix, message_letters, fillvalue='a'):
         padding = fillvalue[0] * (n - len(sanitised_message) % n)
     else:
         padding = ''
-    message = [ord(c) - ord('a') for c in sanitised_message + padding]
+    message = [pos(c) for c in sanitised_message + padding]
     message_chunks = [message[i:i+n] for i in range(0, len(message), n)]
     # message_chunks = chunks(message, len(matrix), fillvalue=None)
     enciphered_chunks = [((matrix * np.matrix(c).T).T).tolist()[0] 
             for c in message_chunks]
-    return ''.join([chr(int(round(l)) % 26 + ord('a')) 
+    return cat([unpos(round(l))
             for l in sum(enciphered_chunks, [])])
 
-
 def hill_decipher(matrix, message, fillvalue='a'):
     """Hill cipher
 
@@ -671,6 +926,217 @@ def hill_decipher(matrix, message, fillvalue='a'):
     inverse_matrix = (inverse_determinant * adjoint) % 26
     return hill_encipher(inverse_matrix, message, fillvalue)          
 
+
+# Where each piece of text ends up in the AMSCO transpositon cipher.
+# 'index' shows where the slice appears in the plaintext, with the slice
+# from 'start' to 'end'
+AmscoSlice = collections.namedtuple('AmscoSlice', ['index', 'start', 'end'])
+
+class AmscoFillStyle(Enum):
+    continuous = 1
+    same_each_row = 2
+    reverse_each_row = 3
+
+def amsco_transposition_positions(message, keyword, 
+      fillpattern=(1, 2),
+      fillstyle=AmscoFillStyle.continuous,
+      fillcolumnwise=False,
+      emptycolumnwise=True):
+    """Creates the grid for the AMSCO transposition cipher. Each element in the
+    grid shows the index of that slice and the start and end positions of the
+    plaintext that go to make it up.
+
+    >>> amsco_transposition_positions(string.ascii_lowercase, 'freddy', \
+        fillpattern=(1, 2)) # doctest:  +NORMALIZE_WHITESPACE
+    [[AmscoSlice(index=3, start=4, end=6),
+     AmscoSlice(index=2, start=3, end=4),
+     AmscoSlice(index=0, start=0, end=1),
+     AmscoSlice(index=1, start=1, end=3),
+     AmscoSlice(index=4, start=6, end=7)],
+    [AmscoSlice(index=8, start=12, end=13),
+     AmscoSlice(index=7, start=10, end=12),
+     AmscoSlice(index=5, start=7, end=9),
+     AmscoSlice(index=6, start=9, end=10),
+     AmscoSlice(index=9, start=13, end=15)],
+    [AmscoSlice(index=13, start=19, end=21),
+     AmscoSlice(index=12, start=18, end=19),
+     AmscoSlice(index=10, start=15, end=16),
+     AmscoSlice(index=11, start=16, end=18),
+     AmscoSlice(index=14, start=21, end=22)],
+    [AmscoSlice(index=18, start=27, end=28),
+     AmscoSlice(index=17, start=25, end=27),
+     AmscoSlice(index=15, start=22, end=24),
+     AmscoSlice(index=16, start=24, end=25),
+     AmscoSlice(index=19, start=28, end=30)]]
+    """
+    transpositions = transpositions_of(keyword)
+    fill_iterator = cycle(fillpattern)
+    indices = count()
+    message_length = len(message)
+
+    current_position = 0
+    grid = []
+    current_fillpattern = fillpattern
+    while current_position < message_length:
+        row = []
+        if fillstyle == AmscoFillStyle.same_each_row:
+            fill_iterator = cycle(fillpattern)
+        if fillstyle == AmscoFillStyle.reverse_each_row:
+            fill_iterator = cycle(current_fillpattern)
+        for _ in range(len(transpositions)):
+            index = next(indices)
+            gap = next(fill_iterator)
+            row += [AmscoSlice(index, current_position, current_position + gap)]
+            current_position += gap
+        grid += [row]
+        if fillstyle == AmscoFillStyle.reverse_each_row:
+            current_fillpattern = list(reversed(current_fillpattern))
+    return [transpose(r, transpositions) for r in grid]
+
+def amsco_transposition_encipher(message, keyword, 
+    fillpattern=(1,2), fillstyle=AmscoFillStyle.reverse_each_row):
+    """AMSCO transposition encipher.
+
+    >>> amsco_transposition_encipher('hellothere', 'abc', fillpattern=(1, 2))
+    'hoteelhler'
+    >>> amsco_transposition_encipher('hellothere', 'abc', fillpattern=(2, 1))
+    'hetelhelor'
+    >>> amsco_transposition_encipher('hellothere', 'acb', fillpattern=(1, 2))
+    'hotelerelh'
+    >>> amsco_transposition_encipher('hellothere', 'acb', fillpattern=(2, 1))
+    'hetelorlhe'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'encode')
+    'etecstthhomoerereenisxip'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(1, 2))
+    'hetcsoeisterereipexthomn'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(1, 2), fillstyle=AmscoFillStyle.continuous)
+    'hecsoisttererteipexhomen'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(2, 1))
+    'heecisoosttrrtepeixhemen'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(1, 3, 2))
+    'hxtomephescieretoeisnter'
+    >>> amsco_transposition_encipher('hereissometexttoencipher', 'cipher', fillpattern=(1, 3, 2), fillstyle=AmscoFillStyle.continuous)
+    'hxomeiphscerettoisenteer'
+    """
+    grid = amsco_transposition_positions(message, keyword, 
+        fillpattern=fillpattern, fillstyle=fillstyle)
+    ct_as_grid = [[message[s.start:s.end] for s in r] for r in grid]
+    return combine_every_nth(ct_as_grid)
+
+
+def amsco_transposition_decipher(message, keyword, 
+    fillpattern=(1,2), fillstyle=AmscoFillStyle.reverse_each_row):
+    """AMSCO transposition decipher
+
+    >>> amsco_transposition_decipher('hoteelhler', 'abc', fillpattern=(1, 2))
+    'hellothere'
+    >>> amsco_transposition_decipher('hetelhelor', 'abc', fillpattern=(2, 1))
+    'hellothere'
+    >>> amsco_transposition_decipher('hotelerelh', 'acb', fillpattern=(1, 2))
+    'hellothere'
+    >>> amsco_transposition_decipher('hetelorlhe', 'acb', fillpattern=(2, 1))
+    'hellothere'
+    >>> amsco_transposition_decipher('etecstthhomoerereenisxip', 'encode')
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('hetcsoeisterereipexthomn', 'cipher', fillpattern=(1, 2))
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('hecsoisttererteipexhomen', 'cipher', fillpattern=(1, 2), fillstyle=AmscoFillStyle.continuous)
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('heecisoosttrrtepeixhemen', 'cipher', fillpattern=(2, 1))
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('hxtomephescieretoeisnter', 'cipher', fillpattern=(1, 3, 2))
+    'hereissometexttoencipher'
+    >>> amsco_transposition_decipher('hxomeiphscerettoisenteer', 'cipher', fillpattern=(1, 3, 2), fillstyle=AmscoFillStyle.continuous)
+    'hereissometexttoencipher'
+    """
+
+    grid = amsco_transposition_positions(message, keyword, 
+        fillpattern=fillpattern, fillstyle=fillstyle)
+    transposed_sections = [s for c in [l for l in zip(*grid)] for s in c]
+    plaintext_list = [''] * len(transposed_sections)
+    current_pos = 0
+    for slice in transposed_sections:
+        plaintext_list[slice.index] = message[current_pos:current_pos-slice.start+slice.end][:len(message[slice.start:slice.end])]
+        current_pos += len(message[slice.start:slice.end])
+    return cat(plaintext_list)
+
+
+def bifid_grid(keyword, wrap_alphabet, letter_mapping):
+    """Create the grids for a Bifid cipher
+    """
+    cipher_alphabet = keyword_cipher_alphabet_of(keyword, wrap_alphabet)
+    if letter_mapping is None:
+        letter_mapping = {'j': 'i'}
+    translation = ''.maketrans(letter_mapping)
+    cipher_alphabet = cat(collections.OrderedDict.fromkeys(cipher_alphabet.translate(translation)))
+    f_grid = {k: ((i // 5) + 1, (i % 5) + 1) 
+              for i, k in enumerate(cipher_alphabet)}
+    r_grid = {((i // 5) + 1, (i % 5) + 1): k 
+              for i, k in enumerate(cipher_alphabet)}
+    return translation, f_grid, r_grid
+
+def bifid_encipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a, 
+                   letter_mapping=None, period=None, fillvalue=None):
+    """Bifid cipher
+
+    >>> bifid_encipher("indiajelly", 'iguana')
+    'ibidonhprm'
+    >>> bifid_encipher("indiacurry", 'iguana', period=4)
+    'ibnhgaqltm'
+    >>> bifid_encipher("indiacurry", 'iguana', period=4, fillvalue='x')
+    'ibnhgaqltzml'
+    """
+    translation, f_grid, r_grid = bifid_grid(keyword, wrap_alphabet, letter_mapping)
+    
+    t_message = message.translate(translation)
+    pairs0 = [f_grid[l] for l in sanitise(t_message)]
+    if period:
+        chunked_pairs = [pairs0[i:i+period] for i in range(0, len(pairs0), period)]
+        if len(chunked_pairs[-1]) < period and fillvalue:
+            chunked_pairs[-1] += [f_grid[fillvalue]] * (period - len(chunked_pairs[-1]))
+    else:
+        chunked_pairs = [pairs0]
+    
+    pairs1 = []
+    for c in chunked_pairs:
+        items = sum(list(list(i) for i in zip(*c)), [])
+        p = [(items[i], items[i+1]) for i in range(0, len(items), 2)]
+        pairs1 += p
+    
+    return cat(r_grid[p] for p in pairs1)
+
+
+def bifid_decipher(message, keyword, wrap_alphabet=KeywordWrapAlphabet.from_a, 
+                   letter_mapping=None, period=None, fillvalue=None):
+    """Decipher with bifid cipher
+
+    >>> bifid_decipher('ibidonhprm', 'iguana')
+    'indiaielly'
+    >>> bifid_decipher("ibnhgaqltm", 'iguana', period=4)
+    'indiacurry'
+    >>> bifid_decipher("ibnhgaqltzml", 'iguana', period=4)
+    'indiacurryxx'
+    """
+    translation, f_grid, r_grid = bifid_grid(keyword, wrap_alphabet, letter_mapping)
+    
+    t_message = message.translate(translation)
+    pairs0 = [f_grid[l] for l in sanitise(t_message)]
+    if period:
+        chunked_pairs = [pairs0[i:i+period] for i in range(0, len(pairs0), period)]
+        if len(chunked_pairs[-1]) < period and fillvalue:
+            chunked_pairs[-1] += [f_grid[fillvalue]] * (period - len(chunked_pairs[-1]))
+    else:
+        chunked_pairs = [pairs0]
+        
+    pairs1 = []
+    for c in chunked_pairs:
+        items = [j for i in c for j in i]
+        gap = len(c)
+        p = [(items[i], items[i+gap]) for i in range(gap)]
+        pairs1 += p
+
+    return cat(r_grid[p] for p in pairs1) 
+
 class PocketEnigma(object):
     """A pocket enigma machine
     The wheel is internally represented as a 26-element list self.wheel_map, 
@@ -705,7 +1171,7 @@ class PocketEnigma(object):
             self.validate_wheel_spec(wheel)
             self.make_wheel_map(wheel)
         if position in string.ascii_lowercase:
-            self.position = ord(position) - ord('a')
+            self.position = pos(position)
         else:
             self.position = position
 
@@ -719,8 +1185,8 @@ class PocketEnigma(object):
         self.validate_wheel_spec(wheel_spec)
         self.wheel_map = [0] * 26
         for p in wheel_spec:
-            self.wheel_map[ord(p[0]) - ord('a')] = ord(p[1]) - ord('a')
-            self.wheel_map[ord(p[1]) - ord('a')] = ord(p[0]) - ord('a')
+            self.wheel_map[pos(p[0])] = pos(p[1])
+            self.wheel_map[pos(p[1])] = pos(p[0])
         return self.wheel_map
 
     def validate_wheel_spec(self, wheel_spec):
@@ -769,16 +1235,15 @@ class PocketEnigma(object):
 
         >>> pe.set_position('f')
         5
-        >>> ''.join([pe.lookup(l) for l in string.ascii_lowercase])
+        >>> cat([pe.lookup(l) for l in string.ascii_lowercase])
         'udhbfejcpgmokrliwntsayqzvx'
         >>> pe.lookup('A')
         ''
         """
         if letter in string.ascii_lowercase:
-            return chr(
-                (self.wheel_map[(ord(letter) - ord('a') - self.position) % 26] + 
-                    self.position) % 26 + 
-                ord('a'))
+            return unpos(
+                (self.wheel_map[(pos(letter) - self.position) % 26] + 
+                    self.position))
         else:
             return ''
 
@@ -826,7 +1291,7 @@ class PocketEnigma(object):
         >>> pe.set_position('z')
         25
         """
-        self.position = ord(position) - ord('a')
+        self.position = pos(position)
         return self.position