Often the same programming pattern will be used with a number of different
procedures. To express such patterns as concepts, we will need to construct
procedures that can accept procedures as arguments or return procedures as
values. Procedures that manipulate procedures are called high-order
procedures, they can serve as powerful abstraction mechanisms, vastly
increaseing the expressive power of our language.

Lambda

Using lambda to create anonymous functions:

(define (plus4 x) (+ x 4)) is equivalent to(define plus4 (lambda (x) (+ x 4)))

Using lambda(let) to create local variables

Sometimes we can use internal definitions to get the same effect as with let.

And in which cases we couldn't get the same effect?

Abstractions and first-class procedures

As programmers, we should be alert to oppotunities to identify the underlying
abstractions in our programs and to build upon then and generalize them to
create more powerful abstractions. This is not to say one should always write
programs in the most abstract way possible; expert programmers know how to
choose the level of abstraction appropriate to their task. But it's important
to be able to think in terms of these abstractions, so that we can be ready
to apply them in new contexts.

Exercises

1.29
Answer:

This is not very hard, just simply translate the simpson rule definition to code:

(define (simpson-rulefabn); still use 'define' since we haven't learned 'let' till now(define h(/ (- ba)n)); the procedure to compute 'yk', the helper method used by 'term'(define (yk)(f(+ a(* kh)))); get the 'next and 'term for the sum procedure(define (nextk)(+ k1))(define (termk)(* (cond ((or (= k1)(= kn))1)((even? k)2)((odd? k)4))(yk)))(/ (* h(sumterm0nextn))3))(define (sumtermanextb)(if (> ab)0(+ (terma)(sumterm(nexta)nextb))))(define (integralfabdx)(define (add-dxx)(+ xdx))(* (sumf(+ a(/ dx2.0))add-dxb)dx))(define (cubex)(* xxx))(simpson-rulecube01100.0)(simpson-rulecube011000.0)(integralcube010.01)(integralcube010.001);; the output:; 0.24999998999999987; 0.24999999999900027; 0.24998750000000042; 0.249999875000001

1.30
Answer:

Put both the recursive and iterative versions here to compare:

(define (producttermanextb)(if (> ab)1(* (terma)(productterm(nexta)nextb))))(define (product-itertermanextb)(define (itercurresult)(if (> curb)result(iter(nextcur)(* (termcur)result))))(itera1))(define (factorialn)(define (identityx)x)(productidentity1incn))(define (incx)(+ x1))(product(lambda (x)x)1(lambda (x)(+ x1))6)(product-iter(lambda (x)x)1(lambda (x)(+ x1))6)(factorial6)(factorial10)(product(lambda (x)(* xx))1(lambda (x)(+ x1))5)(product-iter(lambda (x)(* xx))1(lambda (x)(+ x1))5);; compute the approximations to PI using the formula:;; PI 2*4*4*6*6*8...;; -- = --------------;; 4 3*3*5*5*7*7...;; here, term is (2n/(2n + 1) * 2(n+1) /(2n + 1)), n = 1, 2, 3, ...(/(product-iter(lambda (n)(* (* 2n)(* 2(+ n1.0))))1inc50)(product-iter(lambda (n)(* (+ (* 2n)1.0)(+ (* 2n)1.0)))1inc50))

There might be better ways to translate the formula. The solution above the
is not veru accurate and if the upper bound is too large (say 100), it will
yield to 'nan+'.

1.32
Answer:

1234567891011121314151617181920212223242526

(define (accumulatecombinernull-valuetermanextb)(if (> ab)null-value(combiner(terma)(accumulatecombinernull-valueterm(nexta)nextb))))(define (accumulate-itercombinernull-valuetermanextb)(define (itercurresult)(if (> curb)result(iter(nextcur)(combiner(termcur)result))))(iteranull-value))(define (sumtermanextb); (accumulate + 0 term a next b))(accumulate-iter+0termanextb))(define (producttermanextb); (accumulate * 1 term a next b))(accumulate-iter*1termanextb))(sum(lambda (x)x)1(lambda (x)(+ x1))6)(product(lambda (x)x)1(lambda (x)(+ x1))6)(sum(lambda (x)(* xx))1(lambda (x)(+ x1))5)(product(lambda (x)(* xx))1(lambda (x)(+ x1))5)

