$Id: TODO,v 1.1.1.13 2005/01/26 13:42:19 nthiery Exp $
==============================================================================
TODO
==============================================================================
I)   Libraries to create and features to add
II)  Documentation
III) Specifications issues
IV)  Integration of muEC
V)   Bugs to fix
VI)  Cleanup
VII) Distribution/autoconf/automake

==============================================================================
I) Libraries to create and features to add
==========================================

get rid of Dom::AlgebraWithBasis_Table and experimental::AlgebraWithBasis

Use noDebug in reasonnable places

Add libraries for:
 - enumerations
 - Yamanouchi words (=> Janvier)

 - tabloids
 - set partitions:
   move permutations::fromSetPartition there ?

Add the following types:
   Type::Option (to document)
   Type::OptionsTable (to document)
   Type::Polynomial (basic implementation)
   Type::PolynomialDomain (basic implementation)
   Type::Function (already exists!)
   Type::Predicate (done)
   Type::MemberOf(x)
   Type::HasProp(property)
   Type::TableOf (done)
   Type::Intersection (done)

Add the following functions:
   polylib::variables (to document)
   polylib::constructor (to document)
   polylib::basis (can be a type or a domain)
   polylib::terms
   polylib::monomials (see sortMonomials) (to document)
   polylib::support (to document); add conversion of expressions to polynoms
   polylib::lsupport
   polylib::nthsupport
   polylib::mapterms

Move "alphabet to order" out of the words library to the root of
Combinat, a misc subpackage or an alphabet package (to be discussed).

Xavier's suggestions of algorithms with better complexity:
 - Floyd algorithm for:
   - combinat::"arrangements"::random(n,k) (ask name?  n! / (n-k)! )
 - Kemp algorithm for:
   - combinat::splitNK::generator(n, k)

