passagemath-fricas 10.5.40__cp310-cp310-macosx_14_0_arm64.whl → 10.5.41__cp310-cp310-macosx_14_0_arm64.whl

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/acplot.spad

@@ -1,8 +1,8 @@
 )abbrev package REALSOLV RealSolvePackage
 
 RealSolvePackage() : Exports == Implementation where
-  ++ This package provides numerical solutions of systems of polynomial
-  ++ equations for use in ACPLOT.
+++ Description: This package provides numerical solutions of systems of
+++ polynomial equations for use in ACPLOT.
   I    ==> Integer
   IE   ==> IndexedExponents Symbol
   L    ==> List
@@ -22,7 +22,7 @@ RealSolvePackage() : Exports == Implementation where
       ++ solve(p, eps) finds the real zeroes of a univariate
       ++ integer polynomial p with precision eps.
     realSolve : (L P I, L SY, NF) -> L L NF
-      ++ realSolve(lp, lv, eps) = compute the list of the real
+      ++ realSolve(lp, lv, eps) computes the list of the real
       ++ solutions of the list lp of polynomials with integer
       ++ coefficients with respect to the variables in lv,
       ++ with precision eps.
@@ -47,13 +47,12 @@ RealSolvePackage() : Exports == Implementation where
 
 )abbrev domain ACPLOT PlaneAlgebraicCurvePlot
 
---% PlaneAlgebraicCurvePlot
-++ Plot a NON-SINGULAR plane algebraic curve p(x, y) = 0.
 ++ Author: Clifton J. Williamson
 ++ Date Created: Fall 1988
 ++ Keywords: algebraic curve, non-singular, plot
 ++ Examples:
 ++ References:
+++ Description: Plot a NON-SINGULAR plane algebraic curve \spad{p(x, y) = 0}.
 
 PlaneAlgebraicCurvePlot() : Exports == Implementation where
     B           ==> Boolean

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/aggcat.spad

@@ -1248,6 +1248,13 @@ BinaryRecursiveAggregate(S : Type) : Category == RecursiveAggregate S with
        setelt!(x, "left", b)  == setleft!(x, b)
        setelt!(x, "right", b) == setright!(x, b)
 
+       setchildren!(x, ls) ==
+           not(#ls =$NonNegativeInteger 2) =>
+               error "a binary tree needs 2 children"
+           setleft!(x, ls.1)
+           setright!(x, ls.2)
+           x
+
 )abbrev category DLAGG DoublyLinkedAggregate
 ++ Author: Michael Monagan; revised by Manuel Bronstein and Richard Jenks
 ++ Date Created: August 87 through August 88
@@ -2597,6 +2604,10 @@ StringAggregate : Category == OneDimensionalArrayAggregate Character with
       ++ elt(s, t) returns the concatenation of s and t. It is provided to
       ++ allow juxtaposition of strings to work as concatenation.
       ++ For example, \spad{"smoo" "shed"} returns \spad{"smooshed"}.
+    join: (%, List %) -> %
+      ++ join(sep,ls) returns an element that is the concatenation
+      ++ of all strings in ls but separated by sep, for example,
+      ++ join("/",["a","b","c"]) returns "a/b/c".
  add
    trim(s : %, cc : CharacterClass) == leftTrim(rightTrim(s, cc), cc)
 

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/aggcat2.spad

@@ -31,7 +31,7 @@ FiniteLinearAggregateFunctions2(S, A, R, B):
     scan   : ((S, R) -> R, A, R) -> B
       ++ scan(f, a, r) successively applies
       ++ \spad{reduce(f, x, r)} to more and more leading sub-aggregates
-      ++ x of aggregrate \spad{a}.
+      ++ x of aggregate \spad{a}.
       ++ More precisely, if \spad{a} is \spad{[a1, a2, ...]}, then
       ++ \spad{scan(f, a, r)} returns
       ++ \spad{[reduce(f, [a1], r), reduce(f, [a1, a2], r), ...]}.

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/alg_top.spad

@@ -230,6 +230,8 @@ FacetCategory() : Category == Definition where
 
   add
 
