Several new string metrics are provided: StringTools[HammingDistance], StringTools[EditDistance], StringTools[PrefixDistance], StringTools[SuffixDistance], and StringTools[SimilarityCoefficient].

with( StringTools ):

HammingDistance( "Mathematics", "Mathematische" );

$4$

EditDistance( "Mathematics", "Mathematische" );

$4$

PrefixDistance( "Mathematics", "Mathematische" );

$6$

SuffixDistance( "Mathematics", "Mathematische" );

$24$

SimilarityCoefficient( "Mathematics", "Mathematische" );

$\frac{13}{7}$

The Search and SearchAll pattern matching routines have been extended to allow simultaneous searching of multiple texts. By amortizing the cost of preprocessing, this is more efficient than composing single calls to Search using map2.

Pattern := Random( 1000, 'lower' ):

$\mathrm{true}$

Texts := [seq]( Random( 5000, 'lower' ), i = 1 .. 5000 ):

evalb( Search( Pattern, Texts ) = map2( Search, Pattern, Texts ) );

$\mathrm{true}$

time( Search( Pattern, Texts ) );

$0.007$

time( map2( Search, Pattern, Texts ) );

$0.022$

Texts := 'Texts':

In addition, you can perform multiple pattern searches on a single text.

SearchAll( [ "bac", "ab" ], "abcdababacef" );

$\left[1\,2\right],\left[5\,2\right],\left[7\,2\right],\left[8\,1\right]$

P := [seq]( ThueMorse( i ), i = 5 .. 10 );

$P≔\left[''01101''\,''011010''\,''0110100''\,''01101001''\,''011010011''\,''0110100110''\right]$

SearchAll( P, Random( 200, 'binary' ) );

$\left[26\,1\right],\left[26\,2\right],\left[65\,1\right],\left[65\,2\right],\left[65\,3\right],\left[77\,1\right],\left[77\,2\right],\left[77\,3\right],\left[135\,1\right],\left[135\,2\right],\left[176\,1\right],\left[176\,2\right],\left[176\,3\right]$

You can perform multiple pattern searches for persistent pattern lists using the PatternDictionary subpackage, which exports procedures designed to manage a persistent (external) search data structure for a list of patterns. You can also perform multiple pattern matching repeatedly without incurring the costs of pattern preprocessing, something not possible using only Search and SearchAll. You can create a dictionary using the PatternDictionary[Create] constructor. The input word list is preprocessed once and can then be used for all subsequent searches using PatternDictionary[Search]. Using the PatternDictionary[Get] and PatternDictionary[Size] procedures, you can retrieve matching patterns from the dictionary.

ReadWordList := fname -> remove( type, StringTools:-Split( readbytes( fname, 'TEXT', infinity ) ), "" ):

DICT := PatternDictionary:-Create( ReadWordList( "/usr/share/dict/words" ) ):

PatternDictionary:-Size( DICT );

$51122$

PatternDictionary:-Get( DICT, 666 );

$''acquiring''$

PatternDictionary:-Search( DICT, "childbirth" );

$\left[2\,21453\right],\left[1\,7384\right],\left[1\,7412\right],\left[6\,4302\right],\left[1\,7414\right]$

map2( PatternDictionary:-Get, DICT, map2( op, 2, [ (15) ] ) );

$\left[''hi''\,''chi''\,''child''\,''birth''\,''childbirth''\right]$

The PatternDictionary subpackage also contains an algorithm for factoring a string over a dictionary of patterns. Given a string s, and a dictionary dict, the procedure PatternDictionary[Factors] computes a factorization of s over dict, that is, a sequence of patterns from dict whose concatenation is the string s.

dict := PatternDictionary:-Create( 'builtin' ):
PatternDictionary:-Factors( "linearalgebra", dict );

$''linear'',''algebra''$

Using the new WildcardMatch tool, you can perform glob-style pattern matching. The pattern language is similar to that used in UNIX shells, and is commonly applied to file and directory listings.

WildcardMatch( "a*b", "accccb" );

$\mathrm{true}$

WildcardMatch( "a[c-z]b", "acccc" );

$\mathrm{false}$

WildcardMatch( "a[c-z]??b", "acccc" );

$\mathrm{false}$

WildcardMatch( "a[c-z]??b", "acccb" );

$\mathrm{true}$

