n = 1: C(1) = ['0','1'].
n = 2: C(2) = ['00','01','11','10'].
n = 3: C(3) = ['000','001','011','010',´110´,´111´,´101´,´100´].
def gray(n):
if n == 0:
yield ""
else:
base = list(gray_code(n-1))
for code in base:
yield "0"+code
for code in reversed(base):
yield "1"+code
Example:
* (table (A,B,C) (A and (B or C) equ A and B or A and C))
true true true true
true true fail true
true fail true true
true fail fail true
fail true true true
fail true fail true
fail fail true true
fail fail fail true
def int_to_bool_tuple(x,size):
result = []
while x:
result.insert(0, (x & 1) == 1)
x >>= 1
return ([False]*(size-len(result))) + result
def table2(var_count, func):
for x in range(2**var_count):
bools = int_to_bool_tuple(x,var_count)
for b in bools:
print "%-5s" % b,
print func(*bools)
def and_(x,y): return x and y
def or_ (x,y): return x or y
def not_(x): return not x
def nand_(x,y): return not (x and y)
def nor_(x,y): return not (x or y)
def xor_(x,y): return x ^ y
def impl_(x,y):return not x or y
def equ_(x,y): return x == y
def bool_table(func):
inputs = [(x,y) for x in (True,False) for y in (True,False)]
for x,y in inputs:
print "%-5s %-5s %-5s" % (x,y,func(x,y))
# using goldbach as defined previously
def goldbach_list(start,end,threshold=None):
start = max([start,4])
for n in range(start,end+1):
if n % 2 == 0:
i,j = goldbach(n)
if threshold == None or i > threshold:
print "%d = %d + %d" % (n, i, j)
# using primes_range from previous problem
def goldbach(n):
assert n % 2 == 0
for i in primes_range(2, n):
for j in primes_range(i, n):
if i + j == n:
return (i,j)
# using is_prime from earlier problem
def primes_range(start,end):
return [n for n in range(start, end+1) if is_prime(n)]
# using prime_factors_mult from earlier
def totient_phi2(n):
if n == 1:
return 1
def product(lst):
return reduce(lambda x,y: x*y, lst)
return product([((p-1)*(p**(m-1))) for (p, m) in prime_factors_mult(n)])
#using prime_factors from the previous problem
import itertools
def prime_factors_mult(n):
return [(x, len(list(y))) for x,y in itertools.groupby(prime_factors(n))]
def prime_factors(n):
factor = 2
while n > 1:
if n % factor == 0:
yield factor
n = n / factor
else:
factor += 1
# using coprime defined previously
def totient_phi(m):
if m == 1:
return 1
return len([r for r in range(1,m) if coprime(r,m)])
For this session we'll get bicycle repair man support working.
First let's see if we can get brm working by itself and then see how it integrates into emacs.
To start it I ran:
M-x python-setup-brm
It took a little googling and experimentation to figure out how to use this. But I finally figured out that if you select some text then the menus do their thing.
This is a strange little tool. I guess I'm so used to refactoring with global search and replaces that this seems overly constraining. But perhaps it's just unfamiliar. I suspect that if you got used to it then you could learn to like it, but I'm skeptical. One behavior that was very counter intuitive is that you can't use the normal emacs undo to revert the refactoring change. You have to do it via the menus (or presumably the brm console). In any case let's look at the code that runs brm.
Firstly it does an autoload of pymacs.
I've never really played with this before but you can see that it is loaded correctly and working by doing the following in *scratch*:
(pymacs-eval "2 + 2")
4
The second prep step is to get the bicycle repair man module itself loaded:
(autoload 'brm-init "bikemacs")
Which I'm assuming works since I was able to do a refactoring
This code is mostly just busy work to set up of menus.
Strangely this code ends with an (error ... ) embedded in an (error ...).
Not sure what that is about.
Interestingly in the comments the author of python.el expresses doubts that brm is useful.
Note to self, I should also look at ropemacs. Looks like rope has more features and if I recall an earlier experiment correctly does autocomplete of python variables/modules as well.
Any way, onward and upward. Next stop, context sensitive help.
def coprime(m,n):
return gcd(m,n) == 1
def gcd(m,n):
m,n = sorted([m,n])
while m != 0:
m, n = (n % m), m
return n
We are actually getting to the point where this mode would actually be useful for developing with.
Next let's get skeleton support working now.
Here are the new functions I've copied over:
python-use-skeletons
python-skeletons
python-mode-abbrev-table
def-python-skeleton
def-python-skeleton if
define-skeleton python-else
def-python-skeleton while
def-python-skeleton for
def-python-skeleton try/except
define-skeleton python-target
def-python-skeleton try/finally
def-python-skeleton def
def-python-skeleton class
python-default-template "if"
python-expand-template
This controls whether or not skeleton functions are added to the python-mode-abbrev-table
A list of all the skeletons. apparently used when working on compound statements.
This is where the actual abbrevs are stored
A macro for getting a skeletons "registered" in the abbrev system. First it creates a name for the skeleton of the form: python-insert-foo. Then if adds this name to the pyton-mode-abbrev-table. Finally it calls define-skeleton and creates the skeleton.
def-python-skeleton if
def-python-skeleton while
def-python-skeleton for
def-python-skeleton try/except
def-python-skeleton try/finally
def-python-skeleton def
def-python-skeleton class
else clause used by if and other else-able statements. One reason I would find it hard to get excited about using this particular skeleton/template system is that it seems sort of ridiculous to be prompted after a for loop or a while loop, etc for an else clause. I can count on 1 hand how many times i've ever used an else clause other than part of an if cascade. It seems like an unnecessary burden to make the user consider this case every time they are writing a for loop.
Helper used by try/except
Variable that defines what template to use by default in python-expand-template
This function is for allowing a skeleton to be used directly as a key sequence rather than as an abbrev. Interestingly if defaults to the "if" template but then let's you update what the default is.
I'm not totally sold on the value of skeletons for python. The syntax is already so minimal that the distraction of writing code through the minibuffer doesn't seem like a big win but it's something i'd like to explore in detail sometime and see if it works for me if i give it a chance.
Next let's get bicycle repair man support working.
import math
def is_prime(n):
for test in range(2, int(math.sqrt(n) + 1)):
if n % test == 0:
return False
return True
primes = sieve [2..]
where sieve (p:xs) = p : sieve [x | x<-xs, x `mod` p /= 0]
sorted(lst_of_lsts, key=lambda x: len(x))
sorted(sorted(lst_of_lsts), key=lambda x: len(x))
def length_frequency_sort(lst_of_lists):
freqs = {}
for lst in lst_of_lists:
freqs.setdefault(len(lst), 0)
freqs[len(lst)] += 1
return sorted(lst_of_lists, key=lambda x: freqs[len(x)])
def combination(lst, size):
#defined as in previous problem
def grouped_combos(lst, sizes):
assert len(lst) == sum(sizes)
if not sizes:
yield []
else:
for combo in combinations(lst, sizes[0]):
rest = sorted(list(set(lst) - set(combo)))
for rest_combo in grouped_combos(rest, sizes[1:]):
yield [combo] + rest_combo
def combinations(lst, size):
if len(lst) < size:
return
elif size == 0:
yield []
else:
# keep first
for combo in combinations(lst[1:], size-1):
yield [lst[0]] + combo
# skip first
for combo in combinations(lst[1:], size):
yield combo
>>> def gcomb(x, k):
... "Generate all combinations of k elements from list x."
...
... if k > len(x):
... return
... if k == 0:
... yield []
... else:
... first, rest = x[0], x[1:]
... # A combination does or doesn't contain first.
... # If it does, the remainder is a k-1 comb of rest.
... for c in gcomb(rest, k-1):
... c.insert(0, first)
... yield c
... # If it doesn't contain first, it's a k comb of rest.
... for c in gcomb(rest, k):
... yield c
My next step is to get pychecker working. Turns out it's not much code. Here are the functions:
the default string to use as the command for running pychecker
a cache of the command above and the name of the file we are
currently working with
Pretty straightforward but a couple of things to note.
I wasn't aware that the "interactive" command took straight elisp as an argument. I had just assumed you had to use the magic argument strings.
It's a little strange that they use an old school emacs lisp regular expression ("(\\([^,]+\\), line \\([0-9]+\\))") rather than the rx style they seemed to use everywhere else.
A note on pychecker. I find this utility fascinating. For good and bad reasons. It's really quite useful. C-c C-w is reflexively typed after saving a file. And the fact that it is so useful makes it extra confusing that it it seems sort of abandoned (at least last I checked).
As a future project I'd like to look at it (or one of it's cohorts, pylint, pyflakes, etc) and see how it works and perhaps complain less and help more,but it seems strangely abandoned now. I did start to take a look at one point and it seemed very complex so I ran away with my tail between my legs. But fortunately I have a short memory for scary things and I'll likely return to it someday.
Getting pychecker working required less code than I suspected.
Next I'll do skeleton support which if nothing else is a lot more lines of code.
import random
def random_select(lst, n):
for x in range(n):
yield random.choice(lst)
def insert_at(x, lst, n):
return lst[:n-1] + [x] + lst[n-1:]
def remove_at(lst, n):
return lst[:(n-1)] + lst[n:]
def rotate(lst, n):
n = n % len(lst)
x, y = lst[:n], lst[n:]
return y + x
def slice(lst, i, k):
return lst[i-1:k]
def split(lst, n):
return (lst[:n], lst[n:])
def drop(lst, n):
for i,x in enumerate(lst):
if (i+1) % n != 0:
yield x
def replicate_elements(lst, n):
for x in lst:
for y in range(n):
yield x
def duplicate_elements(lst):
for x in lst:
yield x
yield x