+   import from NNI
+
    -- is empty if it contains no vertices or if multiplier is zero
    empty?(orf : %) : Boolean ==
        if order(orf) = 0 then return true
@@ -1004,6 +1006,9 @@ CubicalFacet() : Exports == Impl where
    -- treat it as an integer.
    Rep := Record(mul : Integer, fac : List(Segment(Integer)))
 
+   import from Integer
+   import from List(Segment(Integer))
+
    -- Constructor for cubical facet
    -- intervals are always stored in low..high order
    -- orientation is calculated by the number of intervals that have
@@ -1278,11 +1283,11 @@ Which are defined like this:
 
 C0 = Zero dimensional chain
 = free abelian group on vertices.
-Elements of C0 are intergral linear combinations of vertices such as: 2x+7y+5z
+Elements of C0 are integral linear combinations of vertices such as: 2x+7y+5z
 
 C1 = One dimensional chain
 = free abelian group on directed edges (1-cells).
-Elements of C1 are intergral linear combinations of edges such as: 2xy+7xz+5yz
+Elements of C1 are integral linear combinations of edges such as: 2xy+7xz+5yz
 These don't necessarily need to be a cycle or even connected.
 
 C2 = two dimensional chain
@@ -1401,6 +1406,8 @@ ChainComplex() : Exports == Impl where
 
    transition_matrices(a : %) : List(Matrix(Integer)) == a::Rep
 
+   import from PrintPackage
+
    -- true if this is a valid chain complex, that is:
    -- 1) maps compose
    -- 2) product of adjacent maps is zero
@@ -1544,6 +1551,8 @@ CoChainComplex(VS : AbelianGroup) : Exports == Impl where
        tm := reverse!(tm)
        map(transpose, tm)
 
+   import from PrintPackage
+
    -- true if this is a valid cochain complex, that is:
    -- 1) maps compose
    -- 2) product of adjacent maps is zero
@@ -2531,6 +2540,8 @@ FiniteCubicalComplex(VS : AbelianGroup) : Exports == Impl where
 
   Impl ==> add
 
+   import from List(Segment(Integer))
+
    -- Representation holds whole Cubical Complex. This consists of
    -- a vertex set, here represented as a vertex list so that we can
    -- index it.

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/algfact.spad

@@ -142,7 +142,6 @@ AlgFactor(UP) : Exports == Implementation where
   Z   ==> Integer
   Q   ==> Fraction Integer
   AN  ==> AlgebraicNumber
-  K   ==> Kernel AN
   UPQ ==> SparseUnivariatePolynomial Q
   SUP ==> SparseUnivariatePolynomial AN
   FR  ==> Factored UP
@@ -165,8 +164,11 @@ AlgFactor(UP) : Exports == Implementation where
 
   Implementation ==> add
 
+    EI ==> Expression(Integer)
+    K ==> Kernel(EI)
+
     import from PolynomialCategoryQuotientFunctions(IndexedExponents K,
-                           K, Z, SparseMultivariatePolynomial(Z, K), AN)
+                           K, Z, SparseMultivariatePolynomial(Z, K), EI)
     import from Integer
 
     UPCF2 ==> UnivariatePolynomialCategoryFunctions2
@@ -178,13 +180,19 @@ AlgFactor(UP) : Exports == Implementation where
     liftpoly : UPQ -> UP
     irred?  : UP  -> Boolean
 
+    import from List(AN)
+    import from Factored(UP)
+
+    ker_lst(la : List(AN)) : List(K) ==
+        tower([c::EI for c in la]$List(EI))
+
     liftpoly p   == map(x +-> x::AN,  p)$UPCF2(Q, UPQ, AN, UP)
     downpoly p   == map(x +-> retract(x)@Q, p)$UPCF2(AN, UP , Q, UPQ)
     ifactor(p, l) == (fact(p pretend UP, l)) pretend Factored(SUP)
-    factor p     == fact(p, tower coefficients p)
+    factor p     == fact(p, ker_lst(coefficients(p)))
 
     factor(p, l) ==
-      fact(p, tower removeDuplicates concat(l, coefficients p))
+      fact(p, ker_lst(removeDuplicates(concat(l, coefficients p))))
 
     split p ==
       fp := factor p