(define (filtered-accumulatecombinernull-valuetermanextbfilter)(if (> ab)null-value(if (filtera)(combiner(terma)(filtered-accumulatecombinernull-valueterm(nexta)nextbfilter))(filtered-accumulatecombinernull-valueterm(nexta)nextbfilter))))(define (prime?n)(= n(smallest-divisorn)))(define (smallest-divisorn)(find-divisorn2))(define (find-divisorntest-divisor)(cond ((> (squaretest-divisor)n)n)((divides?test-divisorn)test-divisor)(else (find-divisorn(+ test-divisor1)))))(define (squarex)(* xx))(define (divides?ab)(= (remainder ba)0))(define (incx)(+ x1))(define (identityx)x); return a procedure Integer -> Boolean; that check if the given integer is relative prime with n(define (relative-prime?n)(define (fa)(= (gcd na)1))f)(define (gcd ab)(if (= b0)a(gcd b(remainder ab))))(filtered-accumulate+0square2inc10prime?)(filtered-accumulate*1identity1inc10(relative-prime?10))

1.34
Answer:

Apply (f f) with get (f 2), while tring to apply (f 2), error will be issued
since a procedure is expected but an integer parameter 2 is given.

1.35
Answer:

12345678910111213141516171819

(define tolerance0.00001)(define (fixed-pointffirst-guess)(define (close-enoughxy)(< (abs (- xy))tolerance))(define (tryguess)(let ((next(fguess)))(if (close-enoughnextguess)next(trynext))))(tryfirst-guess)); since the golden-ratio x satisfies that x^2 = x + 1(define (golden-ratio)(fixed-point(lambda (x)(+ 1(/ 1x)))1.0))(golden-ratio)

(define tolerance0.00001)(define (fixed-pointffirst-guess)(define (close-enoughxy)(< (abs (- xy))tolerance))(define (tryguess)(display "current guess is: ")(display guess)(newline)(let ((next(fguess)))(if (close-enoughnextguess)next(trynext))))(tryfirst-guess)); without average damping(fixed-point(lambda (x)(/ (log 1000)(log x)))2.0); output below:; current guess is: 2.0; current guess is: 9.965784284662087; current guess is: 3.004472209841214; current guess is: 6.279195757507157; current guess is: 3.759850702401539; current guess is: 5.215843784925895; current guess is: 4.182207192401397; current guess is: 4.8277650983445906; current guess is: 4.387593384662677; current guess is: 4.671250085763899; current guess is: 4.481403616895052; current guess is: 4.6053657460929; current guess is: 4.5230849678718865; current guess is: 4.577114682047341; current guess is: 4.541382480151454; current guess is: 4.564903245230833; current guess is: 4.549372679303342; current guess is: 4.559606491913287; current guess is: 4.552853875788271; current guess is: 4.557305529748263; current guess is: 4.554369064436181; current guess is: 4.556305311532999; current guess is: 4.555028263573554; current guess is: 4.555870396702851; current guess is: 4.555315001192079; current guess is: 4.5556812635433275; current guess is: 4.555439715736846; current guess is: 4.555599009998291; current guess is: 4.555493957531389; current guess is: 4.555563237292884; current guess is: 4.555517548417651; current guess is: 4.555547679306398; current guess is: 4.555527808516254; current guess is: 4.555540912917957; 4.555532270803653; with average damping(fixed-point(lambda (x)(/ (+ x(/ (log 1000)(log x)))2))2.0); output below:; current guess is: 2.0; current guess is: 5.9828921423310435; current guess is: 4.922168721308343; current guess is: 4.628224318195455; current guess is: 4.568346513136242; current guess is: 4.5577305909237005; current guess is: 4.555909809045131; current guess is: 4.555599411610624; current guess is: 4.5555465521473675; 4.555537551999825

; k-term finite continued fraction(define (cont-fracndk)(define (fraci)(if (= ik)(/ (ni)(di))(/ (ni)(+ (di)(frac(+ i1))))))(frac1))(define (cont-frac-iterndk)(define (iteriresult)(if (= i0)result(iter(- i1)(/ (ni)(+ (di)result)))))(iterk0)); k = 10 produce 0.6179775280898876(cont-frac(lambda (i)1.0)(lambda (i)1.0)10)(cont-frac-iter(lambda (i)1.0)(lambda (i)1.0)10); k = 11 produce 0.6180555555555556(cont-frac(lambda (i)1.0)(lambda (i)1.0)11)(cont-frac-iter(lambda (i)1.0)(lambda (i)1.0)11); TODO: implement a procedure to retry different k until the first; one that produce the value accurate to 4 decimal.

