passagemath-fricas 10.5.40__cp39-cp39-macosx_14_0_arm64.whl → 10.5.41__cp39-cp39-macosx_14_0_arm64.whl

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

@@ -285,7 +285,7 @@ SpecialFunctionCategory() : Category == with
     airyBiPrime : % -> %
         ++ airyBiPrime(x) is the derivative of the Airy function \spad{Bi(x)}.
     lambertW : % -> %
-        ++ lambertW(z) = w is the principial branch of the solution
+        ++ lambertW(z) = w is the principal branch of the solution
         ++ to the equation \spad{we^w = z}.
     polylog : (%, %) -> %
         ++ polylog(s, x) is the polylogarithm of order s at x.
@@ -395,15 +395,33 @@ SpecialFunctionCategory() : Category == with
     riemannZeta : % -> %
         ++ riemannZeta(z) is the Riemann Zeta function.
     charlierC : (%, %, %) -> %
-        ++ charlierC(n, a, z) is the Charlier polynomial
+        ++ charlierC(n, a, z) is the Charlier polynomial.
+    hahn_p : (%, %, %, %, %) -> %
+        ++ hahn_p(n, a, b, bar_a, bar_b, z) is the continuous
+        ++ Hahn polynomial.
+    hahnQ : (%, %, %, %, %) -> %
+        ++ hahnQ(n, a, b, N, z) s the Hahn polynomial.
+    hahnR : (%, %, %, %, %) -> %
+        ++ hahnR(n, c, d, N, z) is the dual Hahn polynomial.
+    hahnS : (%, %, %, %, %) -> %
+        ++ hahnS(n, a, b, c, z) is the continuous dual Hahn
+        ++ polynomial.
     hermiteH : (%, %) -> %
-        ++ hermiteH(n, z) is the Hermite polynomial
+        ++ hermiteH(n, z) is the Hermite polynomial.
     jacobiP : (%, %, %, %) -> %
-        ++ jacobiP(n, a, b, z) is the Jacobi polynomial
+        ++ jacobiP(n, a, b, z) is the Jacobi polynomial.
+    krawtchoukK : (%, %, %, %) -> %
+        ++ krawtchoukK(n, p, N, z) is the Krawtchouk polynomial.
     laguerreL: (%, %, %) -> %
-        ++ laguerreL(n, a, z) is the Laguerre polynomial
+        ++ laguerreL(n, a, z) is the Laguerre polynomial.
     meixnerM : (%, %, %, %) -> %
-        ++ meixnerM(n, b, c, z) is the Meixner polynomial
+        ++ meixnerM(n, b, c, z) is the Meixner polynomial.
+    meixnerP : (%, %, %, %) -> %
+        ++ meixnerP(n, phi, lambda, z) is the Meixner–Pollaczek polynomial.
+    racahR : (%, %, %, %, %, %) -> %
+        ++ racahR(n, a, b, c, d, z) is the Racah polynomial.
+    wilsonW : (%, %, %, %, %, %) -> %
+        ++ wilsonW(n, a, b, c, d, z) is the Wilson polynomial.
     if % has RetractableTo(Integer) then
         hypergeometricF : (List %, List %, %) -> %
             ++ hypergeometricF(la, lb, z) is the generalized hypergeometric

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

@@ -16,13 +16,13 @@
 ++ elements of \spad{S} have distinct main variables.
 ++ Note that the empty set is a triangular set. A triangular set is not
 ++ necessarily a (lexicographical) Groebner basis and the notion of
-++ reduction related to triangular sets is based on the recursive view
-++ of polynomials. We recall this notion here and refer to [1] for more details.
-++ A polynomial \spad{P} is reduced w.r.t a non-constant polynomial
+++ reduction related to triangular sets is based on the recursive view of
+++ polynomials. We recall this notion here and refer to [1] for more details.
+++ A polynomial \spad{P} is reduced with respect to a non-constant polynomial
 ++ \spad{Q} if the degree of \spad{P} in the main variable of \spad{Q}
 ++ is less than the main degree of \spad{Q}.
-++ A polynomial \spad{P} is reduced w.r.t a triangular set \spad{T}
-++ if it is reduced w.r.t. every polynomial of \spad{T}. \newline
+++ A polynomial \spad{P} is reduced with respect to a triangular set \spad{T}
+++ if it is reduced with respect to every polynomial of \spad{T}. \newline
 ++ References:
 ++  [1] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories
 ++      of Triangular Sets" Journal of Symbol. Comp. 28:105-124, 1999.