@@ -204,6 +212,12 @@ AlgFactor(UP) : Exports == Implementation where
       fp := factorList factor p
       size?(fp, 1) and first(fp).exponent = 1
 
+    SUPEI_to_SUP(pe : SparseUnivariatePolynomial(EI)) : SUP ==
+        map(retract, pe)$SparseUnivariatePolynomialFunctions2(EI, AN)
+
+    red_AN(x : AN, alpha : K, q : SparseUnivariatePolynomial(EI)) : SUP ==
+        SUPEI_to_SUP(univariate(x::EI, alpha, q))
+
     fact(p, l) ==
       (degree p = 1) => primeFactor(p, 1)
       empty? l =>
@@ -211,14 +225,14 @@ AlgFactor(UP) : Exports == Implementation where
         (liftpoly unit dr) *
           _*/[primeFactor(liftpoly dc.factor, dc.exponent)
             for dc in factorList dr]
-      q   := minPoly(alpha := "max"/l)$AN
+      q   := SUPEI_to_SUP(qe := minPoly(alpha := "max"/l)$EI)
       newl  := remove((x : K) : Boolean +-> alpha = x, l)
       sae := SimpleAlgebraicExtension(AN, SUP, q)
       ups := SparseUnivariatePolynomial sae
-      fr  := factor(map(x +-> reduce univariate(x, alpha, q),
+      fr  := factor(map(x +-> reduce(red_AN(x, alpha, qe)),
                      p)$UPCF2(AN, UP, sae, ups),
                     x +-> ifactor(x, newl))$InnerAlgFactor(AN, SUP, sae, ups)
-      newalpha := alpha::AN
+      newalpha := retract((alpha::EI))@AN
       map((x : sae) : AN +-> (lift(x)$sae) newalpha, unit fr)$UPCF2(sae,
                                 ups, AN, UP) *
             _*/[primeFactor(map((x : sae) : AN +-> (lift(x)$sae) newalpha,

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/algfunc.spad

@@ -325,6 +325,12 @@ AlgebraicFunction(R, F) : Exports == Implementation where
     belong? op == has?(op, ALGOP) or is?(op, '%root_sum)
     dalg l     == second(l)::OutputForm
 
+    import from UP
+    import from Fraction(UP)
+    import from Integer
+    import from SparseMultivariatePolynomial(R, Kernel(F))
+    import from List(F)
+
     rootOf(p, x) ==
       k := kernel(x)$K
       (r := retractIfCan(p)@Union(F, "failed")) case "failed" =>

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/array1.spad

@@ -1,6 +1,6 @@
 )abbrev domain PRIMARR PrimitiveArray
-++ This provides a fast array type with no bound checking on elt's.
-++ Minimum index is 0 in this type, cannot be changed
+++ Description: This provides a fast array type with no bound checking on
+++ elt's.  Minimum index is 0 in this type, cannot be changed.
 PrimitiveArray(S : Type) : OneDimensionalArrayAggregate S == add
    Qmax ==> QVMAXINDEX$Lisp
    Qsize ==> QVSIZE$Lisp
@@ -29,8 +29,8 @@ PrimitiveArray(S : Type) : OneDimensionalArrayAggregate S == add
 
 
 )abbrev package PRIMARR2 PrimitiveArrayFunctions2
-++ This package provides tools for operating on primitive arrays
-++ with unary and binary functions involving different underlying types
+++ Description: This package provides tools for operating on primitive arrays
+++ with unary and binary functions involving different underlying types.
 PrimitiveArrayFunctions2(A, B) : Exports == Implementation where
   A, B : Type
 
@@ -65,7 +65,7 @@ PrimitiveArrayFunctions2(A, B) : Exports == Implementation where
     reduce(f, v, b) == reduce(f, v, b)$O2
 
 )abbrev domain TUPLE Tuple
-++ This domain is used to interface with the interpreter's notion
+++ Description: This domain is used to interface with the interpreter's notion
 ++ of comma-delimited sequences of values.
 Tuple(S : Type) : CoercibleTo(PrimitiveArray S) with
   coerce : PrimitiveArray S -> %
@@ -99,8 +99,8 @@ Tuple(S : Type) : CoercibleTo(PrimitiveArray S) with
 
 )abbrev domain IFARRAY IndexedFlexibleArray
 ++ Author: Michael Monagan July/87, modified SMW June/91
-++ A FlexibleArray is the notion of an array intended to allow for growth
-++ at the end only.  Hence the following efficient operations
+++ Description: A FlexibleArray is the notion of an array intended to allow
+++ for growth at the end only.  Hence the following efficient operations
 ++   \spad{concat!(a, x)} meaning append item x at the end of the array \spad{a}
 ++   \spad{delete!(a, n)} meaning delete the last item from the array \spad{a}
 ++ Flexible arrays support the other operations inherited from
@@ -326,8 +326,8 @@ IndexedFlexibleArray(S : Type, mn : Integer) : Exports == Implementation where
           a
 
 )abbrev domain FARRAY FlexibleArray
-++ A FlexibleArray is the notion of an array intended to allow for growth
-++ at the end only.  Hence the following efficient operations
+++ Description: A FlexibleArray is the notion of an array intended to allow
+++ for growth at the end only.  Hence the following efficient operations
 ++   \spad{concat!(a, x)} meaning append item x at the end of the array \spad{a}
 ++   \spad{delete!(a, n)} meaning delete the last item from the array \spad{a}
 ++ Flexible arrays support the other operations inherited from
@@ -347,8 +347,8 @@ FlexibleArray(S : Type) == Implementation where
 -- Join(OneDimensionalArrayAggregate S, ExtensibleLinearAggregate S)
 
 )abbrev domain IARRAY1 IndexedOneDimensionalArray
