You can subscribe to this list here.
2003 
_{Jan}

_{Feb}

_{Mar}

_{Apr}
(5) 
_{May}

_{Jun}

_{Jul}

_{Aug}
(2) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}


2004 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}
(1) 
_{Jun}

_{Jul}
(5) 
_{Aug}

_{Sep}

_{Oct}

_{Nov}
(7) 
_{Dec}
(7) 
2005 
_{Jan}
(2) 
_{Feb}

_{Mar}
(2) 
_{Apr}

_{May}
(3) 
_{Jun}

_{Jul}
(7) 
_{Aug}

_{Sep}
(1) 
_{Oct}
(4) 
_{Nov}

_{Dec}
(4) 
2006 
_{Jan}

_{Feb}
(2) 
_{Mar}
(1) 
_{Apr}
(1) 
_{May}
(1) 
_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}
(1) 
_{Dec}

2007 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}
(5) 
_{Oct}

_{Nov}

_{Dec}

2008 
_{Jan}

_{Feb}
(2) 
_{Mar}

_{Apr}
(1) 
_{May}

_{Jun}
(4) 
_{Jul}

_{Aug}

_{Sep}
(1) 
_{Oct}

_{Nov}
(5) 
_{Dec}

2009 
_{Jan}
(2) 
_{Feb}
(1) 
_{Mar}

_{Apr}

_{May}
(1) 
_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

2010 
_{Jan}

_{Feb}
(1) 
_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}

_{Sep}

_{Oct}

_{Nov}

_{Dec}

2014 
_{Jan}

_{Feb}

_{Mar}

_{Apr}

_{May}

_{Jun}

_{Jul}

_{Aug}
(1) 
_{Sep}

_{Oct}

_{Nov}

_{Dec}

S  M  T  W  T  F  S 







1

2

3

4

5
(1) 
6
(1) 
7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31






From: Nicolas M. Thiery <nthiery@us...>  20050106 17:05:07

Dear Sandrine, dear MuPADCombinat users, I have just implemented primitive objects of arbitrary size in combinat::decomposableObjects. An Atom is now just a primitive object of size 1, while an Epsilon is a primitive object of size 0. In principle, this does not add any expressiveness to decomposableObjects. Indeed, Primitive(3, A) is equivalent to Sequence(Atom, Length=3). However, this allowed for some code factorization, and using Primitive(3,A) is *much* more efficient than using the Sequence above. As an example, here is the combinatorial class of complete binary trees whose leaves are of size 1, and internal nodes of size 3: bla := combinat::decomposableObjects( [Tree = Union(Leave, Prod(Node, Tree, Tree)) Leave = Primitive(1, Leave) Node = Primitive(3, Node)]); >> bla::count(i) $ i=0..10; 0, 1, 0, 0, 0, 1, 0, 0, 0, 2, 0 >> print(i, bla::list(i)) $ i=0..9; 0, [] 1, [Leave] 2, [] 3, [] 4, [] 5, [Prod(Node, Leave, Leave)] 6, [] 7, [] 8, [] 9, [Prod(Node, Leave, Prod(Node, Leave, Leave)), Prod(Node, Prod(Node, Leave, Leave), Leave)] bla::algebraicEquation(); 2 3 A z  A + 1 As usual: all of this is brand new. So while the test passes, some things might break. Cheers, Nicolas  Nicolas M. Thiéry "Isil" <nthiery@...> http://www.lapcs.univlyon1.fr/~nthiery/ 
From: Nicolas M. Thiery <nthiery@us...>  20050105 16:51:37

Dear Patrick, I just realized that the following piece of information could be useful to you: you can describe the combinatorial class of the paths in a graph using a grammar, in order to use the mechanics of combinat::decomposableObjects. Sorry not to have though about this earlier ... For example, take the graph: C > D ^ ^   A > B Then, the following combinatorial class describe all the paths ending at D: >> paths := combinat::decomposableObjects([ DD = Epsilon(), // paths from D to D BD = Prod(Atom(BD), DD), // paths from B to D CD = Prod(Atom(CD), DD), // paths from C to D AD = Union(Prod(Atom(AB), BD), // paths from A to D Prod(Atom(AC), CD))]): // The number of paths between D and D, by length: >> paths::count(i, DD) $ i = 0..4; 1, 0, 0, 0, 0 // The number of paths between B and D, by length: >> paths::count(i, BD) $ i = 0..4; 0, 1, 0, 0, 0 // The number of paths between A and D, by length: >> paths::count(i, AD) $ i = 0..4; 0, 0, 2, 0, 0 // The paths between A and D, by length: >> paths::list(i, AD) $ i = 0..4; [], [], [Prod(AB, Prod(BD)), Prod(AC, Prod(CD))], [], [] Many improvements are possible. Here, I used Alias to produce more readable paths: >> paths := combinat::decomposableObjects([ DD = Epsilon([]), BD = Alias( Prod(Atom([BD]), DD), _concat @ op), CD = Alias( Prod(Atom([CD]), DD), _concat @ op), AD = Alias(Union(Prod(Atom([AB]), BD), Prod(Atom([AC]), CD)),_concat @ op)]): >> paths::list(i, AD) $ i = 0..4; [], [], [[AB, BD], [AC, CD]], [], [] Of course, the grammar can be automatically generated, and using the same technique, it would be possible to describe all paths between any two pair of points. The graph does not need to be acyclic either. Many variations are possible, to obtain things like all paths of length at most n, to count paths using certain arcs, and so on. Feel free to call me for more details. Cheers, Nicolas  Nicolas M. Thiéry "Isil" <nthiery@...> http://www.lapcs.univlyon1.fr/~nthiery/ 