Permutations:
 - descentPolynomial or descentsPolynomial or descentMonomial ?
 - arrangements, i.e. permutations of length k of a list of size n
 - minimal change ordering / hamiltonian path trough the permutoedron
   (Trotter Johnson)
 - typeDuplicateFree ?
 - subpackage fromCycleType, with count = z_\lambda (taille d'une classe de conjugaison)
   remplace partitions::conjugacyClassSize ?

Word:
 - shuffle product of several words

Partitions:
 - rename centralizerSize ?
 - toExp and fromExp is redundant with words::evaluation
   fromExp might be called fromEvaluation
   Now, is evaluation a good name, compared to, say, content ?

Weighted integer vectors:
 - Add a generator
 - Add generic constraints ? this should not arm much with the
   backtrack algorithm.
 - Make a link to combinat::decomposableObjects([T=Multiset(.....)]);

IntegerListsLexTools:
 - Add last/previous
 - Extend to work with n in a range
 - Extend to work with non-constant slopes
 - Check this reference: "Omega: written in Mathematica by Axel Riese,
   is an implementation of MacMahon's Partition Analysis for the
   computation of generating functions for the integer solutions to
   systems of linear equations and inequalities."
 - Check this reference:
   % Jean B. Lasserre
   % La valeur optimale des programmes entiers
   % Calcul de la valeur de la solution optimale d'un programme linéaire
   % en entiers w.r.t. en rationnels

Dyck words:
 - add generator using IntegerListsLexBuiding
 - rank / unrank

Partitions:
   rank / unrank

Composition:
   descents / fromDescents is ambiguous with descents/fromDescents
   of combinat::words. Rename it to set/fromSet

Integer Matrices:
   Fast count by exploring the tree / or computation in symmetric functions
   Provide standard options MinPart and MaxPart
   Make sure that there is no backtrack with MinPart and MaxPart
   fromStandardPermutation instead of fromStandard ?

Subsets:
   lexicographic generator
   graycode generator / ranking / unranking
   k-subsets:
   lexrank/unrank, colexrank/unrank, minimal change ordering
   random generation in linear time (Floyd's algorithm)
   Deduce from it a sampleFromUnrank in Cat::CombinatorialClass
   	sample(k, <size>)
   returns a sample of k distinct objects of size <size>

Set partitions:
   <-> RGF, RGF generator, RGF rank/unrank,

Linear Extensions:
   count (cf. Pouzet?), random
   Shouldn't we use < when all the vertex are in Dom::Real ?
   Implement as a dynamic module (especially for count)

Tableaux:
   There should be some kind of link so that the user can guess
   that counting semi standard tableaux can be done with kostka.
   Make kostka work also for semi-standard tableaux.
   Allow for tableaux of shape such as [0], or [3,2,0,0] ?
      Yes... See combinat::catalan.
   Type Checking: the shape of a tableau MUST be a partition.
   type and testtype are not coherent!
   content, evaluation
   vertical alignement of skew tableaux and ribbons
   Standardization of isAStandard

Trees: see http://mupad-combinat.sf.net/Wiki/Trees
   output of the empty tree?

Decomposable Objects:

   BUGS:
    - The hack to avoid deep recursion is not perfect. The first time,
      Calling count(1\0000, B) will force the computation of all the
      intermediate values, even in cases where this is not useful.

   TODO:

    - When count is not available, but generator is, use
      countFromGenerator.

    - Sandrine: give directly the description as a graph (or
      automaton), use the intersection of automatons, and do the
      decomposable stuff afterward (but how to deal with loops of
      length in a range?)

    - Put in the documentation:
      Trick to generate efficiently all objets of A of size <= n:
	Alias(Prod(A,Domain(NonNegInt)), op, 1)
      Where NonNegInt is a domain with exactly one object of each size
      Extension needed to use the groebner basis stuff.
      or just:
	Alias(Prod(A, Sequence(Z), op, 1))
    - Bolzman method? Useful for Sandrine?

    - modify addProduction / ... to specify a prefix for the
      generated non terminals, in order to have more meaningfull names
      Partial support in genident. Do the full stuff with Florent.

    - Define a politic for warnings / userinfo / errors
    - Add sanity checks, by detecting during the
      standardization those non terminals that should have valuation > 0,
      storing them in a domain variable, and double checking this in
      makeValuation. A priori, that's the right way of doing it, and
      it is safer to forbid non terminal with 0 valuation in Set,
      Cycle, Sequence.  
    - Rename operators to use names that reflect their combinatorial meaning
      Color/AddMark/Mark/EraseMark/DeleteMark/UnMark for Int Theta MultX DivX
      Diagonal/Repetition/ instead of Delta
      Backward compatibility (including with Maple) is unimportant as
      none of them is documented
      Use DivX / MultX ? Or call them as integration/derivation on exp gen functions ?
      or shift on coefficients?
      Better use names which describe their combinatorial meaning,
      to be coherent with Union, Prod, Set, MultiSet. AddLabel/RemoveLabel?
      Mark/Unmark? MarkFirst / MarkLast / UnmarkFirst?
    - provide minSize / maxSize for combinatorial classes
    - Maybe, upon request provide minCard / maxCard for set
    - Most likely set the default minLength for Cycle to 1
      Beware of backward compatibility
      Maybe, upon request, provide a way to set the default (but beware
      not to break usage of Cycles at over places in the code).
    - Order for unrank and generator for labelled structures:
       - choosing first the objects and then the labelling is faster
         by a constant time factor (which depends on the
         specification: think of permutations defined as sequences).
       - Do we need to have unrank and generator be coherent?
       - Due to the Alias feature, the reverse option is more efficient for generator
    - Use RD_INF instead of infinity for valuations ? The overhead does
      probably not justify this.
    - Use polynomials instead of tables as storage for the generating
      functions?
    - Extract a library for generating functions
    - Reinsert the lazy product
    - Check that the holonomic product is not relevant for the labelled case,
      and use instead counting functions of the unlabelled case * n!
    - The Alias feature and the generation are two orthogonal
      processes. It may be useful to allow to change the Aliases at
      run time, that is, make a table: (NonTerminal = AliasProcedure)
      which is called systematically. Note: this can be currently
      already done with parameterized Alias procedure. Drawback of the
      current method: it is not possible to add a new alias (Florent).

    - Use exponential generating functions for counting?
	Advantages:
	  - less binomial coefficients
	  - use holonomic products for the labelled case as well
        Drawbacks:
	  - more multiplications by n! in unrank/random/
          - computations with rational numbers for non
            context-free specifications
        Altogether: probably to be done at some point

      Are standard tableaux decomposable? (probably not)
      Accept empty cycles? (probably not by default)
      How to deal with Set(A) when A has empty objects?
        probably give a warning or error.
      Analysis of complexity & Benchmark of our implementation
      Unranking of subsets of a given cardinality without computing
      billions of binomial coefficients

    - Generator for labelled case: Done

      Problem: due to the maintainance of the labels, the worst case
      complexity of each iteration is n^2.

      Possible solution: instead of passing down lists of labels,
      maintain separately one list of labels (corresponding to the
      labels of the generated object, read in infix order), and just
      pass pointers to the first label, and the number of
      labels. Also, maintain, for each node for which the last
      splitting of the labels has not been reached, a permutation
      (stored as a table(15=10,10=15)) that allows to restore the list
      of labels to its state as it was just after the computation of
      the current splitting at this node level.
      - constant time iterator (not ammortized!) for the k-subsets of {1..n}

    - Subst: Example of "useful" grammar where Subst is used recursively.

    - Unlabelled case

        Conrado:

	count for Power/Multi set(A, constraints) given countA(n) (~done)
	count for Cycle(A, constraints) given countA(n)
	count for Lyndon(A, constraints) given countA(n)
	(probably using a generic algorithm that takes u(n) as in Delta)
	(or continue to use Int Theta Delta)
	(beware: Cycle and Lyndon do not use the same formula as Power/Multiset)
      - generator for unlabelled Sets / Cycles / Lyndon (Nicolas, tomorow morning)
      - unrank for unlabelled Powerset / Multiset

    - Define a combinatorial class for classes with a single element
      to implement atoms/epsilons:
      combinat::singleton(label, size, weight, ...)
    - Rewrite Predefined in terms of Domain

   Needs for Sandrine-Dominique Gouraud:
    - Big grammars, but not so big n
    - random
    - count ?
    - module dynamique ?
   ordre de grandeur 850 chemins de taille 255; grammaire de taille 65
   numbers with 20 decimals; computations in integers with gmp should be fine

     - repeatedSquaring labelled cycles via sequences
     - generatorFromRank

     - Nicolas: add support for multiple standard specifications (no urgency)
       - count : low number of constructors (use Theta instead of Set) + optimizations
       - random: low number of constructors (use Theta instead of Set) (currently broken)
       - generator: use Set
       - unrank:    same one
       That's probably mostly done; double check! 2004/09/08

     - Support for bivariate counting: (Xavier/Conrado)
       combinat::countingFunctions::(Multi)setsByNumberOfComponents(f_A, n, k):
		number of (multi)sets of A of total size n with k components
       combinat::countingFunctions::count(Multi)setsByMininumSize(f, n, m):
		number of (multi)sets of A of total size n with each component of size at least m

     - generatorFromRank(r, n, k):
       build a generator that starts at given rank

     - Implement Multiset/... in makeUnrankFunctions, unlabelled case (Xavier)
     - Suggestions: use PSet / MSet as shortcuts for Powerset Multiset

    - Extend decomposable objects to indexes in a combinatorial class
      with product (or dual coproduct) / counting over a general algebra:
	- disable valuation / degree stuff ?
	- generator for the coproduct
	  "unrank"  for the coproduct (look at the labelled case)
     - Use any combinatorial class with coproduct as grading

Dom::PermutationGroup:
 - generators ?

Domains:

IndexedMultiplicativeBasis: domain of indexed elements s[...],
   such that s[1,2]*s[4,5]=s[1,2,4,5] ?

AlgebraWithBasis:
 - conversion from a table ?
 - normalised representations (ie: canonical representation)

Algebras, Hopf algebras, ...
 - dom::mult2 take 2 elements of dom and returns an element of dom
   similarwise for dom::mult, antipod, coproduct, ...
   (partially done)
 - In last resort, dom::mult2 uses the overloading mechanism,
   and converts the result back to dom; in this is the case,
   a flag (dom::mult2UseOverloading) is set
 - Those two specifications allow for modular programing
 - Unless the flag is set, operators::mult2 is overloaded with mult2

SymmetricWeylAlgebra:

Symmetric functions:
 - See top of the source file lib/EXAMPLES/SymmetricFunctions.mu

Categories to create/modify:
 - Cat::Bialgebra ?
 - Cat::BialgebraWithBasis
 - Cat::Coalgebra
 - Cat::CoalgebraWithBasis
 - Cat::Algebra ?

 - Cat::FiniteCollection and Cat::HomogeneousFiniteCollection could inherit
   from Cat::CombinatorialClass

FreeModule:
 - Should we define:
   Cat::FreeModule(R) or Cat::FreeModule(R, BasisDomain)

   Names for:
    - straighten / straightenBasis; any need for straighten ?
      If yes, it should probably be defined in the category.
    - basisType
    - exprTerm, exprMonomial, exprBasis ?
    - printTerm, printMonomial, printBasis ?
    - multcoeffsLeft
    - operators::_plus / operators::plus ?
    - operators::_mult / operators::mult ?
    - mapCoeffs / mapCoeffsNocheck ?

   Add division by scalars

   Should we separate coeff(x,t) and coeffs(x) for efficiency ?

   Allow for Semi rings or coefficient domains with even less structure
   Allow to disable zero checks

   Allow for non commutative ring in Cat::Module

 - Try to catch the error when defining a free module on a
   CombinatorialClass without the entry domtype (done).  

   Should we continue to implement generate/generate1 ? generate is not
   really meaningfull when the internal data structure is not a sorted list.
    - Rename generate to fromList ?
    - Rename generate1 to monomial ?

    - Should degree / degreevec be in Cat::FreeModule ?
      Should they try to call BasisType::degree, or degree ?
      Don't need to use lazy_and in those procedures

    - some general mechanism to compute in a quotient modulo an ideal ?

   The current Weyl algebra over Dom::ExpressionField() also declares
   a conversion from Dom::ExpressionField(). This gives a conflict:
   W(x1)*x1 is currently resolved as multcoeffs(W(x1),x1) because
   it requires no conversions, where as W(x1)*W(x1) requires one.

 - Cat::GradedAlgebra
    - truncate, homogeneousComponents, ...

 - Cat::Module: should it enforce that:
    - the left and right multiplication coincide ?
    - the ring is commutative ?
   alternatively, we could add an axiom that states this property,
   and is set by default to yes when the ring is commutative.

 - Use capitals for local variables and parameters of domains

Utilities around symmetric functions, specht polynomials, ...

 - Allow to define an alphabet by a polynomial domain
   f: symmetric function, p: polynomial domain
   f(p): the symmetric function, represented in the polynomial domain

Conversions:
 - What conversions should we provide for facade domains that represent
   a subset of its representation domain ?
 - Should we allow two successive explicit conversions ?
   e.g.: DOM_LIST -> combinat::partitions -> Free_Module(R, combinat::partitions) ?

   Should combinat::compositions::finers inherit from combinat::compositions?
   In general, should a subset of a set inherit from it's superset ?

How should be defined tensor() and tensor(a) ?

operators::overloaded:
 - Should the overloaded functions like tensor, _mult, ... be defined in
   the library operators ?
 - Use a funcenv in operators::tensor for the pretty printing of
   unevaluated tensor products

combinat::subClass:
 - should it always be a facade domain?

Linbox:
 - Learn how to write C++ executables
 - Make a C++ executable that reads matrices "on the fly" for wiedemann
 - Cleanup SparseMatrix_Linbox
 - Check the "string memory leak" problem

Link with kbmag2?
	KBMAG stands for Knuth-Bendix on Monoids and Automatic Groups.
	http://www.maths.warwick.ac.uk/~dfh/download/kbmag2/


Weighted automatons:
 - compute the generating series, or make a link with decomposableObjects
   to do it (benchmark!)
 - constructor from a Graph?

==============================================================================
Ibis) Test suite
================

 - Systematically do the prog::check after the testexit() in the test files
 - Systematically include timing information

==============================================================================
II) Documentation
=================
 - Merge doc for adt::Stack with MuPAD's doc
 - Find a short mantra for the documentation of nops, op, ...
   tableaux, skewTableaux, trees & friends, ribbons ribbonsTableaux
 - Explanations about typed combinatorial objects:
    - Preface & design notes (Nicolas)
 - Proofreading + doc writing + status update:
    - necklaces, lyndonWords: proof reading
    - generators: Florent
    - ribbonsTableaux: proofreading (Nicolas + Francois)
    - combinat::countingFunctions (de cote)
    - decomposableObjects: proofreading (Francois)
         Mark Unmark (Nicolas)
    - output::asciiArt
      exemples dans la doc casses par Francois
    - genericTrees (Nicolas)
    - Cat::DecomposableClass (Nicolas) + une phrase dans Cat::
    - ModuleWithBasis (proofreading Florent + Nicolas)
    - ModuleWithSeveralBasis
    - Dom::AlgebraWithBasisTable
    - Dom::SparseMatrixLinBox (beta)
    - examples::SymmetricFunctions: status, usage of lrcalc/symmetrica (Nicolas)
    - prog::bless (virer la doc lorsque mupad300 sera sorti)

 - Live demonstration tour / tutorial:
   Link automatons <-> decomposable object via an appropriate language
   generic trees + large random labelled tree
 - Systematic ispell (Teresa)
 - Documentation examples:
   TODO: combinat (skewTableaux, matrices), index (demonstration, exercises)
 - Proofreading + doc writing + status update:
	lister les nouveaux packages (Teresa)
	isA, type, ... done Florent + vérifier les packages

	finiteClass		(alpha)
	getOptions		(internal)
	GLIP			(internal)
	imageClass		(alpha)
	integerVectorsModPermutationGroup	(alpha)
	MachineIntegerListsLex	(internal+François)
	nbspcols		
	rankers			(FH) ? s'il y a le temps
	subClass		(alpha) mention dans l'intro de combinat
	tools			(internal)

	Domains:
	 - Semirings			(Eric)
	 - WeightedAutomatons		(Eric)
	Categories:

	Bibliothèques:
	 - operators::makeLinear ...	(NT)

 - Remove the "HelpPage" on the first page of index.mdvi
 - Don't use rotating for the platform table in the .mdvi version
 - Put highlighted links to the different documents at the toplevel index
 - Fix all the broken html links (in particular in reference like combinat::words::evaluation
 - Use tip http://www.cs.odu.edu/~zeil/tex4ht/tex4ht_discussion.html to
   speedup gif generation with tex4ht.
 - Write a report on what has been imported from ACE / muEC.
 - Add the examples of Florent:
   combinat::permutations::generators([(i$compo[i])$ i=1..nops(compo)]);
   permet de lister tous les mots d'une évaluation donnée ce qui fait que
   combinat::generators::map
   (
    combinat::permutations::generator([(i$compo[i])$ i=1..nops(compo)]),
    combinat::permutations::standard
   );
   liste le shuffle de (Id_i1, Id_i2, ... Id_ik)
 - Fix the inputs as suggested in doc/dvi/checkinput.log
 - Improve the documentation of integerListsLex*
 - Add an index
 - Add more pictures to the documentation of partitions and tableaux,
   using tableaux.sty, or some similar LaTeX package. Or use ASCII
   drawings.
 - Write tutorials.
 - Provide missing style files ?
   hyperref.sty, booktabs.sty, beton.sty ?
   eec/*.tfm ? /usr/share/texmf/tex/latex/koma-script ?
 - With certain latex distributions, one get errors such as:
   ! TeX capacity exceeded, sorry [pool size=92864].
   Now, we provide a directory local texmf.cnf file, with pool size=150000.
   That should take care of all tetex based distributions.
 - Splitting of long documentations (like permutations) by theme:
   Option I: Use sections similar to Mathematical methods
   Option II: use the same style as export/unexport which allow
   for documenting several related functions in the same page.
   We currently use option II, but Christopher as advocated
   recently (september 2004?) to use option I, now that the
   help pages allow for creating new section types
 - Improve interface concistency checks
    - Don't test interfaces of parametrized domains (how to?)
    - Fix the others! (generators, ...)

==============================================================================
III) Specifications issues
==========================

 - nonCrossingPartitions:
   - Type: (sorted?) list of lists or set of lists ?
     (see mail discussions with Mathieu Dutour)
   Should be coherent with setPartition...
   move to setPartition::nonCrossing.

Choose proper names for:
 - combinat::*::less / before ?
 - combinat::*::convertTo
 - generators::repeater => generators::loop ?

 - combinat::words::evaluation*

 - tableau hyper standard / normalise ?
 - tabloide / tableau ?
 - combinat::tableaux::toPartition / shape
 - cartesian product or Cartesian product ?
 - toWord / word ?
 - insertLetter / insertWord

Choose proper names and protect options

 - combinat::words::alphabetType ou typeAlphabet

==============================================================================
IV) Integration of muEC
=======================

 - COMP, PART, ... are now subpackages of muEC to avoid polluting the
   global namespace.

 - Integration of the documentation: PART (with bug fixes), TYP, COMP
   (with unfixed bugs), SP, SG (with bug fixes, and unfixed bugs), SFA
   (with unfixed bugs), SYMF (with bug fixes, with unfixed bugs)

 - /MUEC/sources/modules/sources/SYM/def.h:56:9
   gcc-2.96 complains: "not" cannot be used as a macro name in C++
   This can be simply fixed by removing the #define

 - Added hold's everywhere on the indexed objects m, p, s, h, X, XX, ...
   to make the SYMF, SFA, and SP libraries less vulnerable to name
   clashes with global variables.

 - SYMF::Plete*:
   Rewrote the option testing to avoid the use of an uninitialized variable.

Demander a Vincent Prosper:
 - les fichiers de tests
 - comment il s'y prenait pour g'en'erer la documentation
 - de quelle version de Symmetrica il est parti
 - differences entre *.h dans Symmetrica-module et Symmetrica

Things that could be reused in combinat:

 - SG   -> combinat::permutations
 - PART -> combinat::partitions
 - COMP -> combinat::compositions (DONE)

Update the source code for Symmetrica from:
	http://www.mathe2.uni-bayreuth.de/axel/symneuholen_engl.html

Things to be cleaned in mu-EC:
 - Replace all _seqgen and _seqin by $:
    - Done for SFA/SfAExpn.mu. I hope I did not break anything.
    - Done at a few other places as well
 - Some functions declared in MuEC seems not to be implemented:
    - muEC::TYP::IsFs
    - muEC::SP::ToXX_heart
    - muEC::SYMF::Plethh
    - muEC::SYMF::Muir1
   Calling them now raises a "not implemented" error (see lib/MUEC/*.mu)
 - muEC::SP::Pe2x_vect uses l[-1] to access the last element of
   a list. I'd be surprised if this works.
 - Update the banner
 - Fix bugs revealed by the documentation

==============================================================================
VI) Cleanup
===========
 - standardize bla_bli blaBli bla_Bli bla::bli

==============================================================================
VII) Distribution/autoconf/automake
===================================

 - The rpm file list does not include the directories; so those are
   not deleted appropriately when the rpm is removed.
 - Rule to run the MuPAD-dev tests:
   (for file in **/*.tst; do echo $file; echo quit | mupad -S -P pe < $file; done) >! checklog 2>&1
 - Emit a warning if the MuPAD version is inappropriate for
   documentation tests
 - Get MuPAD_VERSION dynamically?
 - Check for g++ in configure
 - make update-mupad-cvs-package (and probably the others as well)
   does not remove files that have been deleted.
 - Fix the CVS repository in the distribution so that it allows for
   anonymous update
 - Prepare the survey on sourceforge
 - Add MuPAD to the programming langages on sourceforge
 - Check standard headers for all files + license header ?
 - use AC_ARG_WITH instead of AC_ARG_ENABLE for glip ?
 - installation of stuff in the MuPAD package does not respect =inst
   should it ?
 - Should MUPAD and other variables be declared as precious variables
   with AC_ARG_VAR ? This would in particular add documentation to
   ./configure --help
   cf. info autoconf, Setting Output Variables
 - Use AC_SUBST_FILE to include the makefile fragments in config/*.am ?
 - Cleanup compilation of dynamic modules:
   - .mdh's and .mdg's should be copied into linux/modules
   - Add stuff to CLEANFILES automatically
   - fix BUILT_SOURCE and mmg ?
   - Disable the call to AM_PROG_MUPAD_MMG when dynamic modules are disabled
 - add mupad.m4 and such to $(datadir)/aclocal (see info autoconf)
 - Test suite:
   - make distcheck does not take into account the result of the test suite
   - use autotest in GLIP as exercise, and generalize to MuPAD-Combinat
     if apropriate
   - Avoid running tests relying on dynamic modules when those are disabled.
     Done for IPC.
     Maybe add a lib/config.mu.in file to give access to configuration variables
     from within mupad
   - are html files cleaned up properly in doc/html ?
 - --enable-pdf-documentation sets enable-dvi-documentation, but does
   not run the corresponding tests like checking for latex
 - Remove the following directories from the CVS server:
   MAPITL/TEST (after cleanup)
   GLIP/*.test
   MuPAD-Combinat/test (after cleanup -> tests and removal of subdirs)
   doc/ascii/COMBINAT/
 - Make sure the installation procedure work with non-GNU make:
   Maybe use old-fashionned suffix rules .cc.mcc: ...
 - Add make doc-dvi / doc-pdf ? Check in the autobook if there
   are standard dependencies for the doc.
 - Cf. info autoconf, Changed Makefiles:
    Add `@CFLAGS@', `@CPPFLAGS@', and `@LDFLAGS@' in your `Makefile.in'
    files, so they can take advantage of the values of those variables
    in the environment when `configure' is run.  Doing this isn't
    necessary, but it's a convenience for users.

    Also add `@configure_input@' in a comment to each input file for
    `AC_OUTPUT', so that the output files will contain a comment
    saying they were produced by `configure'.  Automatically selecting
    the right comment syntax for all the kinds of files that people
    call `AC_OUTPUT' on became too much work.

Use the following macro for MuPAD version testing
dnl AC_TEST_VERSION(AVAILABLE-VERSION, NEEDED-VERSION [, ACTION-IF-OKAY [, ACTION-IF-NOT-OKAY]])
dnl written 15 December 1999 by Ben Gertzfield <che@debian.org>
dnl This code is released under the GNU GPL, version 2 or later.

AC_DEFUN(AC_TEST_VERSION, [

    AC_PROG_AWK
    changequote(<<, >>)dnl so [] don't get destroyed as quotes
    ac_got_version=<<`$AWK 'BEGIN {                     \
        first_ver_len = split(ARGV[1], first_ver, "\.");        \
        second_ver_len = split(ARGV[2], second_ver, "\.");      \
                                                        \
        if (first_ver_len > second_ver_len) {           \
            greater_len = first_ver_len;                \
            for (i = second_ver_len + 1; i < first_ver_len + 1; i++) { \
                second_ver[i] = 0;                      \
            }                                           \
        } else {                                        \
            greater_len = second_ver_len;               \
            if (second_ver_len > first_ver_len) {       \
                for (i = first_ver_len + 1; i < second_ver_len + 1; i++) { \
                    first_ver[i] = 0;                   \
                }                                       \
            }                                           \
        }                                               \
                                                        \
        for (i = 1; i < greater_len + 1; i++) {         \
            if (second_ver[i] > first_ver[i]) {         \
                print "failure";                        \
                exit;                                   \
            }                                           \
        }                                               \
        print "success"; }' $1 $2`>>
    changequote([, ])dnl now [] are quotes once again
    if test $ac_got_version = "success"; then
        ifelse([$3], , :, $3)
    else
        ifelse([$4], , :, $4)
    fi
])

- Automatize building of package on the sf compile farm
  ppc-osx2, ...

 - Windows installation:
   Install wizard builder: Inno Setup 3.0x jrsoftware.org
   Visual C++
   Vmware