(define (average-dampf)(define (averageab)(/ (+ ab)2))(lambda (x)(averagex(fx))))(define (squarex)(* xx))(define tolerance0.00001)(define (fixed-pointffirst-guess)(define (close-enoughxy)(< (abs (- xy))tolerance))(define (tryguess)(let ((next(fguess)))(if (close-enoughnextguess)next(trynext))))(tryfirst-guess));; re-write the square-root procedure(define (sqrt x)(fixed-point(average-damp(lambda (y)(/ xy)))1.0));; cube root, similar with above(define (cube-rootx)(fixed-point(average-damp(lambda (y)(/ x(squarey))))1.0))(define dx0.00001)(define (derivg)(lambda (x)(/ (- (g(+ xdx))(gx))dx)))(define (cubex)(* xxx))(define (newton-transformg)(lambda (x)(- x(/ (gx)((derivg)x)))))(define (newton-methodgguess)(fixed-point(newton-transformg)guess))(define (cubicabc)(lambda (x)(+ (* xxx)(* a(squarex))(* bx)c))); zero of x^3 + x^2 + x + 1; should be -1(newton-method(cubic111)1.0)

1.41
Answer:

1234567891011121314

;; Note: it's a little confusing at first, 'double' is not apply the function;; 'f' and double the result, it's 'DOUBLE' the application of the function;; 'f'.(define (doublef)(lambda (x)(f(fx))))(define (incx)(+ x1))((doubleinc)1)(((doubledouble)inc)1); this will get 21(((double(doubledouble))inc)5)

The substitution model of a recursive process reveals a shape of expansion
followed by constraction. The expansion occurs as the process builds up a
chain of defered operations. The contraction occurs as the operations are
actually performed.

Iterative process

An iterative process is one whose state can be summarized by a fixed number
of state variables, together with a fixed rule that describes how the state
variables should be updated as the process moves from state to state and an
(optional) end test that specifies the conditions under which the process
should terminate.

In the iterative case, the program variables provide a complete description
of the state of the process at any point, while in the recursive case, there
is some additional "hidden" information, maintained by the interpreter and not
contained in the program variables.

In contrasting iteration and recursion, we must be careful not to confuse
the notion of a recursive process with the notion of a recursive procedure.
When we describe a procedure as recursive, we are referring to the
syntactic fact that the procedure definition refers (either directly or
indirectly) to the procedure itself. But when we describe a process as
following a pattern that is, say, linearly recursive, we are speaking about
how the process evolves, not about the syntax of how a procedure is written.
It may seem disturbing that we refer to a recursive procedure as generating
an iterative process.

Lame's Theorem

If Euclid's Algorithm requires k steps to compute the GCD of some pair,
then the smaller number in the pair must be greater than or equal to the
kth Fibonacci number.

Fermat's Little Theorem

If n is a prime number and a is any positive integer less than n, then a
raised to the nth power is congruent to a modulo n.

Exercises

1.9
Answer: The first process is recursive and the second one is iterative.

1.10
Answer: from the definition of (A x y), we have:

(A 1 10) = A(0 (A 1 9)) = 2 * (A 1 9) = ... = 2^9 * (A 1 1) = 2^10

(A 2 4) = 65536

(A 3 3) = 65536

(f n) computes 2n

(g n) computes 2^n

(h n) computes 2^2^2... (n times)

1.11
Answer: This is similar with the example of computing Fibonacci number.

; both row and col indexes start at 0(define (pascal-trianglerowcol)(cond ((= col0)1)((= rowcol)1)(else (+ (pascal-triangle(- row1)(- col1))(pascal-triangle(- row1)col)))))

1.15
Answer:

a. from the the procedure definition, suppose p will be called t times,
we have:

a / (3^t) <= 0.1, which leads to:

log(10a) <= t, so t = ceiling (log(10a)) = 5, (the base of the log is 3)