select( curry( WildcardMatch, "maple.???" ), listdir( `if`( nops( [ libname ] ) = 1, libname, libname[ 1 ] ) ) );

$\left[''maple.lib''\,''maple.ind''\,''maple.hdb''\right]$

Using the new RegSplit procedure, you can split a string on substrings matching a regular expression.

RegSplit( "(a|b)+", "xabyazbaabubav" );

$''x'',''y'',''z'',''u'',''v''$

Using the StringTools[RegSub] procedure, you can perform regular expression substitutions in strings. However, it has proved awkward to use in typical applications, and too closely matched the C APIs upon which it is based. A new StringTools[RegSubs] procedure is an improved user interface to this functionality. The calling interface resembles the built-in subs command.

RegSubs( "b" = "&&&", "abc" );

$''abbbc''$

RegSubs( "[ \t]+" = " ", "Some text   \twith\t\t    too much  white     space.   " );

$''Some\; text\; with\; too\; much\; white\; space.''$

Four new procedures support approximate pattern matching, that is, searching text with errors. Two error models are supported. Approximate searching with respect to the Hamming metric using the StringTools[HammingSearch] and StringTools[HammingSearchAll] procedures. These are analogous to Search and SearchAll, respectively, but take a third argument, a non-negative integer, which specifies the maximum allowable number of mismatches (the Hamming distance) in a match. Similarly, StringTools[ApproximateSearch] and StringTools[ApproximateSearchAll] perform approximate pattern matching using the edit (Levenshtein) distance as the metric of ``closeness'' of a match.

Search( "maths", "mathematical" );

$0$

HammingSearch( "maths", "mathematical", 1 );

$1$

ApproximateSearch( "maths", "mathematical", 1 ); # reports END of match

$4$

You can test whether one string is a subsequence of another using the new StringTools[IsSubSequence] procedure.

IsSubSequence( "abc", "abracadabra" );

$\mathrm{true}$

A number of string comparisons can be performed based on n-grams, using the new StringTools[NGrams] routine.

NGrams( "abracadabra", 2 ) ; # 2-grams or digrams

$\left[''ab''\,''br''\,''ra''\,''ac''\,''ca''\,''ad''\,''da''\,''ab''\,''br''\,''ra''\right]$

nops( (30) ) / nops( convert( (30), 'set' ) );

$\frac{10}{7}$

NGrams( "abracadabra", 3 ) ; # 3-grams or trigrams

$\left[''abr''\,''bra''\,''rac''\,''aca''\,''cad''\,''ada''\,''dab''\,''abr''\,''bra''\right]$

nops( (32) ) / nops( convert( (32), 'set' ) );

$\frac{9}{7}$

An implementation of Porter's stemming algorithm is provided in the new Stem procedure.

Stem( "hopeful" );

$''hope''$

Other routines designed to operate on natural language (especially English) text are StringTools[Words], StringTools[WordCount], StringTools[Metaphone], and StringTools[SyllableLength].

Words( "Dimension implies direction, implies measurement, implies the more and the less." ); # - Edwin E. Abbot, "Flatland"

$\left[''Dimension''\,''implies''\,''direction''\,''implies''\,''measurement''\,''implies''\,''the''\,''more''\,''and''\,''the''\,''less''\right]$

WordCount( "Dimension implies direction, implies measurement, implies the more and the less." );

$11$

Metaphone( "Cline" );

$''KLN''$

Metaphone( "Kline" );

$''KLN''$

The value that SyllableLength returns does not match the lexical syllable length found in dictionaries for some words.

SyllableLength( "antidisestablishmentarianism" );

$10$

A number of procedures are now provided for combinatorial operations on strings.

The Permute procedure applies an arbitrary permutation to the characters comprising a string. This defines an action of the symmetric group of degree $n$ on strings of length $n$.

Permute( "abc", [ 1, 3, 2 ] );

$''acb''$

Two special cases are provided in the procedures Rotate and Exchange. The former applies a permutation of the form $\left(123\mathrm{...}n\right)$ to a string of length $n$, and the latter applies a transposition permutation to a string.

seq( Rotate( "abc", i ), i = -3 .. 3 );

$''abc'',''bca'',''cab'',''abc'',''cab'',''bca'',''abc''$

Exchange( "abc", 1, 3 );

$''cba''$

