I just did a graph of the Evolution of the Overall Doctest Coverage of Sage since 3 years. The png is below.

The coverage evolved quiet regularly during the last 20 releases (=20 months) with an average of a bit less than 5 percent a year. For sage-4.6.2, it is actually 84.8%. If we keep this rhythm, we should reach 90% coverage by March 2012 and 100% by April 2014.

The code I used is here : coverage_evolution.py.

The factor 212212112112212112122112112212212112112212112122112112 occurs in the Kolakoski word at the positions 3190, 6366, 7614, 12950, 13765, 14277, 20385, 21344, 39674 and so on. The successive gaps of these first eight occurences are 3176, 1248, 5336, 815, 512, 6108, 959, 18330. Are the gap between all of these occurences bounded or not? The following table lists only the gap that are going increasingly for the Kolakoski word up to 100 billion (=10^9).

The following image draws all the gaps in function of i for the first 10 million digit.

I am currently at Sage Days 28. Right now, there is a discussion about Analytic combinatorics in Sage and the new code written by Alex Raichev at tikcet #10519 was mentionned in the discussion. His code is a bunch of def python functions in a sage file. In Sage, code is written in object oriented way.

I am not an expert of the domain of analytic combinatorics, but I am coding oriented object Python since some time now. So I wrote a comment on the ticket gathering my thoughts to, I hope, help Alex to rewrite his set of functions into an oriented object structure. I copied the content of my comment below as it will be easier to share it.

r"""
[...]

This code relates to analytic combinatorics.
More specifically, it is a collection of functions designed
to compute asymptotics of Maclaurin coefficients of certain classes of
multivariate generating functions.

The main function asymptotics() returns the first `N` terms of
the asymptotic expansion of the Maclaurin coefficients `F_{n\alpha}`
of the multivariate meromorphic function `F=G/H` as `n\to\infty`.
It assumes that `F` is holomorphic in a neighborhood of the origin,
that `H` is a polynomial, and that asymptotics in the direction of
`\alpha` (a tuple of positive integers) are controlled by smooth
or multiple points.

[...]
"""

class HolomorphicMultivariateMeromorphicFunction(object):

    # Constructor of the object
    def __init__(self, F, G):
        #stores important information on the object as attributes of self
        self._F = F
        self._G = G

    def maclaurin_coefficients(self, n, alpha):
        r"""
        Return the maclaurin coefficients of self.

        INPUT:

        - ``alpha`` - tuple of positive integers

        OUTPUT:

        a python list of the first terms

        OR

        maybe an object of a class you implement if there exists pertinent
        questions to ask to it.
        """
        #Do some computations based (I guess) on self._F and self._G
        intermediate_result1 = self.some_intermediate_computations_1()
        #Do more computations
        return something

    def asymptotics(self, N, alpha):
        r"""
        Returns the asymptotics of Maclaurin coefficients.
        """
        #Do some computations based (I guess) on self._F and self._G
        intermediate_result2 = self.some_intermediate_computations_2()
        intermediate_result3 = self.some_intermediate_computations_3()
        return something

    #put here all the others functions needed to compute the asymptotics
    def some_intermediate_computations_1(self):
        pass
    def some_intermediate_computations_2(self):
        pass
    def some_intermediate_computations_3(self):
        pass

    ...

At Sage Days 28 held this week in Orsay, France, I gave a talk on How to contribute to Sage.

• How to contribute to Sage

The talk goes into the details because we wanted people to contribute during the talk. Tickets created during the talk are here :

• Sage Days 28 trac tickets

The purpose of this text also available on the Sage wiki is to explain how to share your branch of Sage development. I am sure there more than one way to do so, but the solution shown here is the same as the way Sage Combinat shares its development.

First, clone the sage-main. Below, I use my sage trac username to name that branch, because it's my branch of Sage development:

sage -b main
sage -clone slabbe

Go to the directory associated to that new branch and initialize the Queue for Mercurial. See Sage Development Manual : Mercurial queues for more details.

cd SAGE_HOME/devel/sage-slabbe
hg qinit

This last step created a new directory (SAGE_HOME/devel/sage-slabbe/.hg/patches) where your patches will be saved. In order to share your branch, you simply need to share this directory. For example, you can copy its content to a public directory on your web site. You can also use svn, git or any other revision control system. As I want to work on my branch the exact same way as I am working on the sage-combinat branch, I choose to use hg.

Now I log on the server that will host my patches, I create the (public) patches directory and I initialize that directory as an hg directory:

ssh username@server.com
mkdir patches
cd patches
hg init

I also add a hook to that public repository so that it updates itself automatically when a push is made to it. In other words, I edit the file ~/patches/.hg/hgrc so that it becomes:

#file ~/patches/.hg/hgrc
[hooks]
changegroup = hg update

I then logout from the server and go to the patches directory on my machine and make a clone of the public patches repository created above. I could use the http adress, but I use the ssh one so that I can push to the server later on:

cd SAGE_HOME/devel/sage-slabbe/.hg/patches
hg clone ssh://username@server.com:~/patches .

Like for the Sage-combinat repository, I create in .hg/patches a file called .hgignore containing the following:

# file .hgignore
syntax: glob
status
guards

Then, add, commit and push this first change to the server:

hg add .hgignore
hg commit -m "Added the .hgignore file"
hg push

I can now create patches on my branch like in sage-combinat:

cd SAGE_HOME/devel/sage-slabbe/
hg qnew trac_XXXX-fixing-stuff.patch
vim sage/combinat/partition.py
hg qrefresh -e

I can push my changes to my public server like in sage-combinat:

cd SAGE_HOME/devel/sage-slabbe/.hg/patches
hg st
hg commit
hg push

For the first time, you may need to add the series file as well:

cd SAGE_HOME/devel/sage-slabbe/.hg/patches
hg add series
hg commit
hg push

Last thing, notice that the sage-combinat script can be used to install your branch on any Sage installation with the following one liner:

sage -combinat install -b slabbe -s http://server.com/path/to/your/username/patches/

In my case, the result is here