@@ -39,7 +39,7 @@ TriangularSetCategory(R : IntegralDomain, E : OrderedAbelianMonoidSup, _
      basicSet : (List P,((P,P)->Boolean)) -> Union(Record(bas:%,top:List P),"failed")
          ++ \spad{basicSet(ps, redOp?)} returns \spad{[bs, ts]} where
          ++ \spad{concat(bs, ts)} is \spad{ps} and \spad{bs}
-         ++ is a basic set in Wu Wen Tsun sense of \spad{ps} w.r.t
+         ++ is a basic set in Wu Wen Tsun sense of \spad{ps} with respect to
          ++ the reduction-test \spad{redOp?}, if no non-zero constant
          ++ polynomial lie in \spad{ps}, otherwise \spad{"failed"} is returned.
      basicSet : (List P,(P->Boolean),((P,P)->Boolean)) -> Union(Record(bas:%,top:List P),"failed")
@@ -56,37 +56,44 @@ TriangularSetCategory(R : IntegralDomain, E : OrderedAbelianMonoidSup, _
          ++ \spad{quasiComponent(ts)} returns \spad{[lp, lq]} where \spad{lp} is the list
          ++ of the members of \spad{ts} and \spad{lq}is \spad{initials(ts)}.
      normalized? : (P, %) -> Boolean
-         ++ \spad{normalized?(p, ts)} returns true iff \spad{p} and all its iterated initials
-         ++ have degree zero w.r.t. the main variables of the polynomials of \spad{ts}
+         ++ \spad{normalized?(p, ts)} returns true iff \spad{p} and all its
+         ++ iterated initials have degree zero with respect to the main
+         ++ variables of the polynomials of \spad{ts}.
      normalized? : %  -> Boolean
          ++ \spad{normalized?(ts)} returns true iff for every \spad{p} in \spad{ts} we have
          ++ \spad{normalized?(p, us)} where \spad{us} is \spad{collectUnder(ts, mvar(p))}.
      reduced? : (P, %, ((P, P) -> Boolean)) -> Boolean
-         ++ \spad{reduced?(p, ts, redOp?)} returns true iff \spad{p} is reduced w.r.t.
-         ++ in the sense of the operation \spad{redOp?}, that is if for every \spad{t} in
-         ++ \spad{ts} \spad{redOp?(p, t)} holds.
+         ++ \spad{reduced?(p, ts, redOp?)} returns true iff \spad{p} is
+         ++ reduced with respect to \spad{ts} in the sense of the operation
+         ++ \spad{redOp?}, that is if for every \spad{t} in \spad{ts}
+         ++ \spad{redOp?(p, t)} holds.
      stronglyReduced? : (P, %) -> Boolean
          ++ \spad{stronglyReduced?(p, ts)} returns true iff \spad{p}
-         ++ is reduced w.r.t. \spad{ts}.
+         ++ is reduced with respect to \spad{ts}.
      headReduced? : (P, %) -> Boolean
-         ++ \spad{headReduced?(p, ts)} returns true iff the head of \spad{p} is
-         ++ reduced w.r.t. \spad{ts}.
+         ++ \spad{headReduced?(p, ts)} returns true iff the head of \spad{p}
+         ++ is reduced \spad{ts} \spad{ts}.
      initiallyReduced? : (P, %) -> Boolean
-         ++ \spad{initiallyReduced?(p, ts)} returns true iff \spad{p} and all its iterated initials
-         ++ are reduced w.r.t. to the elements of \spad{ts} with the same main variable.
+         ++ \spad{initiallyReduced?(p, ts)} returns true iff \spad{p} and
+         ++ all its iterated initials are reduced with respect to the
+         ++ elements of \spad{ts} with the same main variable.
      autoReduced? : (%, ((P, List(P)) -> Boolean)) -> Boolean
-         ++ \spad{autoReduced?(ts, redOp?)} returns true iff every element of \spad{ts} is
-         ++ reduced w.r.t to every other in the sense of \spad{redOp?}
+         ++ \spad{autoReduced?(ts, redOp?)} returns true iff every element
+         ++ of \spad{ts} is reduced with respect to every other in the
+         ++ sense of \spad{redOp?}.
      stronglyReduced? : % -> Boolean
-         ++ \spad{stronglyReduced?(ts)} returns true iff every element of \spad{ts} is
-         ++ reduced w.r.t to any other element of \spad{ts}.
+         ++ \spad{stronglyReduced?(ts)} returns true iff every element of
+         ++ \spad{ts} is reduced with respect to any other element of
+         ++ \spad{ts}.
      headReduced? : % -> Boolean
-         ++ headReduced?(ts) returns true iff the head of every element of \spad{ts} is
-         ++ reduced w.r.t to any other element of \spad{ts}.
+         ++ headReduced?(ts) returns true iff the head of every element of
+         ++ \spad{ts} is reduced with respect to any other element of
+         ++ \spad{ts}.
      initiallyReduced? : % -> Boolean
-         ++ initiallyReduced?(ts) returns true iff for every element \spad{p} of \spad{ts}
-         ++ \spad{p} and all its iterated initials are reduced w.r.t. to the other elements
-         ++ of \spad{ts} with the same main variable.
+         ++ initiallyReduced?(ts) returns true iff for every element \spad{p}
+         ++ of \spad{ts} \spad{p} and all its iterated initials are reduced
+         ++ with respect to the other elements of \spad{ts} with the same
+         ++ main variable.
      reduce : (P, %, ((P, P) -> P), ((P, P) -> Boolean) ) -> P
          ++ \spad{reduce(p, ts, redOp, redOp?)} returns a polynomial \spad{r}  such that
          ++ \spad{redOp?(r, p)} holds for every \spad{p} of \spad{ts}
@@ -123,8 +130,8 @@ TriangularSetCategory(R : IntegralDomain, E : OrderedAbelianMonoidSup, _
          ++ holds and there exists some product \spad{h} of \spad{initials(ts)}
          ++ such that \spad{h*p - r} lies in the ideal generated by \spad{ts}.
      removeZero : (P, %) -> P
-         ++ \spad{removeZero(p, ts)} returns \spad{0} if \spad{p} reduces
-         ++ to \spad{0} by pseudo-division w.r.t \spad{ts} otherwise
+         ++ \spad{removeZero(p, ts)} returns \spad{0} if \spad{p} reduces to
+         ++ \spad{0} by pseudo-division with respect to \spad{ts} otherwise
          ++ returns a polynomial \spad{q} computed from \spad{p}
          ++ by removing any coefficient in \spad{p} reducing to \spad{0}.
      collectQuasiMonic : % -> %
@@ -485,8 +492,8 @@ TriangularSetCategory(R : IntegralDomain, E : OrderedAbelianMonoidSup, _
 ++ a domain is the following: no polynomial is constant and two distinct
 ++ polynomials have distinct main variables. Such a triangular set may
 ++ not be auto-reduced or consistent. Triangular sets are stored
-++ as sorted lists w.r.t. the main variables of their members but they
-++ are displayed in reverse order.\newline
+++ as sorted lists with respect to the main variables of their members but
+++ they are displayed in reverse order.\newline
 ++ References:
 ++  [1] P. AUBRY, D. LAZARD and M. MORENO MAZA "On the Theories
 ++      of Triangular Sets" Journal of Symbol. Comp. 28:105-124, 1999.
@@ -622,7 +629,7 @@ PolynomialSetUtilitiesPackage (R, E, V, P) : Exports == Implementation where
         ++ the one of the \spad{pj}, and no polynomial in \spad{lq}
         ++ divides another polynomial in \spad{lq}. In particular,
         ++ polynomials lying in the base ring \spad{R} are removed.
-        ++ Moreover, \spad{lq} is sorted w.r.t \spad{infRittWu?}.
+        ++ Moreover, \spad{lq} is sorted with respect to \spad{infRittWu?}.
         ++ Furthermore, if R is gcd-domain, the polynomials in \spad{lq} are
         ++ pairwise without common non trivial factor.
      removeRedundantFactors : (P, P) -> LP
@@ -737,19 +744,21 @@ PolynomialSetUtilitiesPackage (R, E, V, P) : Exports == Implementation where
      rewriteSetByReducingWithParticularGenerators : (LP, (P->B), ((P, P)->B), ((P, P)->P)) -> LP
         ++ \spad{rewriteSetByReducingWithParticularGenerators(lp, pred?, redOp?, redOp)}
         ++ returns \spad{lq} where \spad{lq} is computed by the following
-        ++ algorithm. Chose a basic set w.r.t. the reduction-test \spad{redOp?}
-        ++ among the polynomials satisfying property \spad{pred?},
-        ++ if it is empty then leave, else reduce the other polynomials by
-        ++ this basic set w.r.t. the reduction-operation \spad{redOp}.
+        ++ algorithm.  Chose a basic set with respect to the reduction-test
+        ++ \spad{redOp?} among the polynomials satisfying property
+        ++ \spad{pred?}, if it is empty then leave, else reduce the other
+        ++ polynomials by this basic set with respect to the
+        ++ reduction-operation \spad{redOp}.
         ++ Repeat while another basic set with smaller rank can be computed.
-        ++ See code. If \spad{pred?} is \spad{quasiMonic?} the ideal is unchanged.
+        ++ See code. If \spad{pred?} is \spad{quasiMonic?} the ideal is
+        ++ unchanged.
      rewriteIdealWithQuasiMonicGenerators : (LP, ((P, P)->B), ((P, P)->P)) -> LP
         ++ \spad{rewriteIdealWithQuasiMonicGenerators(lp, redOp?, redOp)} returns
         ++ \spad{lq} where \spad{lq} and \spad{lp} generate
         ++ the same ideal in \spad{R^(-1) P} and \spad{lq}
         ++ has rank not higher than the one of \spad{lp}.
         ++ Moreover, \spad{lq} is computed by reducing \spad{lp}
-        ++ w.r.t. some basic set of the ideal generated by
+        ++ with respect to some basic set of the ideal generated by
         ++ the quasi-monic polynomials in \spad{lp}.
      if R has GcdDomain
      then
@@ -769,7 +778,7 @@ PolynomialSetUtilitiesPackage (R, E, V, P) : Exports == Implementation where
           ++ \spad{removeRoughlyRedundantFactorsInContents(lp, lf)} returns
           ++ \spad{newlp}where \spad{newlp} is obtained from \spad{lp}
           ++ by removing in the content of every polynomial of \spad{lp}
-          ++ any occurence of a polynomial \spad{f} in \spad{lf}. Moreover,
+          ++ any occurrence of a polynomial \spad{f} in \spad{lf}. Moreover,
           ++ squares over \spad{R} are first removed in the content
           ++ of every polynomial of \spad{lp}.
        removeRedundantFactorsInContents : (LP, LP) -> LP
@@ -1393,7 +1402,7 @@ PolynomialSetUtilitiesPackage (R, E, V, P) : Exports == Implementation where
 ++ polynomials have distinct main variables. Such a triangular set may
 ++ not be auto-reduced or consistent. The \spadopFrom{construct}{WuWenTsunTriangularSet} operation
 ++ does not check the previous requirement. Triangular sets are stored
-++ as sorted lists w.r.t. the main variables of their members.
+++ as sorted lists with respect to the main variables of their members.
 ++ Furthermore, this domain exports operations dealing with the
 ++ characteristic set method of Wu Wen Tsun and some optimizations
 ++ mainly proposed by Dong Ming Wang.\newline
@@ -1427,21 +1436,25 @@ WuWenTsunTriangularSet(R, E, V, P) : Exports == Implementation where
 
      medialSet : (LP,((P,P)->B),((P,P)->P)) -> Union(%,"failed")
         ++ \spad{medialSet(ps, redOp?, redOp)} returns \spad{bs} a basic set
-        ++ (in Wu Wen Tsun sense w.r.t the reduction-test \spad{redOp?})
+        ++ (in Wu Wen Tsun sense with respect to the reduction-test
+        ++ \spad{redOp?})
         ++ of some set generating the same ideal as \spad{ps} (with
         ++ rank not higher than  any basic set of \spad{ps}), if no non-zero
         ++ constant polynomials appear during the computations, else
         ++ \spad{"failed"} is returned. In the former case, \spad{bs} has to be
-        ++ understood as a candidate for being a characteristic set of \spad{ps}.
-        ++ In the original algorithm, \spad{bs} is simply a basic set of \spad{ps}.
+        ++ understood as a candidate for being a characteristic set of
+        ++ \spad{ps}.
+        ++ In the original algorithm, \spad{bs} is simply a basic set of
+        ++ \spad{ps}.
      medialSet : LP -> Union(%,"failed")
         ++ \spad{medial(ps)} returns the same as
         ++ \spad{medialSet(ps, initiallyReduced?, initiallyReduce)}.
      characteristicSet : (LP,((P,P)->B),((P,P)->P)) -> Union(%,"failed")
-        ++ \spad{characteristicSet(ps, redOp?, redOp)} returns a non-contradictory
-        ++ characteristic set of \spad{ps} in Wu Wen Tsun sense w.r.t the
+        ++ \spad{characteristicSet(ps, redOp?, redOp)} returns a
+        ++ non-contradictory characteristic set of \spad{ps} in Wu Wen Tsun
+        ++ sense with respect to the
         ++ reduction-test \spad{redOp?} (using \spad{redOp} to reduce
-        ++ polynomials w.r.t a \spad{redOp?} basic set), if no
+        ++ polynomials with respect to a \spad{redOp?} basic set), if no
         ++ non-zero constant polynomial appear during those reductions,
         ++ else \spad{"failed"} is returned.
         ++ The operations \spad{redOp} and \spad{redOp?} must satisfy

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

@@ -169,7 +169,8 @@ TubePlotTools() : Exports == Implementation where
 ++ Date Created: Bastille Day 1989
 ++ Keywords:
 ++ Examples:
-++ Package for constructing tubes around 3-dimensional parametric curves.
+++ Description: Package for constructing tubes around 3-dimensional
+++  parametric curves.
 -- Currently unused.
 ExpressionTubePlot() : Exports == Implementation where
   B   ==> Boolean
@@ -343,7 +344,8 @@ ExpressionTubePlot() : Exports == Implementation where
 ++ Date Created: Bastille Day 1989
 ++ Keywords:
 ++ Examples:
-++ Package for constructing tubes around 3-dimensional parametric curves.
+++ Description: Package for constructing tubes around 3-dimensional
+++  parametric curves.
 NumericTubePlot(Curve) : Exports == Implementation where
   Curve : PlottableSpaceCurveCategory
   B   ==> Boolean

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

@@ -78,7 +78,7 @@ TwoFactorize(F) : C == T
     doFactor : (P, Integer, Boolean) -> Factored P
       ++ doFactor(p, n, ext?) returns the factorisation of polynomial p,
       ++ p is assumed to be primitive and squarefree,
-      ++ n is degree in auxilary variable, ext? if false inhibits
+      ++ n is degree in auxiliary variable, ext? if false inhibits
       ++ use of extension field.
 
   T == add

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

@@ -464,7 +464,7 @@ U32VectorPolynomialOperations() : Export == Implementation where
         vector_combination : (PA, Integer, PA, Integer, _
                                Integer, Integer, Integer) -> Void
           ++ vector_combination(v1, c1, v2, c2, n, delta, p) replaces
-          ++ first n + 1 entires of v1 by corresponding entries of
+          ++ first n + 1 entries of v1 by corresponding entries of
           ++ c1*v1+c2*x^delta*v2 mod p.
         to_mod_pa : (SparseUnivariatePolynomial Integer, Integer) -> PA
           ++ to_mod_pa(s, p) reduces coefficients of polynomial

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

@@ -416,7 +416,7 @@ UnittestAux(R : BasicType) : with
      if R has RealNumberSystem then
          testRealEqualsAux : (String, R, R) -> Void
            ++ testRealEqualsAux(inp, ex1, ex2) states that ex1 and ex2 should
-           ++ be approximately equal as real numbers, taking into acount
+           ++ be approximately equal as real numbers, taking into account
            ++ \spadfun{testAbsolutePrecision} and
            ++ \spadfun{testRelativePrecision}.
 
@@ -426,7 +426,7 @@ UnittestAux(R : BasicType) : with
 
          testComplexEqualsAux : (String, Complex R, Complex R) -> Void
            ++ testComplexEqualsAux(inp ex1, ex2) states that ex1 and ex2 should
-           ++ be approximately equal as complex numbers, taking into acount
+           ++ be approximately equal as complex numbers, taking into account
            ++ \spadfun{testAbsolutePrecision} and
            ++ \spadfun{testRelativePrecision}.
 
@@ -632,7 +632,7 @@ Unittest : with
 
      testRealEquals : (String, String) -> Void
        ++ testRealEquals(ex1, ex2) states that ex1 and ex2 should be
-       ++ approximately equal as real numbers, taking into acount
+       ++ approximately equal as real numbers, taking into account
        ++ \spadfun{testAbsolutePrecision} and \spadfun{testRelativePrecision}.
 
      xftestRealEquals : (String, String) -> Void
@@ -640,7 +640,7 @@ Unittest : with
 
      testComplexEquals : (String, String) -> Void
        ++ testComplexEquals(ex1, ex2) states that ex1 and ex2 should be
-       ++ approximately equal as complex numbers, taking into acount
+       ++ approximately equal as complex numbers, taking into account
        ++ \spadfun{testAbsolutePrecision} and \spadfun{testRelativePrecision}.
 
      xftestComplexEquals : (String, String) -> Void

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

@@ -39,7 +39,7 @@ VectorModularReconstructor() : Export == Implementation where
           ++ rational_reconstruction(x, y, i, j) finds rational function
           ++ \spad{r/s} such that \spad{r/s = y} modulo x,
           ++ \spad{degre(r) <= i}, \spad{degree(s) \leq j}.
-          ++ Returs "failed" when such \spad{r/s} does not exist.
+          ++ Returns "failed" when such \spad{r/s} does not exist.
         repack_polys : (Integer, VI, SortedExponentVector, PPA) -> PDR
           ++ repack_polys(k, offsets, exponents, coefficients) converts
           ++ polynomials represented as parallel vector of exponents in
@@ -409,7 +409,7 @@ VectorIntegerReconstructor() : Export == Implementation where
           ++ rational_reconstruction(x, y, i, j) finds rational
           ++ number \spad{r/s} such that \spad{r/s = x} modulo \spad{y},
           ++ \spad{|r| <= i} and \spad{q <= j}.
-          ++ Returs "failed" when such \spad{r/s} does not exist.
+          ++ Returns "failed" when such \spad{r/s} does not exist.
        rational_reconstruction : % -> Union(RR, "failed")
           ++ rational_reconstruction(r) reconstructs vector of rational
           ++ functions based on information stored in reconstructor.

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

@@ -64,7 +64,7 @@ GraphImage () : Exports == Implementation where
       ++ and lines from the list of lists of points, \spad{llp}, whose
       ++ point colors are indicated by the list of palette colors,
       ++ \spad{lpal1}, and whose lines are colored according to the list
-      ++ of palette colors, \spad{lpal2}.  The paramater lp is a list of
+      ++ of palette colors, \spad{lpal2}.  The parameter lp is a list of
       ++ integers which denote the size of the data points.
     makeGraphImage  :  (L L P, L PAL, L PAL, L PI, L DROP)           -> %
       ++ makeGraphImage(llp, lpal1, lpal2, lp, lopt) returns a graph of
@@ -72,7 +72,7 @@ GraphImage () : Exports == Implementation where
       ++ points and lines from the list of lists of points, \spad{llp},
       ++ whose point colors are indicated by the list of palette colors,
       ++ \spad{lpal1}, and whose lines are colored according to the list
-      ++ of palette colors, \spad{lpal2}.  The paramater lp is a list of
+      ++ of palette colors, \spad{lpal2}.  The parameter lp is a list of
       ++ integers which denote the size of the data points, and \spad{lopt}
       ++ is the list of draw command options.
     pointLists      :  %                                         -> L L P

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

@@ -61,11 +61,11 @@ ViewDefaultsPackage() : Exports == Implementation where
       ++ viewport to i.
     viewPosDefault      :  () -> L NNI
       ++ viewPosDefault() returns the default X and Y position of a
-      ++ viewport window unless overriden explicityly, newly created
+      ++ viewport window unless overridden explicitly, newly created
       ++ viewports will have this X and Y coordinate.
     viewPosDefault      :  L NNI -> L NNI
       ++ viewPosDefault([x, y]) sets the default X and Y position of a
-      ++ viewport window unless overriden explicityly, newly created
+      ++ viewport window unless overridden explicitly, newly created
       ++ viewports will have th X and Y coordinates x, y.
     viewSizeDefault : () -> L PI
       ++ viewSizeDefault() returns the default viewport width and height.
@@ -80,7 +80,7 @@ ViewDefaultsPackage() : Exports == Implementation where
     viewWriteDefault  :  L S                         -> L S
       ++ viewWriteDefault(l) sets the default list of things to write in a
       ++ viewport data file to the strings in l; a viewAlone file is always
-      ++ genereated.
+      ++ generated.
     viewWriteAvailable : ()                   -> L S
       ++ viewWriteAvailable() returns a list of available methods for writing,
       ++ such as BITMAP, POSTSCRIPT, etc.

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

@@ -24,7 +24,7 @@ ViewportPackage() : Exports == Implementation where
     graphCurves : (L L P, PAL, PAL, PI, L DROP) -> GRIMAGE
       ++ graphCurves([[p0], [p1], ..., [pn]], ptColor, lineColor, ptSize, [options])
       ++ creates a \spadtype{GraphImage} from the list of lists of points, p0
-      ++ throught pn, using the options specified in the list \spad{options}.
+      ++ through pn, using the options specified in the list \spad{options}.
       ++ The graph point color is specified by \spad{ptColor}, the graph line
       ++ color is specified by \spad{lineColor}, and the size of the points is
       ++ specified by \spad{ptSize}.
@@ -33,19 +33,19 @@ ViewportPackage() : Exports == Implementation where
       ++ the list of lists of points indicated by p0 through pn.
     graphCurves : (L L P, L DROP) -> GRIMAGE
       ++ graphCurves([[p0], [p1], ..., [pn]], [options]) creates a
-      ++ \spadtype{GraphImage} from the list of lists of points, p0 throught pn,
+      ++ \spadtype{GraphImage} from the list of lists of points, p0 through pn,
       ++ using the options specified in the list \spad{options}.
     drawCurves : (L L P, PAL, PAL, PI, L DROP) -> VIEW2D
       ++ drawCurves([[p0], [p1], ..., [pn]], ptColor, lineColor, ptSize, [options])
       ++ creates a \spadtype{TwoDimensionalViewport} from the list of lists of
-      ++ points, p0 throught pn, using the options specified in the list
+      ++ points, p0 through pn, using the options specified in the list
       ++ \spad{options}. The point color is specified by \spad{ptColor}, the
       ++ line color is specified by \spad{lineColor}, and the point size is
       ++ specified by \spad{ptSize}.
     drawCurves : (L L P, L DROP) -> VIEW2D
       ++ drawCurves([[p0], [p1], ..., [pn]], [options]) creates a
       ++ \spadtype{TwoDimensionalViewport} from the list of lists of points,
-      ++ p0 throught pn, using the options specified in the list \spad{options};
+      ++ p0 through pn, using the options specified in the list \spad{options};
     coerce : GRIMAGE -> VIEW2D
       ++ coerce(gi) converts the indicated \spadtype{GraphImage}, gi, into the
       ++ \spadtype{TwoDimensionalViewport} form.

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

@@ -257,7 +257,7 @@ VectorSpaceBasis(R : Field) : Exports == Implementation where
         -- vectors without linear relationship is a basis of the subspace
         -- spanned by theses vectors.
 
-        isBasis? Lv == (rank Lv = # Lv)
+        isBasis?(Lv) == rank(basis(Lv)) = #Lv
 
         -- dimension theory justifies these tests for inclusion
         -- and equality of spaces.
@@ -284,18 +284,18 @@ VectorSpaceBasis(R : Field) : Exports == Implementation where
         -- and looks for vectors to complete a basis of the vector space.
         -- The last reverse call makes order the result in the order of bc.
 
-        complementSpace (Lv : List Vector R) : % ==
-          Lv = [] =>
-            error
-              "Can't get vector length of an empty family for complementSpace"
-          dim := #(Lv.1)
+        do_complement(lv : List(Vector(R)), dim : NonNegativeInteger,
+                      is_basis? : Boolean) : % ==
           bc : List Vector R := (canonicalBasis dim)::List Vector R
-          Lw : List Vector R := concat (Lv, bc)
+          Lw : List(Vector(R)) := concat(lv, bc)
           M := rowEchelon column2matrix Lw
-          n := #Lv
+          n := #lv
           ind : NonNegativeInteger := 1
-          for k in 1..n for v in Lw repeat
-            if ind <= dim and M.(ind, k) ~= 0 then ind := ind+1
+          if is_basis? then
+              ind := n + 1
+          else
+              for k in 1..n for v in Lw repeat
+                  if ind <= dim and M.(ind, k) ~= 0 then ind := ind + 1
           RES := []
           for k in n+1..n+dim for v in bc repeat
             if ind <= dim and M.(ind, k)~=0
@@ -304,10 +304,16 @@ VectorSpaceBasis(R : Field) : Exports == Implementation where
                 ind := ind+1
           reverse! RES
 
+        complementSpace (Lv : List Vector R) : % ==
+          Lv = [] => error
+              "Can't get vector length of an empty family for complementSpace"
+          do_complement(Lv, #(Lv.1), false)
+
         complementSpace (Lv : List Vector R, n : NonNegativeInteger) : % ==
-          Lv = [] => canonicalBasis n
-          n ~= #(Lv.1) => error "Inconsistant vector length in complementSpace"
-          complementSpace Lv
+            Lv = [] => canonicalBasis n
+            n ~= #(Lv.1) => error
+                              "Inconsistant vector length in complementSpace"
+            do_complement(Lv, n, false)
 
         -- the argument B is a basis, computation is a little easier.
 
@@ -316,23 +322,12 @@ VectorSpaceBasis(R : Field) : Exports == Implementation where
             error
               "Can't get vector length of an empty basis for complement Space"
           dim := #(B.1)
-          bc : List Vector R := (canonicalBasis dim)::List Vector R
-          Lw : List Vector R := concat (B::List Vector R, bc)
-          M := rowEchelon column2matrix Lw
-          n := #B
-          ind : NonNegativeInteger := n+1
-          RES := []
-          for k in n+1..n+dim for v in bc repeat
-            if ind <= dim and M.(ind, k) ~= 0
-              then
-                RES := cons (v, RES)
-                ind := ind+1
-          reverse! RES
+          do_complement(B::Rep, #(B.1), true)
 
         complementSpace (B : %, n : NonNegativeInteger) : % ==
           B = [] => canonicalBasis n
           n ~= #(B.1) => error "Inconsistant vector length in complementSpace"
-          complementSpace B
+          do_complement(B::Rep, n, true)
 
         -- member?, coordinatesIfCan and coordinates test if a vector is
         -- in a subspace and consider it.

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

@@ -1,16 +1,7 @@
 )abbrev domain XHASHTBL XHashTable
 )if LiterateDoc
 \documentclass{article}
-\usepackage{url}
-\usepackage{color}
-\definecolor{bgcode}{rgb}{1,1,0.7}
-
-\usepackage{listings}
-\lstdefinelanguage{spad}{basicstyle=\footnotesize\ttfamily,%
-  numbers=left,firstnumber=last,backgroundcolor=\color{bgcode}}
-\parindent0pt
-\parskip\medskipamount
-
+\usepackage{literatedoc}
 \begin{document}
 \title{A hash table implementation via double hashing}
 \author{Ralf Hemmecke}
@@ -45,7 +36,7 @@ respectively. \texttt{VACANT} and \texttt{DELETED} should not be part
 of the key space.
 
 Let's assume that the type of the marker values is \texttt{Marker}.
-Naively, and type correctly, we would have to use as representation
+Naively, and type correctly, we would have to use a representation
 like the following.
 \begin{verbatim}
 Union(Marker, Record(key: Key, entry: Entry))
@@ -111,6 +102,8 @@ XHashTable(Key: Hashable, Entry: Type):
       ++ the sense that from k1=k2 follows h(k1)=h(k2). If that is not
       ++ the case, k1 and k2 will internally be considered as being
       ++ different keys.
+      ++ For XHashTable to work correctly, the function h must only
+      ++ yield non-negative values.
  == add
     KE ==> Record(key: Key, entry: Entry)
     UE ==> Union(Entry, "failed")
@@ -341,9 +334,9 @@ stored and thus the loops eventually terminate.
             mk := getMKey(a, p)
 
         n: Z := numOfBuckets a
-        h1: Z := (h k)::Z
-        p: Z := positiveRemainder(h1, n) -- position in array
-        h2: Z := 1 + positiveRemainder(h1, n-2)
+        h1: Z := (h k)::Z -- h1>=0
+        p: Z := h1 rem n -- position in array (p>=0)
+        h2: Z := 1 + (h1 rem (n-2)) -- h2>=0
         mk: MKey := getMKey(a, p)
         deletedPosition?: Boolean := false
         while not vacant? mk repeat

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

@@ -30,8 +30,9 @@ FreeMagma(VarSet : OrderedSet) : Public == Private where
       length        : % -> PositiveInteger
         ++ \spad{length(x)} returns the number of entries in \spad{x}.
       lexico        : (%, %) -> Boolean
-        ++ \spad{lexico(x, y)} returns \spad{true} iff  \spad{x} is smaller than
-        ++ \spad{y} w.r.t. the lexicographical ordering induced by \spad{VarSet}.
+        ++ \spad{lexico(x, y)} returns \spad{true} iff  \spad{x} is smaller
+        ++ than\spad{y} with respect to the lexicographical ordering induced
+        ++ by \spad{VarSet}.
         ++ N.B. This operation does not take into account the tree structure of
         ++ its arguments. Thus this is not a total ordering.
       mirror        : % -> %
@@ -151,10 +152,11 @@ FreeMagma(VarSet : OrderedSet) : Public == Private where
 ++ Lyndon words over arbitrary (ordered) symbols:
 ++ see Free Lie Algebras by C. Reutenauer (Oxford science publications).
 ++ A Lyndon word is a word which is smaller than any of its right factors
-++ w.r.t. the pure lexicographical ordering.
+++ with respect to the pure lexicographical ordering.
 ++ If \spad{a} and \spad{b} are two Lyndon words such that \spad{a < b}
-++ holds w.r.t lexicographical ordering then \spad{a*b} is a Lyndon word.
-++ Parenthesized Lyndon words can be generated from symbols by using the following
+++ holds with respect to lexicographical ordering then \spad{a*b} is a
+++ Lyndon word.  Parenthesized Lyndon words can be generated from symbols
+++ by using the following
 ++ rule: \spad{[[a, b], c]} is a Lyndon word iff \spad{a*b < c <= b} holds.
 ++ Lyndon words are internally represented by binary trees using the
 ++ \spadtype{FreeMagma} domain constructor.
@@ -182,8 +184,9 @@ LyndonWord(VarSet : OrderedSet) : Public == Private where
       length :  % -> PI
         ++ \spad{length(x)} returns the number of entries in \spad{x}.
       lexico :  (%, %) -> Boolean
-        ++ \spad{lexico(x, y)} returns \spad{true} iff  \spad{x} is smaller than
-        ++ \spad{y} w.r.t. the lexicographical ordering induced by \spad{VarSet}.
+        ++ \spad{lexico(x, y)} returns \spad{true} iff  \spad{x} is smaller
+        ++ than \spad{y} with respect to the lexicographical ordering
+        ++ induced by \spad{VarSet}.
       coerce :  % -> OFMON
         ++ \spad{coerce(x)} returns the element of \spadtype{FreeMonoid}(VarSet)
         ++ corresponding to \spad{x}.

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

@@ -27,10 +27,15 @@ XPolynomialFactor(vl : OrderedSet, F : Field) : Exports == Implementation where
        ++ is of minimal possible degree and homogeneous part of
        ++ of r of maximal degree contains no terms divisible from
        ++ left by leading term of b.
+    rdivide : (XDP, XDP) -> d_rec
+       ++ ldivide(a, b) returns [c, r] such that a = c*b + r, r is
+       ++ is of minimal possible degree and homogeneous part of
+       ++ of r of maximal degree contains no terms divisible from
+       ++ right by leading term of b.
     if F has PolynomialFactorizationExplicit then
         factor : XDP -> List(XDP)
            ++ factor(p) returns a factorization of p into irreducible
-           ++ factors.  Note: in general thare are finitely many
+           ++ factors.  Note: in general there are finitely many
            ++ nonequivalent factorizations into irreducible factors,
            ++ this routine returns only one.
   Implementation ==> add
@@ -77,6 +82,22 @@ XPolynomialFactor(vl : OrderedSet, F : Field) : Exports == Implementation where
             ndx = dx or ndx < dy => return [qq, x]
             dx := ndx
 
+    rdivide(x : XDP, y : XDP) : d_rec ==
+        w := maxdeg(y)
+        ilc := 1/leadingCoefficient(y)
+        dy := degree(y)
+        dx := my_degree(x)
+        dx < dy => [0, x]
+        qq := 0$XDP
+        repeat
+            tx := top_split(x)
+            q1 := ilc*rquo(first(tx), w)
+            x := x - q1*y
+            qq := qq + q1
+            ndx := my_degree(x)
+            ndx = dx or ndx < dy => return [qq, x]
+            dx := ndx
+
     lexquo(x : XDP, y : XDP) : Union(XDP, "failed") ==
         (q, r) := ldivide(x, y)
         r = 0 => q