\begin{patch}{ugDomainsExamplesPagePatch1}
\begin{paste}{ugDomainsExamplesPageFull1}{ugDomainsExamplesPageEmpty1}
\pastebutton{ugDomainsExamplesPageFull1}{\hidepaste}
\tab{5}\spadcommand{ks := getDatabase "k"\bound{q1 }}
\indentrel{3}\begin{verbatim}
   (1)  1252
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty1}
\begin{paste}{ugDomainsExamplesPageEmpty1}{ugDomainsExamplesPagePatch1}
\pastebutton{ugDomainsExamplesPageEmpty1}{\showpaste}
\tab{5}\spadcommand{ks := getDatabase "k"\bound{q1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch2}
\begin{paste}{ugDomainsExamplesPageFull2}{ugDomainsExamplesPageEmpty2}
\pastebutton{ugDomainsExamplesPageFull2}{\hidepaste}
\tab{5}\spadcommand{[ks.(kind=k) for k in ["c","d","p"]]\bound{q3 }\free{q1 }}
\indentrel{3}\begin{verbatim}
   (2)  [269, 427, 556]
                        Type: List(Database(IndexCard))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty2}
\begin{paste}{ugDomainsExamplesPageEmpty2}{ugDomainsExamplesPagePatch2}
\pastebutton{ugDomainsExamplesPageEmpty2}{\showpaste}
\tab{5}\spadcommand{[ks.(kind=k) for k in ["c","d","p"]]\bound{q3 }\free{q1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch3}
\begin{paste}{ugDomainsExamplesPageFull3}{ugDomainsExamplesPageEmpty3}
\pastebutton{ugDomainsExamplesPageFull3}{\hidepaste}
\tab{5}\spadcommand{elt(ks.(kind="d").(nargs="5"),name)\bound{q4 }\free{q1 }}
\indentrel{3}\begin{verbatim}
   (3)
   ["FractionalIdealAsModule", "IndexedJetBundle",
    "InnerIndexedTwoDimensionalArray", "ModularField",
    "ModularRing", "RadicalFunctionField", "ResidueRing",
    "TensorProduct"]
                                 Type: DataList(String)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty3}
\begin{paste}{ugDomainsExamplesPageEmpty3}{ugDomainsExamplesPagePatch3}
\pastebutton{ugDomainsExamplesPageEmpty3}{\showpaste}
\tab{5}\spadcommand{elt(ks.(kind="d").(nargs="5"),name)\bound{q4 }\free{q1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch4}
\begin{paste}{ugDomainsExamplesPageFull4}{ugDomainsExamplesPageEmpty4}
\pastebutton{ugDomainsExamplesPageFull4}{\hidepaste}
\tab{5}\spadcommand{mk := ks.(name="*Matrix*")\bound{q5 }\free{q1 }}
\indentrel{3}\begin{verbatim}
   (4)  39
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty4}
\begin{paste}{ugDomainsExamplesPageEmpty4}{ugDomainsExamplesPagePatch4}
\pastebutton{ugDomainsExamplesPageEmpty4}{\showpaste}
\tab{5}\spadcommand{mk := ks.(name="*Matrix*")\bound{q5 }\free{q1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch5}
\begin{paste}{ugDomainsExamplesPageFull5}{ugDomainsExamplesPageEmpty5}
\pastebutton{ugDomainsExamplesPageFull5}{\hidepaste}
\tab{5}\spadcommand{elt(mk.(kind="d"),name)\bound{q6 }\free{q5 }}
\indentrel{3}\begin{verbatim}
   (5)
   ["ComplexDoubleFloatMatrix",
    "DenavitHartenbergMatrix",
    "DirectProductMatrixModule", "DoubleFloatMatrix",
    "I16Matrix", "I32Matrix", "I8Matrix",
    "IndexedMatrix", "LieSquareMatrix",
    "LinearMultivariateMatrixPencil", "Matrix",
    "RectangularMatrix", "SparseEchelonMatrix",
    "SquareMatrix", "ThreeDimensionalMatrix",
    "U16Matrix", "U32Matrix", "U8Matrix"]
                                 Type: DataList(String)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty5}