b. both the space and number of steps depend on how many times p is called,
so it's O(t) = O(log(a)).

; use the matrix multiplication to represent the transformation; 0 1; (fib(n-1), fib(n)) * = (fib(n), fib(n-1) + fib(n)) = (fib(n), fib(n+1)); 1 1; a <- a + b; b <- a; the state transformation above is just a special case of the below one when; p = 0 and q = 1; a <- bq + aq + ap; b <- bp + aq(define (fibn)(fib-iter1001n))(define (fib-iterabpqcount)(cond ((= count0)b)((even? count)(fib-iterab(+ (squarep)(squareq))(+ (squareq)(* pq2))(/ count2)))(else (fib-iter(+ (* bq)(* aq)(* ap))(+ (* bp)(* aq))pq(- count1)))))(define (squarex)(* xx))

1.21

12345678

; the following expressions produce; 199; 1999; 7(smallest-divisor199)(smallest-divisor1999)(smallest-divisor19999)

1.25
Answer:

Since Scheme has built-in support for arbitrary precision arithmetic, the
procedure will produce the same result as the original expmod, however,
it will be very inefficient since the huge number arithmetic will take much
longer time than the numbers can be represented by a single computer word.

The original expmod used the successive squaring, the numbers to be processed
will never be larger than m^2.

1.26
Answer:

With the calling of square, the original problem can be reduced to a sub
problem with half of the size at each of the step when even? test is true.
So T(n) = T(n/2) = O(logn)

However, if the explicit multiplication used instead, the recursive call
of expmod will be evaluated twice, it not only just compute the sub
problems two time, it is actually a tree recursion like the first solution
for computing fibnacci sequence, so the number of expmod calls grow
exponentially, which conclues that T(n) = O(2^n * logn) = O(n)

(define (miller-rabin-testn)(define (try-ita)(= (expmod-with-signala(- n1)n)1))(try-it(+ 2(random(- n2)))))(define (expmod-with-signalbaseexpm)(cond ((= exp0)1)((even? exp)(square-with-signal(expmod-with-signalbase(/ exp2)m)m))(else(remainder (* base(expmod-with-signalbase(- exp1)m))m))))(define (square-with-signalan)(if (and (not (= a1))(not (= a(- n1)))(= (remainder (* aa)n)1))0(remainder (* aa)n)))(miller-rabin-test561)(miller-rabin-test1105)(miller-rabin-test1729)(miller-rabin-test2465)(miller-rabin-test2821)(miller-rabin-test6601); these will all give #f with quite a chance, but with enough runs, it will; have some false positive(newline)(miller-rabin-test7)(miller-rabin-test23)(miller-rabin-test103)(miller-rabin-test1009)(miller-rabin-test1019)(miller-rabin-test1000033); these will always all give #t

Computational processes are abstract beings that inhabit computers. As they
evolve, processes manipulate other abstract things called data. The evolution
of a process is directed by pattern of rules called a program.

Why use Lisp for the book?

The most significant unique feature of Lisp is the fact that Lisp descriptions
of processes, called procedures, can themselves be represented and manipulated
as Lisp data. The importance of this is that there are powerful program-design
techniques that rely on the ability to blur the traditional distinction between
"passive" data and "active" processes.

The three mechanisms of combining simple ideas to form more complex ideas in any
powerful programming languages:

primitive expressions

means of combination

means of abstraction

Substitution model

Applicative order

Evaluate the operator and operands first and then applies the resulting procedure
to the resulting arguments. "Fully expand and then reduce"

Normal order

Don't evaluate the operands until their values are needed, instead, substitute
operand expressions for parameters until it obtained an expression involving only
primitive operators, and would then perform the evaluation. "Evaluate the
arguments and then apply"

Example: Square Roots by Newton's Method

The contrast between function and procedure is a reflection of the general
distinction between describing properties of things and describing how to
do things, or, as it is sometimes refered to, the distinction between
declarative knowledge and imperative knowledge. In mathematics we are
usually concerned with declarative (what is) descriptions, whereas in
computer science we are usually concerned with imperative (how to)
descriptions.

Exercises

1.3 Define a procedure that takes three numbers as arguments and return the
sum of squares of the two larger numbers.

1.4 Observe that our model of evaluation allows for combinations whose
operators are compound expressions. Use this observation to describe the
behavior of the following procedure:

12

(define (a-plus-abs-bab)((if (> b0)+-)ab))

if b is greater than 0, the operator that will apply to a and b is +, or else
it will be -, so the a-plus-abs-b will always result in a plus abs of b.

1.5
Answer: the interpreter that uses applicative order evaluation will hang due
to the infinite recursive call of 'p', while an interpreter that uses normal
order evaluation will get 0.

Note:p is a function, (p) is a call to function p.

1.6
Answer: the interpreter will hang due to the infinite recursive call to
sqrt-iter. Since List uses applicative order evaluation, in the definition
of new-if, the else-clause will always be evaluated no matter the result of
the predicate, thus lead to infinite recursive call to sqrt-iter. That's why
if needs to be a special form, the predicate expression is evaluated first,
and the result determines whether to evaluate the consequent or the alternative
expression.

1.7
Answer: For small values, the absolute tolerance 0.001 is too large, so the
results become inaccurate. For example, (sqrt 0.001) gives 0.04124542607499115
on my machine. (ubuntu 12.10 x86_64); And for large values, due to the precision
limitation of float-point representation, the guess couldn't be refined to a
value that can be represented within the tolerance. In such cases, the program
can endlessly alternate between two guesses that are more than 0.001 away from
the true square root.

so, instead of using absolute tolerance, we changed to use the relative
tolerance of two continuous guess values. This can be demonstrated with the
below updated good-enough? procedure:

Here comes the summary of the Coursera course
Fucntional Programming Principles in Scala
It's a little bit late, it has been two months since I finished the course.
This is the first Coursera course I followed from the very beginning to the end
and accomplished all the programming assignments with full scores, which helped
me to get the certificate with distinction.

First the excellent parts of the course:

Martin Odersky is a pretty good teacher, and all the lectures are well
designed. I enjoyed watching the lectures a lot and most of which I have
read more than once.

The programming assignments are well structured, with detailed instructions
and step by step guide. In each of the assignments, the whole task is split
into several steps with approprivate level of abstractions.

There are also many useful supporting materials like scala style guide, sbt
tutorial, instructions on tools setup for the course, which made it easier
to concentrate on the course content. For me, I don't have scala develop
environment setup before the course, and by following the tools setup section
in only took me less than half an hour to get everything ready for trying the
example code and the assignments.

As for the less-good things, I would say:

Both the lectures and the assignments are quite easy for an experienced
programmers (No functional programming background needed), I was expecting
more challenging stuff.

There are no official solutions distributed. (The course will be offered
again some time later) However, I still think for those students who passed
the course should be qualified to get the solutions so that they can compare
those with their own to see where they can still improve.

It's a pity that this is only the first half of an advanced undergraduate
course that Martin taught on campus. I am interested in the other half.

After taking this cousre, I got a deeper understanding of the functional
programming basics and it made me feel more comfortable while picking up
SICP again (after 3 years). Now, I am convinced that I am able to go through
SICP and finish most of the exercises. Also, I had a firmer grasp of Scala
even though I didn't write more than 100 lines of Scala before; I understand
more about the scala syntax, idioms and even the motivations behind some of the
language structures. E.g., call by name/value, lazy evaluation, currying,
pattern matching and so on. I will publish my detailed notes on the lectures
and assignments to this blog later.

To conclude, I really enjoyed taking the course and many thanks to Martin
, the TAs, and also the coursera staff for offering such a wonderful course.

This module provides the infrastructure for defining
abstract base classes
(ABCs) in Python. The ABCs define a minimal set of methods that establish the
characteristic behavior of the type. For more details about this, see
PEP 3119.

Highlights

The module provides a metaclass
used to create ABCs. An ABC can be subclassed directly. The class also has a 'register'
method to register unrelated concrete classes (including built-in classes) and unrelated
ABCs as 'virtual subclasses'

Also there are two decorators abstractmethod and abstractproperty, which will set
the function object's attribute '__isabstractmethod__' to True. Only when all of the
abstract methods and abstract properties are overriden, can a class that has a metaclass
derived from ABCMeta be instantiated.

Code comments

ABCMeta.__new__

123456789101112131415161718192021

