Vcsn 2.4 (November 16th, 2016)


Revision as of 11:55, 11 January 2017 by Akim Demaille (talk | contribs)
(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

The Vcsn team is happy to announce the release of Vcsn 2.4, code-named "the quotient tools"!

Noteworthy changes include, besides a few bug fixes:

  • an overhaul of the "Vcsn Tools" (previously known as TAF-Kit). Because the tools are now automatically generated, they are much more extensive than previously: (almost) all of the dyn algorithms are now available from the shell. It now also supports the 'daut' format for automata.

    $ vcsn thompson -Ee '[ab]*c' | vcsn proper | vcsn determinize | vcsn minimize | vcsn to-expression
    $ vcsn random-expression -C 'lal(abc), z' '+, ., w., length=20, w="min=-2, max=10"'
  • an new method to construct an automaton from an extended expression: expression.inductive. This provides an alternative to expression.derived_term. Currently provides a single flavor: generation of standard automata.

    In [2]: vcsn.B.expression('! [ab]*a[ab]*').inductive().expression()
    Out[2]: +bb*
    In [3]: vcsn.B.expression('! [ab]*a[ab]*').automaton().expression()
    Out[3]: b*
  • full support for quotient operators on all entities: labels, expressions, automata, expansions, etc.

    In [2]: c = vcsn.context('lan, q')
       ...: c
    Out[2]: {...}? -> Q
    In [3]: label = vcsn.context('law, q').label
       ...: label('abc') / label('c')
    Out[3]: ab
    In [4]: exp = c.expression
    In [5]: exp('ab').ldivide(exp('ab*c'))
    Out[5]: ab{\}ab*c
    In [6]: e = exp('ab').ldivide(exp('ab*c'))
       ...: e
    Out[6]: ab{\}ab*c
    In [7]: e.automaton().expression()
    Out[7]: b*c

Operators {\} (left quotient) and {/} (right quotient) are available in the rational expressions:

In [8]: e = exp('ab {\} abc*')
   ...: e
Out[8]: ab{\}abc*

In [9]: e.expansion()
Out[9]: \e.[b{\}bc*]

In [10]: e.derived_term().expression()
Out[10]: c*

In [11]: e.inductive().expression()
Out[11]: \e+cc*
  • automaton.evaluate works properly on non-free automata, including multitape automata:

    In [2]: c = vcsn.context('lan(a-z), nmin')
       ...: a = (c|c).levenshtein()
       ...: a('foo|bar')
    Out[2]: 3
  • input/output support for FAdo's format for transducers, and improved compatibility with OpenFST.

For more information, please, the NEWS file.

People who worked on this release:

  • Akim Demaille
  • Clément Gillard
  • Lucien Boillod
  • Sarasvati Moutoucomarapoulé
  • Sébastien Piat
  • Younes Khoudli

People who have influenced this release:

  • Alexandre Duret-Lutz
  • Jacques Sakarovitch
  • Luca Saiu
  • Sylvain Lombardy


Available Ports

  • Docker
Run this command to pull and start the Vcsn docker image on port 8888
docker run -d -p 8888:8888 lrde/vcsn:2.4
  • Debian Jessie
Run this command
echo 'deb stable/' >/etc/apt/sources.list.d/lrde.list
apt-get update
apt-get install vcsn
# Jupyter is not currently available on Debian
apt-get install python3-pip python3-dev libzmq3-dev
pip3 install jupyter
  • Archlinux (AUR)
Run this command:
yaourt -S vcsn
  • MacPorts
Run this command:
sudo port sync && sudo port install vcsn


  • Tarballs (sources to compile):


In order to compile Vcsn 2.4, you need:

C++ compiler
Clang 3.6 or newer and GNU G++ 4.9 or newer are known to work properly.
The display of automata is made using AT&T Graphviz library. (On Ubuntu/Debian, install the following package: graphviz)
Boost (version 1.49 or later) provides free peer-reviewed portable C++ source libraries (at least the Boost.Python and Boost.Regex components, and probably others).
The Flex scanner generater, 2.5.37 or better.
Compiler cache.
To build the C++ reference manual.
Python 3 is required
Although not strictly needed, it is required if you want to enjoy the Vcsn interactive notebooks.