\begin{paste}{ugDomainsExamplesPageEmpty5}{ugDomainsExamplesPagePatch5}
\pastebutton{ugDomainsExamplesPageEmpty5}{\showpaste}
\tab{5}\spadcommand{elt(mk.(kind="d"),name)\bound{q6 }\free{q5 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch6}
\begin{paste}{ugDomainsExamplesPageFull6}{ugDomainsExamplesPageEmpty6}
\pastebutton{ugDomainsExamplesPageFull6}{\hidepaste}
\tab{5}\spadcommand{o := getDatabase "o"\bound{o1 }}
\indentrel{3}\begin{verbatim}
   (6)  8292
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty6}
\begin{paste}{ugDomainsExamplesPageEmpty6}{ugDomainsExamplesPagePatch6}
\pastebutton{ugDomainsExamplesPageEmpty6}{\showpaste}
\tab{5}\spadcommand{o := getDatabase "o"\bound{o1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch7}
\begin{paste}{ugDomainsExamplesPageFull7}{ugDomainsExamplesPageEmpty7}
\pastebutton{ugDomainsExamplesPageFull7}{\hidepaste}
\tab{5}\spadcommand{[o.(kind=k) for k in ["c","d","p"]]\free{o1 }}
\indentrel{3}\begin{verbatim}
   (7)  [2051, 2902, 3339]
                        Type: List(Database(IndexCard))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty7}
\begin{paste}{ugDomainsExamplesPageEmpty7}{ugDomainsExamplesPagePatch7}
\pastebutton{ugDomainsExamplesPageEmpty7}{\showpaste}
\tab{5}\spadcommand{[o.(kind=k) for k in ["c","d","p"]]\free{o1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch8}
\begin{paste}{ugDomainsExamplesPageFull8}{ugDomainsExamplesPageEmpty8}
\pastebutton{ugDomainsExamplesPageFull8}{\hidepaste}
\tab{5}\spadcommand{eigens := o.(name="*eigen*")\bound{eigens }\free{o1 }}
\indentrel{3}\begin{verbatim}
   (8)  9
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty8}
\begin{paste}{ugDomainsExamplesPageEmpty8}{ugDomainsExamplesPagePatch8}
\pastebutton{ugDomainsExamplesPageEmpty8}{\showpaste}
\tab{5}\spadcommand{eigens := o.(name="*eigen*")\bound{eigens }\free{o1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch9}
\begin{paste}{ugDomainsExamplesPageFull9}{ugDomainsExamplesPageEmpty9}
\pastebutton{ugDomainsExamplesPageFull9}{\hidepaste}
\tab{5}\spadcommand{elt(eigens,name)\free{eigens }}
\indentrel{3}\begin{verbatim}
   (9)
   ["eigenMatrix", "eigenvalues", "eigenvalues",
    "eigenvalues", "eigenvector", "eigenvector",
    "eigenvectors", "eigenvectors", "eigenvectors"]
                                 Type: DataList(String)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty9}
\begin{paste}{ugDomainsExamplesPageEmpty9}{ugDomainsExamplesPagePatch9}
\pastebutton{ugDomainsExamplesPageEmpty9}{\showpaste}
\tab{5}\spadcommand{elt(eigens,name)\free{eigens }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch10}
\begin{paste}{ugDomainsExamplesPageFull10}{ugDomainsExamplesPageEmpty10}
\pastebutton{ugDomainsExamplesPageFull10}{\hidepaste}
\tab{5}\spadcommand{elt(elt(elt(eigens,origin),sort),unique)\free{eigens }}
\indentrel{3}\begin{verbatim}
   (10)
   ["EigenPackage", "InnerEigenPackage",
    "RadicalEigenPackage"]
                                 Type: DataList(String)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty10}