-++ Author Micheal Monagan Aug/87
-++ This is the basic one dimensional array data type.
+++ Author: Micheal Monagan Aug/87
+++ Description: This is the basic one dimensional array data type.
 
 IndexedOneDimensionalArray(S : Type, mn : Integer):
  OneDimensionalArrayAggregate S == add
@@ -437,7 +437,7 @@ IndexedOneDimensionalArray(S : Type, mn : Integer):
          qsetelt!(x, i, s)
 
 )abbrev domain ARRAY1 OneDimensionalArray
-++ This is the domain of 1-based one dimensional arrays
+++ Description: This is the domain of 1-based one dimensional arrays.
 
 OneDimensionalArray(S : Type) : Exports == Implementation where
   ARRAYMININDEX ==> 1       -- if you want to change this, be my guest
@@ -465,8 +465,8 @@ OneDimensionalArray(S : Type) : Exports == Implementation where
     oneDimensionalArray(n, s) == new(n, s)
 
 )abbrev package ARRAY12 OneDimensionalArrayFunctions2
-++ This package provides tools for operating on one-dimensional arrays
-++ with unary and binary functions involving different underlying types
+++ Description: This package provides tools for operating on one-dimensional
+++ arrays with unary and binary functions involving different underlying types.
 OneDimensionalArrayFunctions2(A, B) : Exports == Implementation where
   A, B : Type
 

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/brill.spad

@@ -13,6 +13,7 @@
 ++ [2] James Davenport, On Brillhart Irreducibility. To appear.
 ++ [3] John Brillhart, On the Euler and Bernoulli polynomials,
 ++ J. Reine Angew. Math., v. 234, (1969), pp. 45-64
+++ Description: This package implements Brillhart irreducibility test.
 
 BrillhartTests(UP) : Exports == Implementation where
   N ==> NonNegativeInteger

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/carten.spad

@@ -544,7 +544,7 @@ CartesianTensor(minix, dim, R) : Exports == Implementation where
         transpose(x, i, j) ==
             rx := rank x
             i < 1 or i > rx or j < 1 or j > rx or i = j =>
-                error "Improper indicies for transposition"
+                error "Improper indices for transposition"
             if i > j then (i, j) := (j, i)
 
             rl := qcoerce(rx - j)@NNI; nl := dim^rl; zol := 1; zoi := zol*nl

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/catdef.spad

@@ -43,7 +43,7 @@ AbelianGroup() : Category == CancellationAbelianMonoid with
 ++ Keywords:
 ++ References:
 ++ Description:
-++ The class of multiplicative monoids, i.e. semigroups with an
+++ The class of additive (commutative) monoids, i.e. semigroups with an
 ++ additive identity element.
 ++
 ++ Axioms:
@@ -677,6 +677,7 @@ FullyLinearlyExplicitOver(R : Ring) : Category ==
  add
   if not(R is Integer) then
       if (R has LinearlyExplicitOver Integer) then
+          ((x : %) * (n : Integer)) : % == x*(1$R *$R n)
           reducedSystem(m : Matrix %) : Matrix(Integer) ==
               reducedSystem(reducedSystem(m)@Matrix(R))
 
@@ -1272,7 +1273,7 @@ PolynomialFactorizationExplicit() : Category == Definition where
          conditionP : Matrix % -> Union(Vector %,"failed")
               ++ conditionP(m) returns a vector of elements, not all zero,
               ++ whose \spad{p}-th powers (p is the characteristic of the domain)
-              ++ are a solution of the homogenous linear system represented
+              ++ are a solution of the homogeneous linear system represented
               ++ by m, or "failed" is there is no such vector.
          charthRoot : % -> Union(%,"failed")
               ++ charthRoot(r) returns the \spad{p}-th root of r, or "failed"

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/charpol.spad

@@ -109,6 +109,8 @@ CharacteristicPolynomial3(R : IntegralDomain) : Exports == Implementation where
 
   Implementation ==> add
 
+    import from F
+
     char_pol_via_interpolation0(m : Mat, ld : List(R)) : UpF ==
         n := ncols(m)
         n ~= nrows(m) => error "matrix not square"
@@ -163,3 +165,90 @@ CharacteristicPolynomial3(R : IntegralDomain) : Exports == Implementation where
             res1 := char_pol_via_interpolation0(B, lg)
             d := reduce(_*, lg, 1)::F
             map(c +-> c/d, res1)
+
+)abbrev package CHARPOL4 CharacteristicPolynomial4
+++ References: J. Abdeljaoued, The Berkovitz algorithm, Maple and computing
+++  the characteristic polynomial in an arbitrary commutative ring,
+++  MapleTech, Vol. 4, No. 3, pp. 21--32.
+++ Description: This package computes characteristic polynomial
+++  via Berkovitz-Samuelson formula.
+CharacteristicPolynomial4(R : Ring) : Exports == Implementation where
+  Mat ==> Matrix(R)
+  Up ==> SparseUnivariatePolynomial(R)
+  Exports ==> with
+    char_pol_via_berkovitz : Mat -> Up
+      ++ char_pol_via_berkovitz(m) computes characteristic
+      ++ polynomial of m.
+  Implementation ==> add
+
+    VR ==> Vector(R)
+
+    dot_col_vec(m : Mat, k : Integer, v : VR, l : Integer) : R ==
+        ss : R := 0
+        for j in 1..l repeat
+            ss := ss + m(k, j)*v(j)
+        ss
+
+    char_pol_via_berkovitz(m : Mat) : Up ==
+        n := ncols(m)
+        n ~= nrows(m) => error "matrix not square"
+        x := monomial(1, 1)$Up
+        n = 0 => 1
+        n = 1 => m(1, 1)::Up - x
+        n = 2 => (m(1, 1)::Up - x)*(m(2, 2)::Up - x) - (m(2, 1)*m(1, 2))::Up
+        -- vector representing characteristic polynomial
+        pv := zero(n + 1)$VR
+        -- work vectors
+        q := zero(n + 1)$VR
+        c := zero(n + 1)$VR
+        s := zero(qcoerce(n - 1))$VR
+        q(1) := -1
+        q(2) := m(1, 1)
+        c(1) := -1
+        for r in 2..n repeat
+            for i in 1..r repeat
+                pv(i) := q(i)
+            for i in 1..(r - 1) repeat
+                s(i) := m(i, r)
+            c(2) := m(r, r)
+            for i in 1..(r - 2) repeat
+                c(i + 2) := dot_col_vec(m, r, s, r - 1)
+                for j in 1..(r - 1) repeat
+                    q(j) := dot_col_vec(m, j, s, r - 1)
+                for j in 1..(r - 1) repeat
+                    s(j) := q(j)
+            c(r + 1) := dot_col_vec(m, r, s, r - 1)
+            for i in 1..(r + 1) repeat
+                ss : R := 0
+                for j in 1..min(r, i) repeat
+                    ss := ss + c(i + 1 - j)*pv(j)
+                q(i) := ss
+        for i in 1..(n + 1) repeat
+            pv(n + 2 - i) := q(i)
+        unvectorise(pv)$Up
+
+)abbrev package CHARPOL0 CharacteristicPolynomial
+CharacteristicPolynomial(R : CommutativeRing) : Exports == Implementation where
+    Mat ==> Matrix(R)
+    Up ==> SparseUnivariatePolynomial(R)
+    Exports ==> with
+      characteristicPolynomial : Mat -> Up
+        ++ characteristicPolynomial(m) computes the characteristic
+        ++ polynomial of the matrix m.
+      characteristicPolynomial : (Mat, R) -> R
+        ++ characteristicPolynomial(m, r) computes the characteristic
+        ++ polynomial of the matrix m evaluated at the point r.
+        ++ In particular, if r is the polynomial 'x, then it returns
+        ++ the characteristic polynomial expressed as a polynomial in 'x.
+    Implementation ==> add
+
+        if R has FiniteFieldCategory then
+            characteristicPolynomial(m) ==
+                char_pol(m)$CharacteristicPolynomial2(R)
+        else
+            characteristicPolynomial(m) ==
+                char_pol_via_berkovitz(m)$CharacteristicPolynomial4(R)
+
+        characteristicPolynomial(m, x) ==
+            characteristicPolynomial(m)(x)
+

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/clifford.spad

