## mupad-combinat-users — MuPAD Combinat -- Users mailing list

You can subscribe to this list here.

 2003 2004 2005 2006 2007 2008 2009 2010 2014 Jan Feb Mar Apr (5) May Jun Jul Aug (2) Sep Oct Nov Dec Jan Feb Mar Apr May (1) Jun Jul (5) Aug Sep Oct Nov (7) Dec (7) Jan (2) Feb Mar (2) Apr May (3) Jun Jul (7) Aug Sep (1) Oct (4) Nov Dec (4) Jan Feb (2) Mar (1) Apr (1) May (1) Jun Jul Aug Sep Oct Nov (1) Dec Jan Feb Mar Apr May Jun Jul Aug Sep (5) Oct Nov Dec Jan Feb (2) Mar Apr (1) May Jun (4) Jul Aug Sep (1) Oct Nov (5) Dec Jan (2) Feb (1) Mar Apr May (1) Jun Jul Aug Sep Oct Nov Dec Jan Feb (1) Mar Apr May Jun Jul Aug Sep Oct Nov Dec 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

6

7

8

9

10

11

12

13

14

15
(1)
16

17
(1)
18

19

20

21
(2)
22

23

24

25

26

27

28

29
(1)
30
(2)

Showing 7 results of 7

 Re: [Mupad-combinat-users] decomposableObjects and Alias From: Nicolas M. Thiery - 2004-11-30 13:29:00 ```> I just do the upgrade (to be sure). Now, it works. :) Good news. > ballsAndBars := > combinat::decomposableObjects( > [ > Ball = Atom("o"), > Bar = Epsilon("I"), > Toto = Union(Ball,Bar), > BB = Union(Toto, > Alias(Prod(Ball, BB),op), > Alias(Prod(Union(Bar,Ball), Bar, BB),op) > ), > BallsAndBars = Alias(BB, _concat) > ], MainNonTerminal = BallsAndBars);; > > > ballsAndBars::count(i) \$ i = 1..100;; > ballsAndBars::count(1);; This grammar is improper: there is an infinite number of objects of size 0, typically: Prod(Bar, Bar, Prod(Bar, Bar, Prod(Bar, Bar, ...))) In particular, the recursion formula for counting is *really* recursive :-), and MuPAD goes into an infinite loop. I don't know yet how to catch this, so as to emit a meaningful error message. In the meantime, and if you think this can be helpful to the user, I can add a line in the documentation telling, that most of the time, a MAXDEPTH error during the counting diagnoses an improper grammar. > If I master the Alias "function", I think I will introduce it in the > AuGuSTe tool and my future tool(s)... As usual, some benchmarks > will be done.... Great! Cheers, Nicolas -- Nicolas M. Thiéry "Isil" http://www.lapcs.univ-lyon1.fr/~nthiery/ ```
 Re: [Mupad-combinat-users] decomposableObjects and Alias From: Nicolas M. Thiery - 2004-11-30 11:47:04 ``` Hi Sandrine! > I would like to undestand why this specification doesn't compile. Can > anybody help me? > > This example is extracted from the manual (it is the example 6) > > ballsAndBars := > combinat::decomposableObjects( > [ > Ball = Atom("o"), > Bar = Epsilon("I"), > > Toto = Union(Ball,Bar), // I would like to add this line > > BB = Union(Toto, // And replace, Bar by Toto > > Alias(Prod(Ball, BB),op), > Alias(Prod(Ball, Bar, BB),op) > ), > BallsAndBars = Alias(BB, _concat) > ], MainNonTerminal = BallsAndBars);; Err, this works for me. Can you send us a complete copy of your faulty session? What version of MuPAD-Combinat do you use? You might need to upgrade to a relatively recent version (say the current stable 1.2.0). > Another question: in the memory point of view, is this construction > costly? Because I think to use it to avoid my lexical analysis > which consists to remove all the Prod, etc. of the generated > structures to obtain only sequences of atoms. You mean the use of Alias? No, I don't think so, on the contrary. For counting, we use a simplified grammar, and the simplification includes discarding all aliases. For the random generation, you obviously have the overhead of the call to the function given in the Alias. In that case, it might be not completely negligible since, at the end of the day, you will be concatenating together relatively long sequences. From the memory point of view the expressions that you get will be relatively smaller, so I guess you can only win in that process. Well, that is for random generation inside MuPAD. With the C-programs that are generated, you won't have the "concatenation effect", because the objects are printed out on the fly, without ever being stored in memory. So, that should be a win-win. However, that's just my 2 minutes theory; only a real benchmark can tell us the truth. All the best, Nicolas -- Nicolas M. Thiéry "Isil" http://www.lapcs.univ-lyon1.fr/~nthiery/ ```
 [Mupad-combinat-users] decomposableObjects and Alias From: Sandrine-Dominique Gouraud - 2004-11-29 15:23:15 ```Hi, I would like to undestand why this specification doesn't compile. Can anybody help me? This example is extracted from the manual (it is the example 6) ballsAndBars := combinat::decomposableObjects( [ Ball = Atom("o"), Bar = Epsilon("I"), Toto = Union(Ball,Bar), // I would like to add this line BB = Union(Toto, // And replace, Bar by Toto Alias(Prod(Ball, BB),op), Alias(Prod(Ball, Bar, BB),op) ), BallsAndBars = Alias(BB, _concat) ], MainNonTerminal = BallsAndBars);; Thanks for your help. Another question: in the memory point of view, is this construction costed? Because I think to use it to avoid my lexical analysis which consists to remove all the Prod, etc. of the generated structures to obtain only sequences of atoms. SD ```
 Re: [Mupad-combinat-users] Re: Information From: Abbad Houda - 2004-11-21 11:50:04 ```Salut Nicolas ! Merci pour tes r=E9ponses, Bonne fin de week end, Bien amicalement, Houda. HOUDA ABBAD ------------------------ Evolutionary Engineering & Distributed Information Systems Laboratory, EEDIS Laboratory, ------------------------------- Department of Computer Science, Djillali Liabes University of Sidi Bel Abbes Algeria. ------------------------------ E-mail : Houda.Abbad@... -------------------------------------------- --=20 _______________________________________________ Find what you are looking for with the Lycos Yellow Pages http://r.lycos.com/r/yp_emailfooter/http://yellowpages.lycos.com/default.as= p?SRC=3Dlycos10 ```
 [Mupad-combinat-users] Re: Information From: Nicolas M. Thiery - 2004-11-21 10:04:07 ``` Salut Houda! > 1- Rendre possible l'appel d'un même domaine sans argument ou avec > un seul agrument selon les désirs de l'utilisateur. Sachant que > l'initialisation et les méthodes de ce domaine sont les mêmes dans > les deux cas. You may for example give a default value to the argument: domain bla(R=Dom::Rational) begin end: bla(): bla(Dom::Integer) Or do like in a usual procedure: domain bla(R) begin if args(0)=1 then // un argument ... else ... end_if; end: Note however that you can't define a domain where both following construction would work: bla bla(...) if bla takes parameters, then bla alone remains a domain constructor. > 2- Rendre possible l'appel d'une même méthode avec deux types > d'arguments Ex : arg1=(entier,liste,matrice,table,matrice) ou > arg2=(entier,liste,ensemble,ensemble,ensemble), sachant que cette > fois ci, le corps de la méthode diffère selon l'argument transmis. In the MuPAD language, there is no automatic overloading mechanism for methods, or in general for procedures (like e.g. in C++). On the other hand, you may use operators::overloaded to achieve what you want: >> domain bla f := operators::overloaded("f", table( [Dom::Integer, Dom::Integer] = ((x,y) -> x+y), [DOM_STRING, DOM_STRING] = ((x,y) -> x.y))): end_domain: >> bla::f(1,1) ; 2 >> bla::f("bla", "bla") ; "blabla" See the doc of operators::overloaded for details. Good luck! All the best, Nicolas -- Nicolas M. Thiéry "Isil" http://www.lapcs.univ-lyon1.fr/~nthiery/ ```
 Re: [Mupad-combinat-users] Decomposition of symmetry groups? From: Nicolas M. Thiery - 2004-11-17 08:48:36 ``` Dear Hans, > Feature request: Let G be a permutation group, that is a subgroup of > some S_n. Compute the left and right cosets of G w.r.t. S_n. For the moment, there is no systematic and well designed and documented support for groups and in particular permutation groups in MuPAD. Still some features that were required for other computations are already implemented, and this includes what you ask for, though you had little chances to find it yourself. Here is how: The dihedral group D_4, as a permutation group: >> G:=Dom::PermutationGroup(4,[[2,3,4,1], [4,3,2,1]]): >> G::size() ; 8 G acts on integer vectors of length 4 by permutation of the entries. Now, you can build the combinatorial class of integer vectors modulo the action of G: >> C := combinat::integerVectorsModPermutationGroup(G): The function C::list returns canonical representatives of all integer vectors of a given sum or given content. The representatives are the maximal elements in each orbit for the lexicographic order. So, if you give the content [1,2,3,4], it returns a complete set of representatives for the right cosets of G in Sym: >> C::list([1,2,3,4]) ; [[4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]] To get representatives for the left cosets, I guess you can just take the inverses of the representatives of the right cosets. Note that if you want to take coset representatives when G is a Young subgroup of S_n, the function combinat::permutations::modYoungSubgroup is much faster. Caveats: - You need to have MuPAD 3.1.0, or the separate package MuPAD-Combinat (mupad-combinat.sf.net) installed. - The pure MuPAD implementation is really just a stupid and slow fallback. - The package MuPAD-Combinat comes with a C++ dynamic module called GLIP, which is used automatically when available. The algorithms in GLIP are far from optimal, but can deal smoothly with small permutation groups (say |G|<10000, n<20). The problem is that GLIP does not use a good internal representation for permutation group (Shreier-Simms chain; sorry I was soooo ignorant at that time); it just generate all the elements of the group. But then, it builds the representatives of each orbit in a not-so-stupid way. I hope that helps! Nicolas Design suggestions are very welcome. For example, what syntax would have felt natural for you to ask this question? However, to get serious support for groups in MuPAD, the right way is most likely to build an interface with GAP. This has been in my projects since November 2000, but I never got the manpower to work on it. Any help, comments, suggestions are very welcome. -- Nicolas M. Thiéry "Isil" http://www.lapcs.univ-lyon1.fr/~nthiery/ ```
 [Mupad-combinat-users] Decomposition of symmetry groups? From: Christopher Creutzig - 2004-11-15 10:13:55 ```Salvete, I'm afraid I never learned the proper English words for this algebraic operation: In bug report #1533, a user asks how to decompose the symmetry group S6 into right (or left) classes, under the subject "coset-function". In case this was legible: Does anyone know how to do this with MuPAD-Combinat? If you wish to contact the user directly, his address is hans.schmidt@... -- +--+ +--+| |+-|+ Christopher Creutzig (ccr@...) +--+ Tel.: 05251-60-5525 ```

Showing 7 results of 7