\begin{paste}{ugDomainsExamplesPageEmpty10}{ugDomainsExamplesPagePatch10}
\pastebutton{ugDomainsExamplesPageEmpty10}{\showpaste}
\tab{5}\spadcommand{elt(elt(elt(eigens,origin),sort),unique)\free{eigens }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch11}
\begin{paste}{ugDomainsExamplesPageFull11}{ugDomainsExamplesPageEmpty11}
\pastebutton{ugDomainsExamplesPageFull11}{\hidepaste}
\tab{5}\spadcommand{tm := o.(type="*Matrix*")\bound{x10 }\free{o1 }}
\indentrel{3}\begin{verbatim}
   (11)  383
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty11}
\begin{paste}{ugDomainsExamplesPageEmpty11}{ugDomainsExamplesPagePatch11}
\pastebutton{ugDomainsExamplesPageEmpty11}{\showpaste}
\tab{5}\spadcommand{tm := o.(type="*Matrix*")\bound{x10 }\free{o1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch12}
\begin{paste}{ugDomainsExamplesPageFull12}{ugDomainsExamplesPageEmpty12}
\pastebutton{ugDomainsExamplesPageFull12}{\hidepaste}
\tab{5}\spadcommand{fm := o.(origin="*Matrix*")\bound{x11 }\free{o1 }}
\indentrel{3}\begin{verbatim}
   (12)  321
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty12}
\begin{paste}{ugDomainsExamplesPageEmpty12}{ugDomainsExamplesPagePatch12}
\pastebutton{ugDomainsExamplesPageEmpty12}{\showpaste}
\tab{5}\spadcommand{fm := o.(origin="*Matrix*")\bound{x11 }\free{o1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch13}
\begin{paste}{ugDomainsExamplesPageFull13}{ugDomainsExamplesPageEmpty13}
\pastebutton{ugDomainsExamplesPageFull13}{\hidepaste}
\tab{5}\spadcommand{fm-tm\bound{x12 }\free{x10 x11 }}
\indentrel{3}\begin{verbatim}
   (13)  257
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty13}
\begin{paste}{ugDomainsExamplesPageEmpty13}{ugDomainsExamplesPagePatch13}
\pastebutton{ugDomainsExamplesPageEmpty13}{\showpaste}
\tab{5}\spadcommand{fm-tm\bound{x12 }\free{x10 x11 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch14}
\begin{paste}{ugDomainsExamplesPageFull14}{ugDomainsExamplesPageEmpty14}
\pastebutton{ugDomainsExamplesPageFull14}{\hidepaste}
\tab{5}\spadcommand{fullDisplay(fm-\%)\bound{x13 }\free{x12 }}
\indentrel{3}\begin{verbatim}
   * : (Matrix(D),%)->%
      from SparseEchelonMatrix(C,D) (unexposed)
   * : (Matrix(Fraction(D)),%)->%
      from SparseEchelonMatrix(C,D)
        if has(D,IntegralDomain) (unexposed)
   * : (Matrix(R),%)->%
      from LinearMultivariateMatrixPencil(R) (unexposed)
   ^ : (Matrix(R),NonNegativeInteger)->Matrix(R)
      from StorageEfficientMatrixOperations(R) (unexposed)
   bezoutMatrix : (UP,UP)->Matrix(R)
      from BezoutMatrixWrapper(R,UP) (unexposed)
   blockElimination
      :
      (%,List(NonNegativeInteger),List(NonNegativeInteger
      ),List(NonNegativeInteger),List(NonNegativeInteger)
      ,List(NonNegativeInteger),List(NonNegativeInteger))
      ->List(Matrix(R))
      from LinearMultivariateMatrixPencil(R)
        if has(R,Field) (unexposed)
   clearDenominator : (Matrix(Q))->Matrix(R)
      from MatrixCommonDenominator(R,Q)
   coerceP
      : (Vector(Matrix(R)))->Vector(Matrix(Polynomial(R)))
      from CoerceVectorMatrixPackage(R) (unexposed)
   coerce : (%)->Matrix(D)
      from SparseEchelonMatrix(C,D) (unexposed)
   coerce : (%)->Matrix(R)
      from RectangularMatrix(m,n,R) (unexposed)
   coerce : (%)->Matrix(R)
      from SquareMatrix(ndim,R) (unexposed)
   coerce : (Matrix(MachineFloat))->%
      from FortranMatrixCategory (unexposed)
   coerce
      :
      (Vector(Matrix(R)))->Vector(Matrix(Fraction(Polynom
      ial(R))))
      from CoerceVectorMatrixPackage(R) (unexposed)
   commonDenominator : (Matrix(Q))->R
      from MatrixCommonDenominator(R,Q)
   convert : (SquareMatrix(n,R))->%
      from LieSquareMatrix(n,R)
   copy! : (Matrix(R),Matrix(R))->Matrix(R)
      from StorageEfficientMatrixOperations(R) (unexposed)
   eliminationEquations
      :
      (%,List(NonNegativeInteger),List(NonNegativeInteger
      ),List(NonNegativeInteger),List(NonNegativeInteger)
      ,List(NonNegativeInteger),List(NonNegativeInteger),
      List(NonNegativeInteger),List(NonNegativeInteger),L
      ist(NonNegativeInteger),List(NonNegativeInteger))->
      List(Matrix(Polynomial(R)))
      from LinearMultivariateMatrixPencil(R)
        if has(R,Field) (unexposed)
   eliminationEquations
      :
      (%,List(NonNegativeInteger),List(NonNegativeInteger
      ),List(NonNegativeInteger),List(NonNegativeInteger)
      ,List(NonNegativeInteger),List(NonNegativeInteger))
      ->List(Matrix(Polynomial(R)))
      from LinearMultivariateMatrixPencil(R)
        if has(R,Field) (unexposed)
   eliminationTransformations
      :
      (%,List(NonNegativeInteger),List(NonNegativeInteger
      ),List(NonNegativeInteger),List(NonNegativeInteger)
      )->List(Matrix(Polynomial(R)))
      from LinearMultivariateMatrixPencil(R)
        if has(R,Field) (unexposed)
   eliminationTransformations
      :
      (%,List(NonNegativeInteger),List(NonNegativeInteger
      ),List(NonNegativeInteger),List(NonNegativeInteger)
      ,List(Equation(Polynomial(R))))->List(Matrix(R))
      from LinearMultivariateMatrixPencil(R)
        if has(R,Field) (unexposed)
   eliminationTransformations
      :
      (%,List(NonNegativeInteger),List(NonNegativeInteger
      ),Symbol,List(NonNegativeInteger),List(NonNegativeI
      nteger),Symbol)->List(Matrix(Polynomial(R)))
      from LinearMultivariateMatrixPencil(R)
        if has(R,Field) (unexposed)
   hasSolution? : (Matrix(F),Vector(F))->Boolean
      from LinearSystemMatrixPackage1(F)
   leftIdentity : (%)->Matrix(R)
      from LinearMultivariateMatrixPencil(R) (unexposed)
   leftScalarTimes! : (Matrix(R),R,Matrix(R))->Matrix(R)
      from StorageEfficientMatrixOperations(R) (unexposed)
   matrix : (%,NonNegativeInteger)->Matrix(R)
      from LinearMultivariateMatrixPencil(R) (unexposed)
   minus! : (Matrix(R),Matrix(R))->Matrix(R)
      from StorageEfficientMatrixOperations(R) (unexposed)
   minus! : (Matrix(R),Matrix(R),Matrix(R))->Matrix(R)
      from StorageEfficientMatrixOperations(R) (unexposed)
   particularSolution
      : (Matrix(F),Vector(F))->Union(Vector(F),"failed")
      from LinearSystemMatrixPackage1(F)
   plus! : (Matrix(R),Matrix(R),Matrix(R))->Matrix(R)
      from StorageEfficientMatrixOperations(R) (unexposed)
   power!
      :
      (Matrix(R),Matrix(R),Matrix(R),Matrix(R),NonNegativ
      eInteger)->Matrix(R)
      from StorageEfficientMatrixOperations(R) (unexposed)
   primitiveRowEchelon
      :
      (%)->Record(Ech:%,Lt:Matrix(Fraction(D)),Pivots:Lis
      t(D),Rank:NonNegativeInteger)
      from SparseEchelonMatrix(C,D)
        if has(D,GcdDomain) (unexposed)
   rank : (Matrix(F),Vector(F))->NonNegativeInteger
      from LinearSystemMatrixPackage1(F)
   rectangularMatrix : (Matrix(R))->%
      from RectangularMatrix(m,n,R) (unexposed)
   retractIfCan
      : (Matrix(Expression(Float)))->Union(%,"failed")
      from FortranMatrixFunctionCategory (unexposed)
   retractIfCan
      : (Matrix(Expression(Integer)))->Union(%,"failed")
      from FortranMatrixFunctionCategory (unexposed)
   retractIfCan
      :
      (Matrix(Fraction(Polynomial(Float))))->Union(%,"fai
      led")
      from FortranMatrixFunctionCategory (unexposed)
   retractIfCan
      :
      (Matrix(Fraction(Polynomial(Integer))))->Union(%,"f
      ailed")
      from FortranMatrixFunctionCategory (unexposed)
   retractIfCan
      : (Matrix(Polynomial(Float)))->Union(%,"failed")
      from FortranMatrixFunctionCategory (unexposed)
   retractIfCan
      : (Matrix(Polynomial(Integer)))->Union(%,"failed")
      from FortranMatrixFunctionCategory (unexposed)
   retract : (Matrix(Expression(Float)))->%
      from FortranMatrixFunctionCategory (unexposed)
   retract : (Matrix(Expression(Integer)))->%
      from FortranMatrixFunctionCategory (unexposed)
   retract : (Matrix(Fraction(Polynomial(Float))))->%
      from FortranMatrixFunctionCategory (unexposed)
   retract : (Matrix(Fraction(Polynomial(Integer))))->%
      from FortranMatrixFunctionCategory (unexposed)
   retract : (Matrix(Polynomial(Float)))->%
      from FortranMatrixFunctionCategory (unexposed)
   retract : (Matrix(Polynomial(Integer)))->%
      from FortranMatrixFunctionCategory (unexposed)
   rightIdentity : (%)->Matrix(R)
      from LinearMultivariateMatrixPencil(R) (unexposed)
   rightScalarTimes! : (Matrix(R),Matrix(R),R)->Matrix(R)
      from StorageEfficientMatrixOperations(R) (unexposed)
   rowEchelon
      :
      (%)->Record(Ech:%,Lt:Matrix(D),Pivots:List(D),Rank:
      NonNegativeInteger)
      from SparseEchelonMatrix(C,D) (unexposed)
   rowEchelon : (Matrix(LO))->Matrix(LO)
      from OrePolynomialMatrixOperations(F,LO) (unexposed)
   rowEchelon
      :
      (Matrix(LO),F,List(Vector(F)))->Record(mat:Matrix(L
      O),vecs:List(Vector(F)))
      from OrePolynomialMatrixOperations(F,LO) (unexposed)
   setsubMatrix!
      :
      (%,NonNegativeInteger,NonNegativeInteger,NonNegativ
      eInteger,Matrix(R))->Matrix(R)
      from LinearMultivariateMatrixPencil(R) (unexposed)
   solveUniquely
      : (Matrix(S),Vector(S))->Union(Vector(S),"failed")
      from LinearSystemMatrixPackage2(S) (unexposed)
   solve
      :
      (Matrix(F),List(Vector(F)))->List(Record(particular
      :Union(Vector(F),"failed"),basis:List(Vector(F))))
      from LinearSystemMatrixPackage1(F)
   solve
      :
      (Matrix(F),Vector(F))->Record(particular:Union(Vect
      or(F),"failed"),basis:List(Vector(F)))
      from LinearSystemMatrixPackage1(F)
   solve
      :
      (Matrix(LO),F,List(Vector(F)),(LO,List(F))->Record(
      particular:List(Record(ratpart:F,coeffs:Vector(F)))
      ,basis:List(F)))->Union(Record(particular:List(Reco
      rd(ratpart:Vector(F),coeffs:Vector(F))),basis:List(
      Vector(F))),"failed")
      from OrePolynomialMatrixOperations(F,LO) (unexposed)
   splitDenominator
      : (Matrix(Q))->Record(num:Matrix(R),den:R)
      from MatrixCommonDenominator(R,Q)
   squareMatrix : (Matrix(R))->%
      from SquareMatrix(ndim,R) (unexposed)
   subMatrix
      :
      (%,NonNegativeInteger,NonNegativeInteger,NonNegativ
      eInteger,NonNegativeInteger,NonNegativeInteger)->Ma
      trix(R)
      from LinearMultivariateMatrixPencil(R) (unexposed)
   subSylvesterMatrix
      : (Matrix(R),NonNegativeInteger)->Matrix(R)
      from BezoutMatrixWrapper(R,UP) (unexposed)
   subSylvesterMatrix
      :
      (Matrix(R),NonNegativeInteger,NonNegativeInteger)->
      Matrix(R)
      from BezoutMatrixWrapper(R,UP) (unexposed)
   sylvesterMatrix : (UP,UP)->Matrix(R)
      from BezoutMatrixWrapper(R,UP) (unexposed)
   times! : (Matrix(R),Matrix(R),Matrix(R))->Matrix(R)
      from StorageEfficientMatrixOperations(R) (unexposed)
   transformColumns! : (%,Matrix(R))->%
      from LinearMultivariateMatrixPencil(R) (unexposed)
   transformRows! : (%,Matrix(R))->%
      from LinearMultivariateMatrixPencil(R) (unexposed)
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty14}
\begin{paste}{ugDomainsExamplesPageEmpty14}{ugDomainsExamplesPagePatch14}
\pastebutton{ugDomainsExamplesPageEmpty14}{\showpaste}
\tab{5}\spadcommand{fullDisplay(fm-\%)\bound{x13 }\free{x12 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch15}
\begin{paste}{ugDomainsExamplesPageFull15}{ugDomainsExamplesPageEmpty15}
\pastebutton{ugDomainsExamplesPageFull15}{\hidepaste}
\tab{5}\spadcommand{m := tm+fm\bound{x14 }\free{x10 x11 }}
\indentrel{3}\begin{verbatim}
   (15)  639
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty15}
\begin{paste}{ugDomainsExamplesPageEmpty15}{ugDomainsExamplesPagePatch15}
\pastebutton{ugDomainsExamplesPageEmpty15}{\showpaste}
\tab{5}\spadcommand{m := tm+fm\bound{x14 }\free{x10 x11 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch16}
\begin{paste}{ugDomainsExamplesPageFull16}{ugDomainsExamplesPageEmpty16}
\pastebutton{ugDomainsExamplesPageFull16}{\hidepaste}
\tab{5}\spadcommand{fullDisplay(m, 202, 205)\free{x14 }}
\indentrel{3}\begin{verbatim}
   eigenvectors
      :
      (Matrix(F),(SparseUnivariatePolynomial(F))->Factore
      d(SparseUnivariatePolynomial(F)))->List(Record(eigv
      al:Union(F,SparseUnivariatePolynomial(F)),eigmult:N
      onNegativeInteger,eigvec:List(Vector(SparseUnivaria
      tePolynomial(F)))))
      from InnerEigenPackage(F) (unexposed)
   elColumn2! : (M,R,Integer,Integer)->M
      from MatrixLinearAlgebraFunctions(R,Row,Col,M)
   elRow1! : (M,Integer,Integer)->M
      from MatrixLinearAlgebraFunctions(R,Row,Col,M)
   elRow2! : (M,R,Integer,Integer)->M
      from MatrixLinearAlgebraFunctions(R,Row,Col,M)
                                             Type: Void
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty16}
\begin{paste}{ugDomainsExamplesPageEmpty16}{ugDomainsExamplesPagePatch16}
\pastebutton{ugDomainsExamplesPageEmpty16}{\showpaste}
\tab{5}\spadcommand{fullDisplay(m, 202, 205)\free{x14 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPagePatch17}
\begin{paste}{ugDomainsExamplesPageFull17}{ugDomainsExamplesPageEmpty17}
\pastebutton{ugDomainsExamplesPageFull17}{\hidepaste}
\tab{5}\spadcommand{elt(elt(elt(m,name),unique),count)\free{x14 }}
\indentrel{3}\begin{verbatim}
   (17)  355
                                  Type: PositiveInteger
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsExamplesPageEmpty17}
\begin{paste}{ugDomainsExamplesPageEmpty17}{ugDomainsExamplesPagePatch17}
\pastebutton{ugDomainsExamplesPageEmpty17}{\showpaste}
\tab{5}\spadcommand{elt(elt(elt(m,name),unique),count)\free{x14 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsQueryLanguagePagePatch1}
\begin{paste}{ugDomainsQueryLanguagePageFull1}{ugDomainsQueryLanguagePageEmpty1}
\pastebutton{ugDomainsQueryLanguagePageFull1}{\hidepaste}
\tab{5}\spadcommand{ops := getDatabase("o")\bound{o1 }}
\indentrel{3}\begin{verbatim}
   (1)  8292
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsQueryLanguagePageEmpty1}
\begin{paste}{ugDomainsQueryLanguagePageEmpty1}{ugDomainsQueryLanguagePagePatch1}
\pastebutton{ugDomainsQueryLanguagePageEmpty1}{\showpaste}
\tab{5}\spadcommand{ops := getDatabase("o")\bound{o1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsQueryLanguagePagePatch2}
\begin{paste}{ugDomainsQueryLanguagePageFull2}{ugDomainsQueryLanguagePageEmpty2}
\pastebutton{ugDomainsQueryLanguagePageFull2}{\hidepaste}
\tab{5}\spadcommand{ops.(name="map").(nargs="3").(type="*Stream*")\bound{o2 }\free{o1 }}
\indentrel{3}\begin{verbatim}
   (2)  3
                              Type: Database(IndexCard)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsQueryLanguagePageEmpty2}
\begin{paste}{ugDomainsQueryLanguagePageEmpty2}{ugDomainsQueryLanguagePagePatch2}
\pastebutton{ugDomainsQueryLanguagePageEmpty2}{\showpaste}
\tab{5}\spadcommand{ops.(name="map").(nargs="3").(type="*Stream*")\bound{o2 }\free{o1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsQueryLanguagePagePatch3}
\begin{paste}{ugDomainsQueryLanguagePageFull3}{ugDomainsQueryLanguagePageEmpty3}
\pastebutton{ugDomainsQueryLanguagePageFull3}{\hidepaste}
\tab{5}\spadcommand{elt(elt(elt(elt(ops,name="determinant"),origin),sort),unique)\free{o1 }}
\indentrel{3}\begin{verbatim}
   (3)
   ["InnerMatrixLinearAlgebraFunctions",
    "MatrixCategory", "MatrixLinearAlgebraFunctions",
    "SquareMatrixCategory"]
                                 Type: DataList(String)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsQueryLanguagePageEmpty3}
\begin{paste}{ugDomainsQueryLanguagePageEmpty3}{ugDomainsQueryLanguagePagePatch3}
\pastebutton{ugDomainsQueryLanguagePageEmpty3}{\showpaste}
\tab{5}\spadcommand{elt(elt(elt(elt(ops,name="determinant"),origin),sort),unique)\free{o1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPagePatch1}
\begin{paste}{ugDomainsDemoPageFull1}{ugDomainsDemoPageEmpty1}
\pastebutton{ugDomainsDemoPageFull1}{\hidepaste}
\tab{5}\spadcommand{QF := QuadraticForm(2,Fraction Integer)\bound{x2 }\free{x1 }}
\indentrel{3}\begin{verbatim}
   (1)  QuadraticForm(2,Fraction(Integer))
                                             Type: Type
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPageEmpty1}
\begin{paste}{ugDomainsDemoPageEmpty1}{ugDomainsDemoPagePatch1}
\pastebutton{ugDomainsDemoPageEmpty1}{\showpaste}
\tab{5}\spadcommand{QF := QuadraticForm(2,Fraction Integer)\bound{x2 }\free{x1 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPagePatch2}
\begin{paste}{ugDomainsDemoPageFull2}{ugDomainsDemoPageEmpty2}
\pastebutton{ugDomainsDemoPageFull2}{\hidepaste}
\tab{5}\spadcommand{A := matrix [[-1,1/2],[1/2,1]]\bound{x3 }\free{x2 }}
\indentrel{3}\begin{verbatim}
        +     1+
        |- 1  -|
        |     2|
   (2)  |      |
        | 1    |
        | -   1|
        + 2    +
                        Type: Matrix(Fraction(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPageEmpty2}
\begin{paste}{ugDomainsDemoPageEmpty2}{ugDomainsDemoPagePatch2}
\pastebutton{ugDomainsDemoPageEmpty2}{\showpaste}
\tab{5}\spadcommand{A := matrix [[-1,1/2],[1/2,1]]\bound{x3 }\free{x2 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPagePatch3}
\begin{paste}{ugDomainsDemoPageFull3}{ugDomainsDemoPageEmpty3}
\pastebutton{ugDomainsDemoPageFull3}{\hidepaste}
\tab{5}\spadcommand{q : QF := quadraticForm(A)\bound{x4 }\free{x3 }}
\indentrel{3}\begin{verbatim}
        +     1+
        |- 1  -|
        |     2|
   (3)  |      |
        | 1    |
        | -   1|
        + 2    +
               Type: QuadraticForm(2,Fraction(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPageEmpty3}
\begin{paste}{ugDomainsDemoPageEmpty3}{ugDomainsDemoPagePatch3}
\pastebutton{ugDomainsDemoPageEmpty3}{\showpaste}
\tab{5}\spadcommand{q : QF := quadraticForm(A)\bound{x4 }\free{x3 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPagePatch4}
\begin{paste}{ugDomainsDemoPageFull4}{ugDomainsDemoPageEmpty4}
\pastebutton{ugDomainsDemoPageFull4}{\hidepaste}
\tab{5}\spadcommand{nrows q\free{x3 }}
\indentrel{3}\begin{verbatim}
error
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPageEmpty4}
\begin{paste}{ugDomainsDemoPageEmpty4}{ugDomainsDemoPagePatch4}
\pastebutton{ugDomainsDemoPageEmpty4}{\showpaste}
\tab{5}\spadcommand{nrows q\free{x3 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPagePatch5}
\begin{paste}{ugDomainsDemoPageFull5}{ugDomainsDemoPageEmpty5}
\pastebutton{ugDomainsDemoPageFull5}{\hidepaste}
\tab{5}\spadcommand{v := directProduct([2,-1])$DirectProduct(2,Fraction Integer)\bound{x5 }\free{x4 }}
\indentrel{3}\begin{verbatim}
   (4)  [2, - 1]
               Type: DirectProduct(2,Fraction(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPageEmpty5}
\begin{paste}{ugDomainsDemoPageEmpty5}{ugDomainsDemoPagePatch5}
\pastebutton{ugDomainsDemoPageEmpty5}{\showpaste}
\tab{5}\spadcommand{v := directProduct([2,-1])$DirectProduct(2,Fraction Integer)\bound{x5 }\free{x4 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPagePatch6}
\begin{paste}{ugDomainsDemoPageFull6}{ugDomainsDemoPageEmpty6}
\pastebutton{ugDomainsDemoPageFull6}{\hidepaste}
\tab{5}\spadcommand{q.v\free{x5 }}
\indentrel{3}\begin{verbatim}
   (5)  - 5
                                Type: Fraction(Integer)
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPageEmpty6}
\begin{paste}{ugDomainsDemoPageEmpty6}{ugDomainsDemoPagePatch6}
\pastebutton{ugDomainsDemoPageEmpty6}{\showpaste}
\tab{5}\spadcommand{q.v\free{x5 }}
\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPagePatch7}
\begin{paste}{ugDomainsDemoPageFull7}{ugDomainsDemoPageEmpty7}
\pastebutton{ugDomainsDemoPageFull7}{\hidepaste}
\tab{5}\spadcommand{3*q-q+q\free{x4 }}
\indentrel{3}\begin{verbatim}
        +     3+
        |- 3  -|
        |     2|
   (6)  |      |
        | 3    |
        | -   3|
        + 2    +
               Type: QuadraticForm(2,Fraction(Integer))
\end{verbatim}
\indentrel{-3}\end{paste}\end{patch}

\begin{patch}{ugDomainsDemoPageEmpty7}
\begin{paste}{ugDomainsDemoPageEmpty7}{ugDomainsDemoPagePatch7}
\pastebutton{ugDomainsDemoPageEmpty7}{\showpaste}
\tab{5}\spadcommand{3*q-q+q\free{x4 }}
\end{paste}\end{patch}