@@ -129,9 +129,9 @@ We can then create some elements in the algebra (I will call the general element
 There are many options for creating higher grade basis,
 
     * by multiplying basis vectors,
-    * or by using ee(List PI) to specify the higher order term in one go with a list of its indices (exterior product of indicies)
-    * or from a binary map of the indicies
-    * or using the monomial function (Clifford product of indicies)
+    * or by using ee(List PI) to specify the higher order term in one go with a list of its indices (exterior product of indices)
+    * or from a binary map of the indices
+    * or using the monomial function (Clifford product of indices)
     * or using the pseudoscalar.
 
 (4) -> e12 : Eu := e(1) /\ e(2)

sage_wheels/lib/fricas/target/aarch64-apple-darwin23.6.0/src/algebra/combfunc.spad

@@ -103,6 +103,10 @@ CombinatorialFunction(R, F) : Exports == Implementation where
 
   Implementation ==> add
 
+    import from List(Symbol)
+    import from BasicOperator
+    import from Segment(F)
+
     COMB := 'comb
 
     ifact     : F -> F
@@ -616,14 +620,32 @@ FunctionalSpecialFunction(R, F) : Exports == Implementation where
         ++ riemannZeta(z) is the Riemann Zeta function.
     charlierC : (F, F, F) -> F
         ++ charlierC(n, a, z) is the Charlier polynomial.
+    hahn_p : (F, F, F, F, F) -> F
+        ++ hahn_p(n, a, b, bar_a, bar_b, z) is the continuous
+        ++ Hahn polynomial.
+    hahnQ : (F, F, F, F, F) -> F
+        ++ hahnQ(n, a, b, N, z) is the Hahn polynomial.
+    hahnR : (F, F, F, F, F) -> F
+        ++ hahnR(n, c, d, N, z) is the dual Hahn polynomial.
+    hahnS : (F, F, F, F, F) -> F
+        ++ hahnS(n, a, b, c, z) is the continuous dual Hahn
+        ++ polynomial.
     hermiteH : (F, F) -> F
         ++ hermiteH(n, z) is the Hermite polynomial.
     jacobiP : (F, F, F, F) -> F
         ++ jacobiP(n, a, b, z) is the Jacobi polynomial.
+    krawtchoukK : (F, F, F, F) -> F
+        ++ krawtchoukK(n, p, N, z) is the Krawtchouk polynomial.
     laguerreL: (F, F, F) -> F
         ++ laguerreL(n, a, z) is the Laguerre polynomial.
     meixnerM : (F, F, F, F) -> F
         ++ meixnerM(n, b, c, z) is the Meixner polynomial.
+    meixnerP : (F, F, F, F) -> F
+        ++ meixnerP(n, phi, lambda, z) is the Meixner-Pollaczek polynomial.
+    racahR : (F, F, F, F, F, F) -> F
+        ++ racahR(n, a, b, c, d, z) is the Racah polynomial.
+    wilsonW : (F, F, F, F, F, F) -> F
+        ++ wilsonW(n, a, b, c, d, z) is the Wilson polynomial.
     if F has RetractableTo(Integer) then
         hypergeometricF : (List F, List F, F) -> F
           ++ hypergeometricF(la, lb, z) is the generalized hypergeometric
@@ -748,10 +770,18 @@ FunctionalSpecialFunction(R, F) : Exports == Implementation where
     opHypergeometricF := operator('hypergeometricF)$CommonOperators
     opMeijerG := operator('meijerG)$CommonOperators
     opCharlierC := operator('charlierC)$CommonOperators
+    op_hahn_p := operator('hahn_p)$CommonOperators
+    op_hahnQ := operator('hahnQ)$CommonOperators
+    op_hahnR := operator('hahnR)$CommonOperators
+    op_hahnS := operator('hahnS)$CommonOperators
     opHermiteH := operator('hermiteH)$CommonOperators
     opJacobiP := operator('jacobiP)$CommonOperators
+    op_krawtchoukK := operator('krawtchoukK)$CommonOperators
     opLaguerreL := operator('laguerreL)$CommonOperators
     opMeixnerM := operator('meixnerM)$CommonOperators
+    op_meixnerP := operator('meixnerP)$CommonOperators
+    op_racahR := operator('racahR)$CommonOperators
+    op_wilsonW := operator('wilsonW)$CommonOperators
     op_log_gamma := operator('%logGamma)$CommonOperators
     op_eis := operator('%eis)$CommonOperators
     op_erfs := operator('%erfs)$CommonOperators
@@ -1710,6 +1740,60 @@ FunctionalSpecialFunction(R, F) : Exports == Implementation where
     setProperty(opLaguerreL, SPECIALDIFF, dLaguerreL@((List F, SY)->F)
                                                  pretend None)
 
+    hahn_p(n : F, a : F, b : F, c : F, z : F) : F == op_hahn_p(n, a, b, c, z)
+
+    e_hahn_p(n : F, a : F, b : F, c : F, z : F) : F ==
+        n = 0 => 1
+        kernel(op_hahn_p, [n, a, b, c, z])
+
+    el_hahn_p(l: List F) : F == e_hahn_p(l(1), l(2), l(3), l(4), l(5))
+
+    evaluate(op_hahn_p, el_hahn_p)$BasicOperatorFunctions1(F)
+
+
+    hahnQ(n : F, a : F, b : F, c : F, z : F) : F == op_hahnQ(n, a, b, c, z)
+
+    e_hahnQ(n : F, a : F, b : F, c : F, z : F) : F ==
+        n = 0 => 1
+        kernel(op_hahnQ, [n, a, b, c, z])
+
+    el_hahnQ(l: List F) : F == e_hahnQ(l(1), l(2), l(3), l(4), l(5))
+
+    evaluate(op_hahnQ, el_hahnQ)$BasicOperatorFunctions1(F)
+
+
+    hahnR(n : F, a : F, b : F, c : F, z : F) : F == op_hahnR(n, a, b, c, z)
+
+    e_hahnR(n : F, a : F, b : F, c : F, z : F) : F ==
+        n = 0 => 1
+        kernel(op_hahnR, [n, a, b, c, z])
+
+    el_hahnR(l: List F) : F == e_hahnR(l(1), l(2), l(3), l(4), l(5))
+
+    evaluate(op_hahnR, el_hahnR)$BasicOperatorFunctions1(F)
+
+
+    hahnS(n : F, a : F, b : F, c : F, z : F) : F == op_hahnS(n, a, b, c, z)
+
+    e_hahnS(n : F, a : F, b : F, c : F, z : F) : F ==
+        n = 0 => 1
+        kernel(op_hahnS, [n, a, b, c, z])
+
+    el_hahnS(l: List F) : F == e_hahnS(l(1), l(2), l(3), l(4), l(5))
+
+    evaluate(op_hahnS, el_hahnS)$BasicOperatorFunctions1(F)
+
+
+    krawtchoukK(n : F, b : F, c : F, z : F) : F == op_krawtchoukK(n, b, c, z)
+
+    e_krawtchoukK(n : F, b : F, c : F, z : F) : F ==
+        n = 0 => 1
+        kernel(op_krawtchoukK, [n, b, c, z])
+
+    el_krawtchoukK(l : List F) : F == e_krawtchoukK(l(1), l(2), l(3), l(4))
+
+    evaluate(op_krawtchoukK, el_krawtchoukK)$BasicOperatorFunctions1(F)
+
 
     meixnerM(n : F, b : F, c : F, z : F) : F == opMeixnerM(n, b, c, z)
 
@@ -1722,6 +1806,39 @@ FunctionalSpecialFunction(R, F) : Exports == Implementation where
 
     evaluate(opMeixnerM, elMeixnerM)$BasicOperatorFunctions1(F)
 
+    meixnerP(n : F, b : F, c : F, z : F) : F == op_meixnerP(n, b, c, z)
+
+    e_meixnerP(n : F, b : F, c : F, z : F) : F ==
+        n = 0 => 1
+        kernel(op_meixnerP, [n, b, c, z])
+
+    el_meixnerP(l : List F) : F == e_meixnerP(l(1), l(2), l(3), l(4))
+
+    evaluate(op_meixnerP, el_meixnerP)$BasicOperatorFunctions1(F)
+
+
+    racahR(n : F, a : F, b : F, c : F, d : F, z : F) : F ==
+        op_racahR(n, a, b, c, d, z)
+
+    e_racahR(n : F, a : F, b : F, c : F, d : F, z : F) : F ==
+        n = 0 => 1
+        kernel(op_racahR, [n, a, b, c, d, z])
+
+    el_racahR(l: List F) : F == e_racahR(l(1), l(2), l(3), l(4), l(5), l(6))
+
+    evaluate(op_racahR, el_racahR)$BasicOperatorFunctions1(F)
+
+
+    wilsonW(n : F, a : F, b : F, c : F, d : F, z : F) : F ==
+        op_wilsonW(n, a, b, c, d, z)
+
+    e_wilsonW(n : F, a : F, b : F, c : F, d : F, z : F) : F ==
+        n = 1 => 1
+        kernel(op_wilsonW, [n, a, b, c, d, z])
+
+    el_wilsonW(l: List F) : F == e_wilsonW(l(1), l(2), l(3), l(4), l(5), l(6))
+
+    evaluate(op_wilsonW, el_wilsonW)$BasicOperatorFunctions1(F)
 
     --
     belong? op == has?(op, SPECIAL)
@@ -1789,10 +1906,18 @@ FunctionalSpecialFunction(R, F) : Exports == Implementation where
       is?(op, 'lerchPhi) => opLerchPhi
       is?(op, 'riemannZeta) => opRiemannZeta
       is?(op, 'charlierC) => opCharlierC
+      is?(op, 'hahn_p) => op_hahn_p
+      is?(op, 'hahnQ) => op_hahnQ
+      is?(op, 'hahnR) => op_hahnR
+      is?(op, 'hahnS) => op_hahnS
       is?(op, 'hermiteH) => opHermiteH
       is?(op, 'jacobiP) => opJacobiP
+      is?(op, 'krawtchoukK) => op_krawtchoukK
       is?(op, 'laguerreL) => opLaguerreL
       is?(op, 'meixnerM) => opMeixnerM
+      is?(op, 'meixnerP) => op_meixnerP
+      is?(op, 'racahR) => op_racahR
+      is?(op, 'wilsonW) => op_wilsonW
       is?(op, '%logGamma) => op_log_gamma
       is?(op, '%eis) => op_eis
       is?(op, '%erfs) => op_erfs