The characters (actually, byte code points) of a string can be simultaneously shifted by a fixed quantity using the Shift procedure. This is essentially a generalized Caesar cipher.

Shift( "abc", 2 );

$''cde''$

Shift( "abc", -1 );

$''`ab''$

All strings of a given length on a fixed set of characters can be produced using the Generate procedure. Specify the length of strings to produce and the ``alphabet'' upon which to generate the strings. Because of the rapid growth in the numbers of strings with the length and alphabet size, it is only practical to use this for modest sized inputs.

Generate( 3, "abc" );

$\left[''aaa''\,''aab''\,''aac''\,''aba''\,''abb''\,''abc''\,''aca''\,''acb''\,''acc''\,''baa''\,''bab''\,''bac''\,''bba''\,''bbb''\,''bbc''\,''bca''\,''bcb''\,''bcc''\,''caa''\,''cab''\,''cac''\,''cba''\,''cbb''\,''cbc''\,''cca''\,''ccb''\,''ccc''\right]$

The Repeat procedure implements iterated concatenation efficiently.

Repeat( "some text ", 4 );

$''some\; text\; some\; text\; some\; text\; some\; text''$

The Support utility determines the set of characters that occur in a string.

Support( "foobar" );

$''abfor''$

Analogous to the numboccur procedure, the NumbOccur procedure in the StringTools package counts the number of occurrences of a character in a string.

seq( NumbOccur( "foobar", ch ), ch = Support( "foobar" ) );

$\mathrm{NumbOccur}\left(''foobar''\,''a''\right),\mathrm{NumbOccur}\left(''foobar''\,''b''\right),\mathrm{NumbOccur}\left(''foobar''\,''f''\right),\mathrm{NumbOccur}\left(''foobar''\,''o''\right),\mathrm{NumbOccur}\left(''foobar''\,''r''\right)$

The Trim, TrimLeft, and TrimRight procedures remove leading and trailing whitespace from strings. The new Center, PadLeft, and PadRight procedures provide approximate inverses to these text operations by adding leading and trailing whitespace to strings. You must specify a width as the second argument to each of these routines.

PadLeft( "foo", 10 );

$''foo''$

PadRight( "foo", 10 );

$''foo''$

Center( "foo", 10 );

$''foo''$

A number of new procedures support investigations in combinatorics on words (represented as strings).

Initial segments of the Thue-Morse and Fibonacci (semi-infinite) words can be constructed using StringTools[ThueMorse] and StringTools[Fibonacci], respectively.

seq( ThueMorse( n ), n = 1 .. 10 );

$''0'',''01'',''011'',''0110'',''01101'',''011010'',''0110100'',''01101001'',''011010011'',''0110100110''$

seq( Fibonacci( n ), n = 1 .. 5 );

$''0'',''01'',''010'',''01001'',''01001010''$

map( length, [ (53) ] );

$\left[1\,2\,3\,5\,8\right]$

You can determine primitivity using StringTools[IsPrimitive].  You can extract the primitive root of a word using StringTools[PrimitiveRoot].

IsPrimitive( "abc" );

$\mathrm{true}$

IsPrimitive( "ababab" );

$\mathrm{false}$

PrimitiveRoot( "abc" );

$''abc''$

PrimitiveRoot( "ababab" );

$''ab''$

You can test for conjugacy in the free semigroup (on the nonzero byte values less than 256) using StringTools[IsConjugate]. You can also efficiently compute the (lexicographically) minimal element in the conjugacy class of a given word using StringTools[MinimumConjugate].

IsConjugate( "bca", "abc" );

$\mathrm{true}$

IsConjugate( "bac", "abc" );

$\mathrm{false}$

MinimumConjugate( "bca" );

$''abc''$

MinimumConjugate( "bac" );

$''acb''$

Every string possesses a unique non-increasing factorization into substrings, each of which is a minimum conjugate. These factors are the Lyndon factors of the string. You can compute this factorization using the procedure StringTools[LyndonFactors].

L := LyndonFactors( Fibonacci( 8 ) );

$L≔\left[''01''\,''00101''\,''0010010100101''\,''00100101''\,''001''\,''001''\right]$

cat( op( L ) );

$''0100101001001010010100100101001001''$

Fibonacci( 8 );

$''0100101001001010010100100101001001''$

evalb( (65) = (64) );

$\mathrm{true}$

andmap( w -> evalb( w = MinimumConjugate( w ) ), L );

$\mathrm{true}$

seq( evalb( L[ i ] <= L[ i - 1 ] ), i = 2 .. nops( L ) );

$\mathrm{true},\mathrm{true},\mathrm{true},\mathrm{true},\mathrm{true}$

You can also factor a word into monotonic factors using MonotonicFactors.

MonotonicFactors( Fibonacci( 8 ) );

$\left[''01''\&comma;''001''\&comma;''01''\&comma;''001''\&comma;''001''\&comma;''01''\&comma;''001''\&comma;''01''\&comma;''001''\&comma;''001''\&comma;''01''\&comma;''001''\&comma;''001''\right]$

andmap( IsMonotonic, (69) );

$\mathrm{true}$

You can identify palindromes using the StringTools[IsPalindrome] procedure. (A palindrome is a string s for which $s=\mathrm{Reverse}\left(s\right)$.)

IsPalindrome( "abc" );

$\mathrm{false}$

IsPalindrome( "aba" );

$\mathrm{true}$

Periodicity of words (strings) plays an important role in combinatorics on words, as well as in pattern matching. A positive integer k is a period of a string s if $s_i=s_{i+k}$, for $i=1..n-k$, where n is the length of s. You can test whether k is a period of s using the StringTools[IsPeriod] procedure. The least period of a string s is the period of s. You can compute the period of a string using the StringTools[Period] procedure.

IsPeriod( "abcab", 2 );

$\mathrm{false}$

IsPeriod( "abcab", 3 );

$\mathrm{true}$

Period( "abcab" );

$3$

Period( "abcde" );

$5$

You can compute the length of the maximum overlap between two strings using the StringTools[Overlap] procedure.

The border of a word is the longest subword that is both a prefix and suffix of the word. You can compute the border of a word using the StringTools[Border] procedure. For efficiency, you can compute the length of the border without actually constructing it using StringTools[BorderLength]. The border array of a word is the list of the lengths of the borders of its prefixes.

Border( Fibonacci( 8 ) );

$''0100101001001''$

seq( evalb( Border( Fibonacci( n + 2 ) ) = Fibonacci( n ) ), n = 1 .. 10 );

$\mathrm{true},\mathrm{true},\mathrm{true},\mathrm{true},\mathrm{true},\mathrm{true},\mathrm{true},\mathrm{true},\mathrm{true},\mathrm{true}$

BorderArray( Fibonacci( 6 ) );

$\left[0\&comma;0\&comma;1\&comma;1\&comma;2\&comma;3\&comma;2\&comma;3\&comma;4\&comma;5\&comma;6\&comma;4\&comma;5\right]$

Overlap( "abc", "bcd" );

$2$

f8 := Fibonacci( 8 ):

Overlap( f8, f8 );

$34$

The new StringTools[IsVowel] procedure recognizes the upper and lower case English language vowels: a, e, i, o, and u.

Select( IsVowel, "facetious" );

$''aeiou''$

The StringTools[CamelCase] procedure performs a conversion that is best explained by the following example.

CamelCase( "linearalgebraicgroups" );

$''LinearAlgebraicGroups''$

The new StringTools[Visible] procedure is an aid for examining strings that contain control characters. It replaces non-printing characters with ASCII escape codes.

Visible( Random( 10 ) );

$''\backslash 228\}\backslash 216\backslash 152\backslash 11\backslash 197\backslash EG1''$

The new StringTools[Anagrams] procedure searches for anagrams of a given word (string) in a list of words (strings).

Anagrams( "edit", [ "foo", "diet", "bar", "tide", "baz", "edit", "dite", "foobar" ] );

$''tide'',''diet'',''edit'',''dite''$

The functions for computing closed forms of definite and indefinite sums are the following.

Summation: compute closed forms of definite and indefinite sums

DefiniteSummation: compute closed forms of definite sums

IndefiniteSummation: compute closed forms of indefinite sums

The DefiniteSum package contains tools for computing closed forms of definite sums.

CreativeTelescoping: compute closed forms of definite sums using the creative telescoping method

Definite: compute closed forms of definite sums using the general routine

pFqToStandardFunctions: compute closed forms of definite sums using the conversion method where the hypergeometric series is used as an intermediate representation

Telescoping: compute closed forms of definite sums using the classical telescoping method

The IndefiniteSum package contains tools for computing closed forms of indefinite sums.

AccurateSummation: indefinite sums using the method of accurate summation

AddIndefiniteSum: library extension mechanism

Hypergeometric: indefinite sums of j-fold hypergeometric terms

Indefinite: general routine for computing closed forms of indefinite sums

Polynomial: indefinite sums of polynomials

Rational: indefinite sums of rational functions

RemoveIndefiniteSum: library extension mechanism

The Hypergeometric package contains tools for working with hypergeometric terms in general, and for finding closed forms of definite and indefinite sums of hypergeometric term.

Normal forms of rational functions and of hypergeometric terms: MultiplicativeDecomposition, PolynomialNormalForm, RationalCanonicalForm, SumDecomposition

Algorithms for definite and indefinite sums of hypergeometric type: ExtendedGosper, ExtendedZeilberger, Gosper, IsZApplicable, KoepfGosper, KoepfZeilberger, LowerBound, MinimalZpair, Zeilberger, ZeilbergerRecurrence, ZpairDirect

Applications: DefiniteSum, IndefiniteSum, WZMethod

Other functions: AreSimilar, ConjugateRTerm, IsHolonomic, IsHypergeometricTerm, IsProperHypergeometricTerm, Verify

The SumTools[Hypergeometric][AccurateSummation] function has been superseded by the SumTools[IndefiniteSum][AccurateSummation] function.

The following new functions have been added to the SumTools[Hypergeometric] package:

with(SumTools:-Hypergeometric):

IsZApplicable: An implementation of a necessary and sufficient condition for the termination of Zeilberger's algorithm to hypergeometric terms.

T1 := 1/(n*k+n+1)*binomial(n,k+1) +
     (n*k-2*k-n+2)/(n^2*k+2*n*k^2-n*k+2*k+n-1)*binomial(n,k);

$\mathrm{T1}≔\frac{\left(\genfrac{}{}{0ex}{}{n}{k+1}\right)}{nk+n+1}+\frac{\left(nk-2k-n+2\right)\left(\genfrac{}{}{0ex}{}{n}{k}\right)}{2n{k}^2+n^{2}k-nk+2k+n-1}$

IsZApplicable(T1,n,k);

$\mathrm{true}$

T2 := (-1)^k*1/(n*k+1)*binomial(n+1,k)*binomial(2*n-2*k-1,n-1);

$\mathrm{T2}≔\frac{{\left(\mathrm{-1}\right)}^k\left(\genfrac{}{}{0ex}{}{n+1}{k}\right)\left(\genfrac{}{}{0ex}{}{2n-2k-1}{n-1}\right)}{nk+1}$

IsZApplicable(T2,n,k);

$\mathrm{false}$

LowerBound: An implementation of an algorithm to compute a lower bound for the order of the telescopers for a given bivariate hypergeometric term.

T3 := 1/(n*(k+1)+1)*binomial(2*n,k+1)-1/(n*k+1)*binomial(2*n,k)+
     1/(2*k-1)/(n-3*k+1)*binomial(2*n,k);

$\mathrm{T3}≔\frac{\left(\genfrac{}{}{0ex}{}{2n}{k+1}\right)}{n\left(k+1\right)+1}-\frac{\left(\genfrac{}{}{0ex}{}{2n}{k}\right)}{nk+1}+\frac{\left(\genfrac{}{}{0ex}{}{2n}{k}\right)}{\left(2k-1\right)\left(n-3k+1\right)}$

LowerBound(T3,n,k);

$3$

ExtendedZeilberger: An implementation of an algorithm which computes the minimal Z-pairs for a class of sums of hypergeometric terms.

T4 := (-1)^k*binomial(m,k)*binomial(2*k,k)*1/2^(2*k);

$\mathrm{T4}≔\frac{{\left(\mathrm{-1}\right)}^k\left(\genfrac{}{}{0ex}{}{m}{k}\right)\left(\genfrac{}{}{0ex}{}{2k}{k}\right)}{2^{2k}}$

V := Sum(T4,m=0..n);

$V≔\sum _{m=0}^n\frac{{\left(\mathrm{-1}\right)}^k\left(\genfrac{}{}{0ex}{}{m}{k}\right)\left(\genfrac{}{}{0ex}{}{2k}{k}\right)}{2^{2k}}$

ExtendedZeilberger(V,n,k,En);

$\left[\left(2n+4\right){\mathrm{En}}^2+\left(-4n-7\right)\mathrm{En}+2n+3\&comma;\frac{2k^2{\left(\mathrm{-1}\right)}^k\left(\genfrac{}{}{0ex}{}{n+1}{k}\right)\left(\genfrac{}{}{0ex}{}{2k}{k}\right)}{\left(-n-2+k\right)2^{2k}}\right]$

_EnvDoubleSum := true:

Sum(V,k=0..n) = DefiniteSum(V,n,k,0..n);

$\sum _{k=0}^n\sum _{m=0}^n\frac{{\left(\mathrm{-1}\right)}^k\left(\genfrac{}{}{0ex}{}{m}{k}\right)\left(\genfrac{}{}{0ex}{}{2k}{k}\right)}{2^{2k}}=\frac{\left(2n+1\right)\left(\genfrac{}{}{0ex}{}{2n}{n}\right)}{4^n}$

KoepfGosper and KoepfZeilberger: Implementation of W. Koepf's extension to Gosper's algorithm and Zeilberger's algorithm, respectively.

T5 := n*(n/2)!;

$\mathrm{T5}≔n\left(\frac{n}{2}\right)!$

Sum(T5,n) = KoepfGosper(T5,n);

$\sum _{n}n\left(\frac{n}{2}\right)!=2\left(\frac{n}{2}\right)!+2\left(\frac{n}{2}+\frac{1}{2}\right)!$

T6 := binomial(2/3*n,2*k);

$\mathrm{T6}≔\left(\genfrac{}{}{0ex}{}{\frac{2n}{3}}{2k}\right)$

Zpair := KoepfZeilberger(T6,n,k,En);

$\mathrm{Zpair}≔\left[{\mathrm{En}}^3-4\&comma;\frac{6\left(k-\frac{n}{2}-1\right)\left(2k-1\right)k\left(\genfrac{}{}{0ex}{}{\frac{2n}{3}}{2k}\right)}{\left(k-1-\frac{n}{3}\right)\left(-\frac{2n}{3}-1+2k\right)n}\right]$

MinimalZpair: A combination of various algorithms for computing the minimal Z-pairs of hypergeometric terms.

T7 := 1/(3*n+20*k+2)^3;

$\mathrm{T7}≔\frac{1}{{\left(3n+20k+2\right)}^3}$

MinimalZpair(T7,n,k,En);

$\left[{\mathrm{En}}^{20}-1\&comma;\frac{1}{{\left(3n+20k+42\right)}^3}+\frac{1}{{\left(3n+20k+22\right)}^3}+\frac{1}{{\left(3n+20k+2\right)}^3}\right]$

T8 := 1/(n*(k+1)-1)/(n-2*k-4)/(2*n+k+4)!-1/(n*k-1)/(n-2*k-2)/(2*n+k+3)!+1/(n-2*k-2)/(2*n+k+3)!;

$\mathrm{T8}≔\frac{1}{\left(n\left(k+1\right)-1\right)\left(n-2k-4\right)\left(2n+k+4\right)!}-\frac{1}{\left(nk-1\right)\left(n-2k-2\right)\left(2n+k+3\right)!}+\frac{1}{\left(n-2k-2\right)\left(2n+k+3\right)!}$

Zpair := MinimalZpair(T8,n,k,En):

Zpair[1];

$\left(-1953125n^9-44140625n^8-438125000n^7-2505718750n^6-9095640625n^5-21719685625n^4-34096450250n^3-33905768600n^2-19362572120n-4833216960\right){\mathrm{En}}^3+\left(1953125n^9+42187500n^8+400625000n^7+2194468750n^6+7637609375n^5+17505613750n^4+26405971500n^3+25257742600n^2+13888257120n+3340995840\right){\mathrm{En}}^2+\left(20000n^4+152000n^3+422400n^2+508160n+223232\right)\mathrm{En}-20000n^4-232000n^3-998400n^2-1888960n-1325792$

As previously demonstrated using the IsZApplicable function, you cannot apply Zeilberger's algorithm to $\mathrm{T2}$.

MinimalZpair(T2,n,k,En);

Error, (in SumTools:-Hypergeometric:-MinimalZpair) Zeilberger's algorithm is not applicable