def__new__(mcls,name,bases,namespace):cls=super(ABCMeta,mcls).__new__(mcls,name,bases,namespace)# Compute set of abstract method namesabstracts=set(nameforname,valueinnamespace.items()ifgetattr(value,"__isabstractmethod__",False))forbaseinbases:fornameingetattr(base,"__abstractmethods__",set()):value=getattr(cls,name,None)ifgetattr(value,"__isabstractmethod__",False):abstracts.add(name)cls.__abstractmethods__=frozenset(abstracts)# chaoc: caches are the typical usages of weak references# Set up inheritance registrycls._abc_registry=WeakSet()cls._abc_cache=WeakSet()cls._abc_negative_cache=WeakSet()cls._abc_negative_cache_version=ABCMeta._abc_invalidation_counterreturncls

It first creates a 'type' object cls. (super(ABCMeta, mcls) is 'type')

Iterate through all the attributes (including all the attributes inherited
from all the bases), if any of them have '__isabstractmethod__' set to true,
add it to cls's __abstractmethods__.

Initialize the attributes '_abc_registry', '_abc_cache', '_abc_negative_cache'
and '_abc_negative_cache_version', which are used to speed up the check in
__instancecheck__ and __subclasscheck__.

ABCMeta.register(cls, subclass)

See the added comments in line

12345678910111213141516

defregister(cls,subclass):"""Register a virtual subclass of an ABC."""# chaoc: sanity check to make sure that subclass is class type# either a type object (for new style classes) or the type is# the same as ClassType(for old style classes)ifnotisinstance(subclass,(type,types.ClassType)):raiseTypeError("Can only register classes")ifissubclass(subclass,cls):return# Already a subclass# Subtle: test for cycles *after* testing for "already a subclass";# this means we allow X.register(X) and interpret it as a no-op.ifissubclass(cls,subclass):# This would create a cycle, which is bad for the algorithm belowraiseRuntimeError("Refusing to create an inheritance cycle")cls._abc_registry.add(subclass)ABCMeta._abc_invalidation_counter+=1# Invalidate negative cache

ABCMeta.__instancecheck__

See the added comments in line

12345678910111213141516171819202122

def__instancecheck__(cls,instance):"""Override for isinstance(instance, cls)."""# Inline the cache checking when it's simple.subclass=getattr(instance,'__class__',None)ifsubclassisnotNoneandsubclassincls._abc_cache:returnTruesubtype=type(instance)# Old-style instancesifsubtypeis_InstanceType:subtype=subclass# chaoc: subtype will also be subclass for old style classes# as assigned in the above stepifsubtypeissubclassorsubclassisNone:# chaoc: check if the negative cache is safe to use or notif(cls._abc_negative_cache_version==ABCMeta._abc_invalidation_counterandsubtypeincls._abc_negative_cache):returnFalse# Fall back to the subclass check.returncls.__subclasscheck__(subtype)return(cls.__subclasscheck__(subclass)orcls.__subclasscheck__(subtype))

ABCMeta.__subclasscheck__

The code and comment in this function is very clear and straightforward.

Just make sure the different cases needed to check:

check the subclass hook

check if it's a direct subclass through __mro__

check if it's a subclass of a registered class (issubclass is called to do
recursive check)

check if it's a subclass of a subclass (issubclass is called to do recursive
check)

In this post, we only talk about the defitions of ABCMeta. We will see the
typical usages in the collections module.

This module provides support for maintaining a list in sorted order without
having to sort the list after each insertion. It uses a basic bisection
algorithm similar with the classic binary search.

Review of binary search

According to 'Programming Pearls'
by Jon Bentley, It's very hard to write a correct binary search(Unbelievable, Uh?).
Below is the note from the book:

I've assigned [binary search] in courses at Bell Labs and IBM.
Professional programmers had a couple of hours to convert [its] description
into a program in the language of their choice; a high-level pseudocode
was fine. At the end of the speci?ed time, almost all the programmers
reported that they had correct code for the task. We would then take thirty
minutes to examine their code, which the programmers did with test cases.
In several classes and with over a hundred programmers, the results varied
little: ninety percent of the programmers found bugs in their programs (and
I wasn't always convinced of the correctness of the code in which no bugs were
found). I was amazed: given ample time, only about ten percent of professional
programmers were able to get this small program right. But they aren't the only
ones to ?nd this task difficult: in the history in Section 6.2.1 of his
'Sorting and Searching', Knuth points out that while the first binary search
was published in 1946, the first published binary search without bugs did not
appear until 1962.

