Update website for PatternClass 2.4.2

PackageInfo.g

@@ -10,8 +10,8 @@ SetPackageInfo( rec(
 
 PackageName := "PatternClass",
 Subtitle := "A permutation pattern class package",
-Version := "2.4.1",
-Date := "28/09/2017", # dd/mm/yyyy format
+Version := "2.4.2",
+Date := "24/07/2018", # dd/mm/yyyy format
 
 Persons := [
   rec(
@@ -75,7 +75,6 @@ SourceRepository := rec(
     URL := Concatenation( "https://github.com/gap-packages/", ~.PackageName ),
 ),
 IssueTrackerURL := Concatenation( ~.SourceRepository.URL, "/issues" ),
-#SupportEmail   := "TODO",
 PackageWWWHome  := "https://gap-packages.github.io/PatternClass/",
 PackageInfoURL  := Concatenation( ~.PackageWWWHome, "PackageInfo.g" ),
 README_URL      := Concatenation( ~.PackageWWWHome, "README.md" ),

README.md

@@ -14,7 +14,7 @@ patched functions are located in lib/automata.* .
 Introduction
 ------------
 
-This is version 2.4 of the 'PatternClass' package.
+This is version 2.4.2 of the 'PatternClass' package.
 
 The 'PatternClass' package allows you to explore the permutation
 pattern classes build by token passing networks.
@@ -54,12 +54,12 @@ If you get 'PatternClass' as a compressed file unpack it in the pkg/ folder
 in the gap4r4 folder where GAP is installed on your computer.
 To uncompress the .tar.gz file on UNIX use the following command
 
-   tar xzf PatternClass2.4.tar.gz
+   tar xzf PatternClass2.4.2.tar.gz
 
 If your version of tar does not support the z option use
 
-   gunzip PatternClass2.4.tar.gz
-   tar xf PatternClass2.4.tar
+   gunzip PatternClass2.4.2.tar.gz
+   tar xf PatternClass2.4.2.tar
 
 This will create the folder PatternClass in pkg/ and within that
 you will find the directories and files mentioned above.
@@ -72,11 +72,11 @@ Loading  Automata 1.13
 For help, type: ?Automata:
 ----------------------------------------------------------------
 ─────────────────────────────────────────────────────────────────────────────
-Loading  PatternClass 2.4 (A permutation pattern class package)
-by Ruth Hoffmann (TODO),
+Loading  PatternClass 2.4.2 (A permutation pattern class package)
+by Ruth Hoffmann (https://rh347.host.cs.st-andrews.ac.uk/),
    Steve Linton (http://sal.host.cs.st-andrews.ac.uk/), and
    Michael Albert (http://www.cs.otago.ac.nz/staff/michael.html).
-Homepage: https://RuthHoffmann.github.io/PatternClass/
+Homepage: https://gap-packages.github.io/PatternClass/
 ─────────────────────────────────────────────────────────────────────────────
 true
 gap>
@@ -89,6 +89,11 @@ online or within GAP help.
 
 Changes
 -------
+Changes from 2.4 to 2.4.2:
+- Changed the name of HashSet due to clash with DataStructure Package
+- Removed TODOs from code
+<<<>>><<<>>><<<>>><<<>>>
+
 Changes from 2.3 to 2.4:
 - Improved the runtime of InbetweenPermSet when the subpermutation is of length 1.
 - Added IsSumPerm function

_data/package.yml

@@ -1,6 +1,6 @@
 name: PatternClass
-version: 2.4.1
-date: 2017-09-28
+version: 2.4.2
+date: 2018-07-24
 description: |
     A permutation pattern class package
 
@@ -32,7 +32,7 @@ packageinfo: https://gap-packages.github.io/PatternClass/PackageInfo.g
 
 downloads:
     - name: .tar.gz
-      url: https://github.com/gap-packages/PatternClass/releases/download/v2.4.1/PatternClass-2.4.1.tar.gz
+      url: https://github.com/gap-packages/PatternClass/releases/download/v2.4.2/PatternClass-2.4.2.tar.gz
 
 abstract: |
     The PatternClass package is build on the idea of token passing networks building permutation pattern classes. Those classes are best determined by their basis. Both sets can be encoded by rank encoding their permutations. Each, the class and its basis, in their encoded form build a rational language. Rational languages can be easily computed by using automata, which also can be build directly from the token passing networks. Both ways will build the same language, i.e. the same automaton.

doc/chap0.html

@@ -44,8 +44,8 @@ <h2>A permutation pattern class package</h2>
 
   </b>
 <br />Email: <span class="URL"><a href="mailto:[email protected]">[email protected]</a></span>
-<br />Homepage: <span class="URL"><a href="TODO">TODO</a></span>
-<br />Address: <br />TODO<br />
+<br />Homepage: <span class="URL"><a href="https://rh347.host.cs.st-andrews.ac.uk/">https://rh347.host.cs.st-andrews.ac.uk/</a></span>
+<br />Address: <br />Ruth Hoffmann<br /> School of Computer Science,<br /> University of St. Andrews,<br /> North Haugh,<br /> St. Andrews,<br /> Fife,<br /> KY16 9SS,<br /> SCOTLAND<br />
 </p><p><b>
     Steve Linton
 

doc/chap0.txt

@@ -22,8 +22,15 @@
 
   Ruth Hoffmann
       Email:    mailto:[email protected]
-      Homepage: TODO
-      Address:  TODO
+      Homepage: https://rh347.host.cs.st-andrews.ac.uk/
+      Address:  Ruth Hoffmann
+                School of Computer Science,
+                University of St. Andrews,
+                North Haugh,
+                St. Andrews,
+                Fife,
+                KY16 9SS,
+                SCOTLAND
 
 
   Steve Linton

doc/chap0_mj.html

@@ -6,7 +6,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
 <head>
 <script type="text/javascript"
-  src="http://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
+  src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
 </script>
 <title>GAP (PatternClass) - Contents</title>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
@@ -47,8 +47,8 @@ <h2>A permutation pattern class package</h2>
 
   </b>
 <br />Email: <span class="URL"><a href="mailto:[email protected]">[email protected]</a></span>
-<br />Homepage: <span class="URL"><a href="TODO">TODO</a></span>
-<br />Address: <br />TODO<br />
+<br />Homepage: <span class="URL"><a href="https://rh347.host.cs.st-andrews.ac.uk/">https://rh347.host.cs.st-andrews.ac.uk/</a></span>
+<br />Address: <br />Ruth Hoffmann<br /> School of Computer Science,<br /> University of St. Andrews,<br /> North Haugh,<br /> St. Andrews,<br /> Fife,<br /> KY16 9SS,<br /> SCOTLAND<br />
 </p><p><b>
     Steve Linton
 

doc/chap1.html

@@ -26,13 +26,13 @@
 
 <h3>1 <span class="Heading">Introduction</span></h3>
 
-<p>Token passing networks (TPNs) are directed graphs with nodes that can hold at most one token. Also each graph has a designated input node, which generates an ordered sequence of numbered tokens and a designated output node that collects the tokens in the order they arrive at it. The input node has no incoming edges, whereas the output node has no outgoing edges. A token <span class="SimpleMath">t</span> travels through the graph, from node to node, if there is an edge connecting the nodes, if the node the token is moving from is either the input node and the tokens <span class="SimpleMath">1, ..., t-1</span> have been released or the node is not the output node, and lastly if the destination node contains no token or it is the output node. <a href="chapBib.html#biBPermGenTPGraph">[3]</a></p>
+<p>Token passing networks (TPNs) are directed graphs with nodes that can hold at most one token. Also each graph has a designated input node, which generates an ordered sequence of numbered tokens and a designated output node that collects the tokens in the order they arrive at it. The input node has no incoming edges, whereas the output node has no outgoing edges. A token <span class="SimpleMath">t</span> travels through the graph, from node to node, if there is an edge connecting the nodes, if the node the token is moving from is either the input node and the tokens <span class="SimpleMath">1, ..., t-1</span> have been released or the node is not the output node, and lastly if the destination node contains no token or it is the output node. <a href="chapBib.html#biBPermGenTPGraph">[ALTd.]</a></p>
 
-<p>The set of permutations resulting from a TPN is closed under the property of containment. A permutation <span class="SimpleMath">a</span> contains a permutation <span class="SimpleMath">b</span> of shorter length if in <span class="SimpleMath">a</span> there is a subsequence that is isomorphic to <span class="SimpleMath">b</span>. This class of permutations can be represented by its anti-chain, which in this context is called the basis. <a href="chapBib.html#biBRegCloSetPerms">[2]</a></p>
+<p>The set of permutations resulting from a TPN is closed under the property of containment. A permutation <span class="SimpleMath">a</span> contains a permutation <span class="SimpleMath">b</span> of shorter length if in <span class="SimpleMath">a</span> there is a subsequence that is isomorphic to <span class="SimpleMath">b</span>. This class of permutations can be represented by its anti-chain, which in this context is called the basis. <a href="chapBib.html#biBRegCloSetPerms">[AAR03]</a></p>
 
-<p>To enhance the computability of permutation pattern classes, each permutation can be encoded, using the so called rank encoding. For a permutation <span class="SimpleMath">p_1 ... p_n</span>, it is the sequence <span class="SimpleMath">e_1... e_n</span> where <span class="SimpleMath">e_i</span> is the rank of <span class="SimpleMath">p_i</span> among <span class="SimpleMath">{p_i,p_i+1,...,p_n}</span>. It can be shown that the sets of encoded permutations of the class and the basis, both are a rational languages. Rational languages can be represented by automata. <a href="chapBib.html#biBRegCloSetPerms">[2]</a></p>
+<p>To enhance the computability of permutation pattern classes, each permutation can be encoded, using the so called rank encoding. For a permutation <span class="SimpleMath">p_1 ... p_n</span>, it is the sequence <span class="SimpleMath">e_1... e_n</span> where <span class="SimpleMath">e_i</span> is the rank of <span class="SimpleMath">p_i</span> among <span class="SimpleMath">{p_i,p_i+1,...,p_n}</span>. It can be shown that the sets of encoded permutations of the class and the basis, both are a rational languages. Rational languages can be represented by automata. <a href="chapBib.html#biBRegCloSetPerms">[AAR03]</a></p>
 
-<p>There is another approach to get from TPNs to their corresponding automata. Namely building equivalence classes from TPNs using the different dispositions of tokens within them. These equivalence classes of dispositions and the rank encoding of the permutations allow to build the same rational language as from the process above. <a href="chapBib.html#biBPermGenTPGraph">[3]</a></p>
+<p>There is another approach to get from TPNs to their corresponding automata. Namely building equivalence classes from TPNs using the different dispositions of tokens within them. These equivalence classes of dispositions and the rank encoding of the permutations allow to build the same rational language as from the process above. <a href="chapBib.html#biBPermGenTPGraph">[ALTd.]</a></p>
 
 
 <div class="chlinkprevnextbot">&nbsp;<a href="chap0.html">[Top of Book]</a>&nbsp;  <a href="chap0.html#contents">[Contents]</a>&nbsp;  &nbsp;<a href="chap0.html">[Previous Chapter]</a>&nbsp;  &nbsp;<a href="chap2.html">[Next Chapter]</a>&nbsp;  </div>

doc/chap1.txt

@@ -10,24 +10,24 @@
   connecting  the  nodes,  if  the node the token is moving from is either the
   input  node and the tokens 1, ..., t-1 have been released or the node is not
   the  output node, and lastly if the destination node contains no token or it
-  is the output node. [3]
+  is the output node. [ALTd.]
 
   The set of permutations resulting from a TPN is closed under the property of
   containment.  A  permutation a contains a permutation b of shorter length if
   in  a  there  is  a  subsequence  that  is  isomorphic  to  b. This class of
   permutations  can be represented by its anti-chain, which in this context is
-  called the basis. [2]
+  called the basis. [AAR03]
 
   To   enhance   the   computability  of  permutation  pattern  classes,  each
   permutation  can  be  encoded,  using  the  so  called  rank encoding. For a
   permutation p_1 ... p_n, it is the sequence e_1... e_n where e_i is the rank
   of  p_i  among {p_i,p_i+1,...,p_n}. It can be shown that the sets of encoded
   permutations  of  the  class  and  the basis, both are a rational languages.
-  Rational languages can be represented by automata. [2]
+  Rational languages can be represented by automata. [AAR03]
 
   There  is another approach to get from TPNs to their corresponding automata.
   Namely   building   equivalence   classes  from  TPNs  using  the  different
   dispositions   of   tokens   within   them.  These  equivalence  classes  of
   dispositions  and  the  rank encoding of the permutations allow to build the
-  same rational language as from the process above. [3]
+  same rational language as from the process above. [ALTd.]
 

doc/chap10_mj.html

@@ -6,7 +6,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
 <head>
 <script type="text/javascript"
-  src="http://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
+  src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
 </script>
 <title>GAP (PatternClass) - Chapter 10:  Miscellaneous functions </title>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8" />

doc/chap1_mj.html

@@ -6,7 +6,7 @@
 <html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
 <head>
 <script type="text/javascript"
-  src="http://cdnjs.cloudflare.com/ajax/libs/mathjax/2.7.0/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
+  src="http://cdn.mathjax.org/mathjax/latest/MathJax.js?config=TeX-AMS-MML_HTMLorMML">
 </script>
 <title>GAP (PatternClass) - Chapter 1: Introduction</title>
 <meta http-equiv="content-type" content="text/html; charset=UTF-8" />
@@ -29,13 +29,13 @@
 
 <h3>1 <span class="Heading">Introduction</span></h3>
 
-<p>Token passing networks (TPNs) are directed graphs with nodes that can hold at most one token. Also each graph has a designated input node, which generates an ordered sequence of numbered tokens and a designated output node that collects the tokens in the order they arrive at it. The input node has no incoming edges, whereas the output node has no outgoing edges. A token <span class="SimpleMath">\(t\)</span> travels through the graph, from node to node, if there is an edge connecting the nodes, if the node the token is moving from is either the input node and the tokens <span class="SimpleMath">\(1, \ldots, t-1\)</span> have been released or the node is not the output node, and lastly if the destination node contains no token or it is the output node. <a href="chapBib_mj.html#biBPermGenTPGraph">[3]</a></p>
+<p>Token passing networks (TPNs) are directed graphs with nodes that can hold at most one token. Also each graph has a designated input node, which generates an ordered sequence of numbered tokens and a designated output node that collects the tokens in the order they arrive at it. The input node has no incoming edges, whereas the output node has no outgoing edges. A token <span class="SimpleMath">\(t\)</span> travels through the graph, from node to node, if there is an edge connecting the nodes, if the node the token is moving from is either the input node and the tokens <span class="SimpleMath">\(1, \ldots, t-1\)</span> have been released or the node is not the output node, and lastly if the destination node contains no token or it is the output node. <a href="chapBib_mj.html#biBPermGenTPGraph">[ALTd.]</a></p>
 
-<p>The set of permutations resulting from a TPN is closed under the property of containment. A permutation <span class="SimpleMath">\(a\)</span> contains a permutation <span class="SimpleMath">\(b\)</span> of shorter length if in <span class="SimpleMath">\(a\)</span> there is a subsequence that is isomorphic to <span class="SimpleMath">\(b\)</span>. This class of permutations can be represented by its anti-chain, which in this context is called the basis. <a href="chapBib_mj.html#biBRegCloSetPerms">[2]</a></p>
+<p>The set of permutations resulting from a TPN is closed under the property of containment. A permutation <span class="SimpleMath">\(a\)</span> contains a permutation <span class="SimpleMath">\(b\)</span> of shorter length if in <span class="SimpleMath">\(a\)</span> there is a subsequence that is isomorphic to <span class="SimpleMath">\(b\)</span>. This class of permutations can be represented by its anti-chain, which in this context is called the basis. <a href="chapBib_mj.html#biBRegCloSetPerms">[AAR03]</a></p>
 
-<p>To enhance the computability of permutation pattern classes, each permutation can be encoded, using the so called rank encoding. For a permutation <span class="SimpleMath">\(p_{1} \ldots p_{n}\)</span>, it is the sequence <span class="SimpleMath">\(e_{1}\ldots e_{n}\)</span> where <span class="SimpleMath">\(e_{i}\)</span> is the rank of <span class="SimpleMath">\(p_{i}\)</span> among <span class="SimpleMath">\(\{p_{i},p_{i+1},\ldots,p_{n}\}\)</span>. It can be shown that the sets of encoded permutations of the class and the basis, both are a rational languages. Rational languages can be represented by automata. <a href="chapBib_mj.html#biBRegCloSetPerms">[2]</a></p>
+<p>To enhance the computability of permutation pattern classes, each permutation can be encoded, using the so called rank encoding. For a permutation <span class="SimpleMath">\(p_{1} \ldots p_{n}\)</span>, it is the sequence <span class="SimpleMath">\(e_{1}\ldots e_{n}\)</span> where <span class="SimpleMath">\(e_{i}\)</span> is the rank of <span class="SimpleMath">\(p_{i}\)</span> among <span class="SimpleMath">\(\{p_{i},p_{i+1},\ldots,p_{n}\}\)</span>. It can be shown that the sets of encoded permutations of the class and the basis, both are a rational languages. Rational languages can be represented by automata. <a href="chapBib_mj.html#biBRegCloSetPerms">[AAR03]</a></p>
 
-<p>There is another approach to get from TPNs to their corresponding automata. Namely building equivalence classes from TPNs using the different dispositions of tokens within them. These equivalence classes of dispositions and the rank encoding of the permutations allow to build the same rational language as from the process above. <a href="chapBib_mj.html#biBPermGenTPGraph">[3]</a></p>
+<p>There is another approach to get from TPNs to their corresponding automata. Namely building equivalence classes from TPNs using the different dispositions of tokens within them. These equivalence classes of dispositions and the rank encoding of the permutations allow to build the same rational language as from the process above. <a href="chapBib_mj.html#biBPermGenTPGraph">[ALTd.]</a></p>
 
 
 <div class="chlinkprevnextbot">&nbsp;<a href="chap0_mj.html">[Top of Book]</a>&nbsp;  <a href="chap0_mj.html#contents">[Contents]</a>&nbsp;  &nbsp;<a href="chap0_mj.html">[Previous Chapter]</a>&nbsp;  &nbsp;<a href="chap2_mj.html">[Next Chapter]</a>&nbsp;  </div>