Understanding how to use loop invariants in composing a program is very important,
so let's first implement a binary search and prove the correctness utilizing this.
Here we use a simplified specification compared to the bsearch function in the C
standard library.

1234567891011121314151617181920212223242526

intbinsearch(intx,int*A,intn)// @require 0 <= n && n <= length(A)// @require is_sorted(A, n)/* @ensures (-1 == result && !is_in(x, A, n)) || ((0 <= result && result < n) && A[result] == x)*/{intlower=0,higher=n;intmid;while(lower<higher)// @loop_invariant 0 <= lower && lower <= higher && higher <= n// @loop_invariant (lower == 0 || A[lower - 1] < x)// @loop_invariant (higher == n || A[higher] > x){mid=lower+(higher-lower)/2;// @assert lower <= mid && mid < higherif(A[mid]==x)returnmid;elseif(A[mid]<x)lower=mid+1;elsehigher=mid;}return-1;}

It's easy to prove that the loop invariants are strong enough to imple the
postcodition of the function(@ensures). Does this function terminate? In the
loop body, we have lower < higher, so lower <= mid && mid < higher, then the
intervals from lower to mid and from (mid+1) to higher are strictly
smaller than the original interval (lower, higher), unless we find the element,
the difference between higher and lower will eventually become 0 and we will
exit the loop.

The bisect() functions provided in this module are useful for finding the
insertion points but can be tricky or awkward to use for common searching
tasks.

Code comments

The above binsearch function will return the first of the elements that equals
to the target if there are more than one. Sometimes it's required to find the
left most one or the right most one. We can achieve this by using the bisect()
functions. Let's examine the pre and post conditions, and also loop invariants.

12345678910111213141516171819

defbisect_right(a,x,lo=0,hi=None):# Let l be the original lo passed in, and h be hi. In order to differentiate.# @requires 0 <= l && l < h && h <= len(a)# @requires is_sorted(a[l:h])# @ensures all e in a[l:result] have e <= x, and all e in a[result:h] have e > xwhilelo<hi:# @loop_invariant l <= lo && lo <= hi && hi <= h# @loop_invariant lo == l || a[lo - 1] <= x# @loop_invariant hi == h || a[hi] > xmid=(lo+hi)//2# @assert lower <= mid && mid < higherifx<a[mid]:hi=midelse:lo=mid+1returnlo

After exiting the loop, we have lo == hi. Now we have to distinguish some cases:

If lo == l, from the third conjunct, we know that a[hi] > x, and since lo == hi,
we have a[lo] > x. In this case, all e in a[l:h] > x

If hi == h, from the second conjunct, we know that a[lo - 1] < x, in this case,
all e in a[l:h] <= x

if lo != l and hi != h, from the second and third conjuncts, we know that
a[lo - 1] <= x, a[hi] > x. The post condition still holds.

We can do the same analysis on the function bisect_left().

Note: In the pre condition I explicitly written down that lo < hi is required, the
code will directly return lo when hi is less than or equal to lo, but that's simply
meaningless, if this is the case, the sorted order of 'a' after we insert element
before the index returned by the function.

About the function prototype

In the doc of the module, it's bisect.bisect_right(a, x, lo=0, hi=len(a))
while in the source code, it's def bisect_left(a, x, lo=0, hi=None)

bisect.bisect_right(a, x, lo=0, hi=len(a)) is not valid python code, you will
get error like this: NameError: name 'a' is not defined. This is because default
values are computed and bound at the function definition time rather than when you
call the function. This means that you can't have a default which is dependent on
something that is not known until the function is called.

Pythonic stuff

Override function definitions in Python

12345

# Overwrite above definitions with a fast C implementationtry:from_bisectimport*exceptImportError:pass

It took me some time to finally get latex math formulas working in Octopress.
If you googled ‘Octopress latex’, you can get quite a few online resources about
how to support latex in octopress, with various levels of complexity. In this
post, I will write down how I achieve this.

The initial attempt

As I installed the jekyll-rst plugin
to use rst to write my posts, I thought it should be easy to write latex math
because docutils has native support for it since version 0.8 (A :math: role and
also a .. math: directive introduced for that). However, after I tried to use
these in a octopress post, I found that the post will be rendered to empty. For
example, if I insert the following rst code into my post, the whole post becomes
empty; but after removing this line, everything is fine.

1

The area of a circle is :math:`A_\text{c} = (\pi/4) d^2`.

I also verified that the exact same code can be successfully converted to valid
html using the ‘rst2html.py’ script on my system, so I guess maybe something is
wrong in ‘RbST’. I found that in RbST, it has its own copies of rst2html and
rst2latex tools under /gems/RbST-0.1.3/lib/rst2parts ,

1234

chuchao@chuchao:~/.rvm/gems/ruby-1.9.2-p320/gems/RbST-0.1.3/lib/rst2parts$ ls
__init__.py rst2html.py rst2latex.py transform.py transform.pycchuchao@chuchao:~/.rvm/gems/ruby-1.9.2-p320/gems/RbST-0.1.3/lib/rst2parts$ ls ..
rbst.rb rst2parts

which will be used in rbst.rb. I have even tried to change rbst.rb to use the
rst2html.py installed on my system, but this also didn’t get any luck.

The module provides an implementation of heap queue algorithm, also known as
priority queue algorithm.

Highlights

Zero-based indexing is used, so the children's index of node with index k
are (2*k + 1) and (2*k + 2) respectively.

Internally a 'min heap' is maintained rather than 'max heap', which is more
generally used in algorithm textbooks.

Three general functions based on heaps are also provided:

12345678910

# Merge multiple sorted inputs into a single sorted output# (for example, merge timestamped entries from multiple log files)heapq.merge(*iterables)# The following two functions are effectively like# sorted(iterable, key=key, reverse=True)[:n] and# sorted(iterable, key=key)[:n],# but they perform best with smaller values of nheapq.nlargest(n,iterable[,key])heapq.nsmallest(n,iterable[,key]))

Pythonic stuff

Rich comparison methods

123

defcmp_lt(x,y):# use __lt__ if available; otherwise, try __le__returnx<yifhasattr(x,'__lt__')else(noty<=x)

In python, there are 6 so called "Rich Comparison" methods, x < y calls
x.__lt__(y) and others are similar (__le__ and <=; __gt__ and >=; __eq__ and ==;
__ne__ and <>). Arguments to rich comparison methods are never coerced. see
coercion

Code comments

Why heapify(x) is O(n)?

This is not obvious at first by seeing the code, given that there is a 'while'
loop in _siftup and also a while loop in _siftdown(called in _siftup). Let's
look into it further:

in the while loop of _siftup, it takes O(L) time for nodes that L levels
above leaves.

and in the while loop of _siftdown called in _siftup, it takes at most L
steps, so _siftdown is O(L).

since we have n/4 nodes in level 1, n/8 nodes in level 2, and finally one
root node, which is lg(n) levels above leaf, so the total amount in the while
loop of heapify is:

n/4 * c + n/8 * c + n/16 * 3c + ... + 1 * lg(n) * c, and let n/4 = 2^k,
after simplification, we get:

c * 2^k(1/2^0 + 2/2^1 + 3/2^2 + ... + (k+1)/2^k), as the limit of
(k+1)/2^k is 0 when k is infinite, so the term in the brackets bound to
a constant, from this we can conclude that heapify is O(2^k), which is O(n).

Why it continues to find the smaller child until a leaf is hit in _siftup?

As explained in the comment by the module author, this is a ad hoc to reduce
the comparisons on the following operations on the heap.

I am going to start the series of posts on reading the source of python standard
modules. I will go with the pure python modules first, and maybe later I can
continue with C implementations of the modules. Let's see how far I could go.

What will be included

A brief introduction of the module. (It should be very short, people can go to
the standard library doc for more information.)

Special highlights about the important APIs, implementation details.

Python features/idioms/tricks/gotchas that worth the whistle, especially those
I was not familiar with

Detail explanations about the tricky part of the code if any

What will not be included

The example usage of the various APIs, for this kind of stuff,
Python module of the week is a better
place to go

Also, alone the way, I may start another series on some specific 'advanced topics'
in python, like descriptor, decorator, method resolution order(mro)
and so on. Mainly about why they are introduced into python, how they are used and
the typical use cases. This is inspired by the blogs about
python history