Permalink
Commits on Nov 16, 2016
  1. books/bookvol5,9 add Signatures chapter

    Goal: Axiom Proofs
    
    There is a new chapter containing the collection of
    signatures of functions with hyperlinks. These will
    be used to verify the match between function calls.
    committed Nov 16, 2016
Commits on Nov 14, 2016
  1. faq, readme: minor cleanup edits

    Goal: Axiom Maintenance
    committed Nov 14, 2016
Commits on Nov 13, 2016
  1. books/bookvol9 compiler cleanup, remove unused aldor refs

    Goal: Axiom Maintenance
    committed Nov 13, 2016
  2. books/bookvolbug bug 7322: )co dh )constructor DHMATRIX )functions id…

    …entity
    
    Goal: Axiom Maintenance
    \begin{verbatim}
    )co dh )constructor DHMATRIX )functions identity
    
       Compiling AXIOM source code from dh.spad
       DHMATRIX abbreviates domain DenavitHartenbergMatrix
       processing macro definition minrow ==> One
       processing macro definition mincolumn ==> One
       processing macro definition nx ==> ::(x(One,One),R)
       processing macro definition ny ==> ::(x(2,One),R)
       processing macro definition nz ==> ::(x(3,One),R)
       processing macro definition ox ==> ::(x(One,2),R)
       processing macro definition oy ==> ::(x(2,2),R)
       processing macro definition oz ==> ::(x(3,2),R)
       processing macro definition ax ==> ::(x(One,3),R)
       processing macro definition ay ==> ::(x(2,3),R)
       processing macro definition az ==> ::(x(3,3),R)
       processing macro definition px ==> ::(x(One,4),R)
       processing macro definition py ==> ::(x(2,4),R)
       processing macro definition pz ==> ::(x(3,4),R)
       processing macro definition row ==> Vector R
       processing macro definition col ==> Vector R
       processing macro definition radians ==> /(pi,180)
       processing macro definition SIG ==> -- the constructor category
       processing macro definition CODE ==> -- the constructor capsule
    ------------------------------------------------------------------------
       initializing nrlib DHMATRIX for DenavitHartenbergMatrix
       compiling into nrlib DHMATRIX
    ****** Domain: R already in scope
       compiling exported identity : () -> $
    
    Error: ERROR "Caught fatal error [memory may be damaged]"
    Fast links are on: do (si::use-fast-links nil) for debugging
    Signalled by |COMPILERDOITWITHSCREENEDLISPLIB|.
    ERROR "Caught fatal error [memory may be damaged]"
    
    Broken at APPLY.  Type :H for Help.
        1  Return to top level.
    BOOT>>
    
    \end{verbatim}
    committed Nov 13, 2016
Commits on Nov 8, 2016
  1. books/bookvolbib Add Unums 2.0 An Interview with John L. Gustafson

    Goal: Axiom Literate Programming
    
    \index{Gustafson, John}
    \begin{chunk}{axiom.bib}
    @article{Gust16b,
      author = "Gustafson, John",
      title = "Unums 2.0 An Interview with John L. Gustafson",
      publisher = "ACM",
      journal = "Ubiquity",
      year = "2016",
      paper = "Gust16b.pdf"
    }
    
    \end{chunk}
    committed Nov 8, 2016
Commits on Nov 6, 2016
  1. books/bookvol10.3 FPARFRAC remove dangling +

    Goal: Axiom Maintenance / update credit list
    
    Apply Qian Yun bug patch. Fix
    
    fullPartialFraction((1/18)::FRAC SUP FRAC INT
    committed Nov 6, 2016
Commits on Nov 5, 2016
  1. src/axiom-website/documentation.html add quotes

    Goal: Axiom Maintenance
    
    The fundamental purpose of scientific discourse is not the mere presentation
    of information and thought, but rather its actual communication.
    -- George Gopen and Judith Swan
    
    Literate programming ... because yourself from the past does not answer emails.
    -- Tim Daly
    
    ...design of systems of computer algebra not getting the recognition
    they deserve in terms of the object-oriented community. I should say
    that the models that Scratchpad and later Axiom had abouy abstraction
    are, in my view, superior to all the models that have appeared of
    object-orientation.
    -- Gaston Gonnet [Gonn05]
    
    I think that that's the big contribution of computer algebra --
    making the knowledge of lots of mathematicins that worked for a
    long time but have put all their results in journals that are
    very difficult to extract and to find, putting it at the fingertips
    of everybody. I think that that's one of the most important contributions.
    -- Gaston Gonnet [Gonn05]
    committed Nov 5, 2016
  2. books/bookvolbib add Gonnet reference

    Goal: Axiom Literate Programming
    
    \index{Gonnet, Gaston}
    \index{Haigh, Thomas}
    \begin{chunk}{axiom.bib}
    @misc{Gonn05,
      author = "Gonnet, Gaston and Haigh, Thomas",
      title = "An Interview with Gaston Gonnet",
      year = "2005",
      publisher = "SIAM",
      url = "http://history.siam.org/pdfs2/Gonnet_final.pdf",
      abstract =
        "Born in Uruguay, Gonnet was first exposed to computers while working
        for IBM in Montevideo as a young man. This led him to a position at
        the university computer center, and in turn to an undergraduate degree
        in computer science in 1973. In 1974, following a military coup, he
        left for graduate studies in computer science at the University of
        Waterloo. Gonnet earned an M.Sc. and a Ph.D. in just two and a half
        years, writing a thesis on the analysis of search algorithms under the
        supervision of Alan George. After one year teaching in Rio de Janeiro
        he returned to Waterloo, as a faculty member.
    
        In 1980, Gonnet began work with a group including Morven Gentleman and
        Keith Geddes to produce an efficient interactive computer algebra
        system able to work well on smaller computers: Maple. Gonnet discusses
        in great detail the goals and organization of the Maple project, its
        technical characteristics, the Maple language and kernel, the Maple
        library, sources of funding, the contributions of the various team
        members, and the evolution of the system over time. He compares the
        resulting system to MACSYMA, Mathematica, Reduce, Scratchpad and other
        systems. Gonnet also examines the licensing and distribution of Maple
        and the project’s relations to its users. Maple was initially used for
        teaching purposes within the university, but soon found users in other
        institutions. From 1984, distribution was handled by Watcom, a company
        associated with the university, and 1988, Gonnet and Geddes created a
        new company, Waterloo Maple Software, Inc. to further commercialize
        Maple, which established itself as the leading commercial computer
        algebra system. However, during the mid-1990s the company ran into
        trouble and disagreements with his colleagues caused Gonnet to
        withdraw from managerial involvement. Since then, he feels that Maple
        has lost its battle with Mathematica. Gonnet also discusses Maple’s
        relation to Matlab and its creator, Cleve Moler.
    
        From 1984 onward with Frank Tompa, Tim Bray, and other Waterloo
        colleagues, Gonnet worked on the production of computer software to
        support the creation of the second edition of the Oxford English
        Dictionary. This led to the creation of another startup company, Open
        Text, producing software for the searching and indexing of textual
        information within large corporations. Gonnet explains his role in the
        firm, including his departure and his feeling that it made a strategic
        blunder by not exploiting its early lead in Internet search.
    
        Gonnet continued to work in a number of areas of computer science,
        including analysis of algorithms. In 1990, Gonnet moved from Waterloo
        to ETH in Switzerland. Among his projects since then have been Darwin,
        a bioinformatics system for the manipulation of genetic data, and
        leadership of the OpenMath project to produce a standard
        representation for mathematical objects. He has been involved in
        several further startup companies, including Aruna, a relational
        database company focused on business intelligence applications.",
      keywords = "axiomref",
      paper = "Gonn05.pdf"
    }
    
    \end{chunk}
    committed Nov 5, 2016
Commits on Oct 31, 2016
  1. books/bookvol10.4 update references

    Goal: Axiom Literate Programming
    
    \index{Corless, Robert M.}
    \index{Gianni, Patrizia, M.}
    \index{Trager, Barry M.}
    \index{Watt, Stephen M.}
    \begin{chunk}{axiom.bib}
    @inproceedings{Corl95,
      author = "Corless, Robert M. and Gianni, Patrizia, M. and Trager, Barry M.
                and Watt, Stephen M.",
      title = "The Singular Value Decomposition for Polynomial Systems",
      booktitle = "ISSAC 95",
      year = "1995",
      pages = "195-207",
      publisher = "ACM",
      abstract =
        "This paper introduces singular value decomposition (SVD) algorithms
        for some standard polynomial computations, in the case where the
    
        coefficients are inexact or imperfectly known. We first give an
        algorithm for computing univariate GCD's which gives {\sl exact}
        results for interesting {\sl nearby} problems, and give efficient
        algorithms for computing precisely how nearby. We generalize this to
        multivariate GCD computations. Next, we adapt Lazard's $u$-resultant
        algorithm for the solution of overdetermined systems of polynomial
        equations to the inexact-coefficent case. We also briefly discuss an
        application of the modified Lazard's method to the location of
        singular points on approximately known projections of algebraic curves.",
      paper = "Corl95.pdf",
      keywords = "axiomref",
    }
    
    \end{chunk}
    
    \index{Lazard, Daniel}
    \begin{chunk}{axiom.bib}
    @article{Laza92,
      author = "Lazard, Daniel",
      title = "Solving Zero-dimensional Algebraic Systems",
    Journal of Symbolic Computation, 1992, 13, 117-131
      journal = "J. of Symbolic Computation",
      volume = "13",
      pages = "117-131",
      year = "1992",
      abstract =
        "It is shown that a good output for a solver of algebraic systems of
         dimension zero consists of a family of ``triangular sets of
         polynomials''. Such an output is simple, readable, and consists
         of all information which may be wanted.
    
         Different algorithms are described for handling triangular systems
         and obtaining them from Groebner bases. These algorithms are
         practicable, and most of them are polynomial in the number of
         solutions",
      paper = "Laza92.pdf"
    }
    committed Oct 31, 2016
Commits on Oct 30, 2016
  1. books/bookvol5 Add chapter Type Inference and Coercion

    Goal: Axiom Literate Programming
    
    \index{Jenks, Richard D.}
    \begin{chunk}{axiom.bib}
    @techreport{Jenk86c,
      author = "Jenks, Richard D.",
      title = "A History of the SCRATCHPAD Project (1977-1986)",
      institution = "IBM Research",
      year = "1986",
      month = "May",
      type = "Scratchpad II Newsletter",
      volume = "1",
      number = "3",
    }
    
    \end{chunk}
    
    \index{Liskov, Barbara}
    \index{Atkinson, Russ}
    \index{Bloom, Toby}
    \index{Moss, Eliot}
    \index{Schaffert, Craig}
    \index{Scheifler, Bob}
    \index{Snyder, Alan}
    \begin{chunk}{axiom.bib}
    @techreport{Lisk79,
      author = "Liskov, Barbara and Atkinson, Russ and Bloom, Toby and
                Moss, Eliot and Schaffert, Craig and Scheifler, Bob and
                Snyder, Alan",
      title = "CLU Reference Manual",
      institution = "Massachusetts Institute of Technology",
      year = "1979",
      paper = "Lisk79.pdf"
    }
    
    \end{chunk}
    
    \index{Schaffert, C.}
    \index{Cooper, T.}
    \begin{chunk}{axiom.bib}
    @article{Scha86,
      author = "Schaffert, C. and Cooper, T.",
      title = "An Introduction to Trellis/Owl",
      journal = "SIGPLAN Notices",
      volume = "21",
      number = "11",
      publisher = "ACM",
      year = "1986",
      pages = "9-16"
    }
    
    \end{chunk}
    
    \index{Sweedler, Moss E.}
    \begin{chunk}{axiom.bib}
    @techreport{Swee86,
      author = "Sweedler, Moss E.",
      title = "Typing in Scratchpad II",
      institution = "IBM Research",
      year = "1986",
      month = "January",
      type = "Scratchpad II Newsletter",
      volume = "1",
      number = "2",
    }
    
    \end{chunk}
    committed Oct 30, 2016
Commits on Oct 25, 2016
  1. books/bookvol10.1 Finite Fields in Axiom fix citations

    Goal: Axiom Literate Programming
    committed Oct 25, 2016
Commits on Oct 24, 2016
  1. books/bookvol10.1 Finite Fields in Axiom by Grabmeier/Scheerhorn

    Goal: Axiom Literate Programming
    
    \section{Finite Fields} %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    
    \index{Ash, D.W.}
    \index{Black, I.F.}
    \index{Vanstone, S.A.}
    \begin{chunk}{axiom.bib}
    @article{Ashx89,
      author = "Ash, D.W. and Black, I.F. and Vanstone, S.A.",
      title = "Low Complexity Normal Bases",
      journal = "Discrete Applied Mathematics",
      volume = "25",
      pages = "191-210",
      year = "1989"
    }
    
    \end{chunk}
    
    \index{Beth, T.}
    \index{Geiselmann, W.}
    \index{Meyer, F.}
    \begin{chunk}{axiom.bib}
    @article{Beth91,
      author = "Beth, T. and Geiselmann, W. and Meyer, F.",
      title = "Finding (Good) Normal Bases in Finite Fields",
      journal = "Proc. ISSAC '91",
      year = "1991"
    }
    
    \end{chunk}
    
    \index{Gathen, J. von zur}
    \index{Giesbrecht, M.}
    \begin{chunk}{axiom.bib}
    @article{Gath90,
      author = "Gathen, J. von zur and Giesbrecht, M.",
      title =  "Constructing normal bases in finite fields",
      journal = "J. Symb. Comp.",
      volume = "10",
      pages = "547-570",
      year = "1990"
    }
    
    \end{chunk}
    
    \index{Geiselmann, W.}
    \index{Gollmann, D.}
    \begin{chunk}{axiom.bib}
    @article{Geis89,
      author = "Geiselmann, W. and Gollmann, D.",
      title = "Symmetry and Duality in Normal Basis Multiplication",
      journal = "Proc. AAECC-6, LNCS",
      volume = "357",
      year = "1989"
    }
    
    \end{chunk}
    
    \index{Huber, K.}
    \begin{chunk}{axiom.bib}
    @article{Hube90,
      author = "Huber, K.",
      title = "Some Comments on Zech's Logarithm",
      journal = "IEEE Trans. Information Theory",
      volume = "IT-36",
      pages = "946-950",
      year = "1990"
    }
    
    \end{chunk}
    
    \index{InnerNormalBasisFieldFunctions}
    \index{Itoh, T.}
    \index{Tsujii, S.}
    \begin{chunk}{axiom.bib}
    @article{Itoh88,
      author = "Itoh, T. and Tsujii, S.",
      title = "A fast algorithm for computing multiplicative inverses in
               $GF(2^m)$ using normal bases",
      journal = "Inf. and Comp.",
      volume = "78",
      pages = "171-177",
      year = "1988",
      algebra = "\newline\refto{package INBFF InnerNormalBasisFieldFunctions}",
      abstract =
        "This paper proposes a fast algorithm for computing multiplicative
        inverses in $GF(2^m)$ using normal bases. Normal bases have the
        following useful property: In the case that an element $x$ in
        $GF(2^m)$ is represented by normal bases, $2^k$ power operation of an
        element $x$ in $GF(2^m)$ can be carried out by $k$ times cyclic shift
        of its vector representation.  C.C. Wang et al. proposed an algorithm
        for computing multiplicative inverses using normal bases, which
        requires $(m-2)$ multiplications in $GF(2^m)$ and $(m-1)$ cyclic
        shifts. The fast algorithm proposed in this paper also uses normal
        bases, and computes multiplicative inverses iterating multiplications
        in $GF(2^m)$. It requires at most $2[log_2(m-1)]$ multiplications in
        $GF(2^m)$ and $(m-1)$ cyclic shifts, which are much less than those
        required in Wang's method. The same idea of the proposed fast
        algorithm is applicable to the general power operation in $GF(2^m)$
        and the computation of multiplicative inverses in $GF(q^m)$
        $(q=2^n)$.",
      paper = "Itoh88.pdf"
    }
    
    \end{chunk}
    
    \index{Jacobson, N.}
    \begin{chunk}{axiom.bib}
    @book{Jaco85,
      author = "Jacobson, N.",
      title = "Basic Algebra I, 2nd ed.",
      publisher = "W.H. Freeman and Co.",
      year = "1985"
    }
    
    \end{chunk}
    
    \index{Lenstra, A.K.}
    \begin{chunk}{axiom.bib}
    @article{Lens82,
      author = "Lenstra, A.K.",
      title = "Factorization of Polynomials, Comp. Methods in Number Theory
               (part 1)",
      journal = "Math. Centre Tracts",
      volume = "154",
      year = "1982"
    }
    
    \end{chunk}
    
    \index{Lenstra Jr., H.W.}
    \begin{chunk}{axiom.bib}
    @article{Lens91,
      author = "Lenstra Jr., H.W.",
      title = "Finding Isomorphisms between Finite Fields",
      journal = "Math. of Comp.",
      volume = "56",
      number = "193",
      pages = "329-347",
      year = "1991"
    }
    
    \end{chunk}
    
    \index{Lenstra Jr., H.W.}
    \index{Schoof, R.J.}
    \begin{chunk}{axiom.bib}
    @article{Lens87,
      author = "Lenstra Jr., H.W. and Schoof, R.J.",
      title = "Primitive Normal Bases for Finite Fields",
      journal = "Math. of Comp.",
      volume = "48",
      number = "177",
      pages = "217-231",
      year = "1987"
    }
    
    \end{chunk}
    
    \index{Lidl, R.}
    \index{Niederreiter, H.}
    \begin{chunk}{axiom.bib}
    @book{Lidl83,
      author = "Lidl, R. and Niederreiter, H.",
      title = "Finite Fields",
      publisher = "Addison-Wesley",
      volume = "20",
      year = "1983"
    }
    
    \end{chunk}
    
    \index{FiniteFieldCategory}
    \index{Lipson, John D.}
    \begin{chunk}{axiom.bib}
    @book{Lips81,
      author = "Lipson, John D.",
      title = "Elements of Algebra and Algebraic Computing",
      publisher = "Addison-Wesley Educational Publishers",
      year = "1981",
      isbn = "978-0201041156",
      algebra = "\newline\refto{category FFIELDC FiniteFieldCategory}"
    }
    
    \end{chunk}
    
    \index{L\"uneburg, H}
    \begin{chunk}{axiom.bib}
    @misc{Lune87,
      author = {L\"uneburg, H},
      title = "On the Rational Normal Form of Endomorphisms",
      comment = "BI-Wissenschaftsverlag",
      year = "1987"
    }
    
    \end{chunk}
    
    \index{CharacteristicNonZero}
    \index{FieldOfPrimeCharacteristic}
    \index{ExtensionField}
    \index{FiniteFieldCategory}
    \index{FiniteAlgebraicExtensionField}
    \index{SimpleAlgebraicExtension}
    \index{InnerPrimeField}
    \index{PrimeField}
    \index{FiniteFieldExtensionByPolynomial}
    \index{FiniteFieldCyclicGroupExtensionByPolynomial}
    \index{FiniteFieldNormalBasisExtensionByPolynomial}
    \index{FiniteFieldExtension}
    \index{FiniteFieldCyclicGroupExtension}
    \index{FiniteFieldNormalBasisExtension}
    \index{InnerFiniteField}
    \index{FiniteField}
    \index{FiniteFieldCyclicGroup}
    \index{FiniteFieldNormalBasis}
    \index{DiscreteLogarithmPackage}
    \index{FiniteFieldFunctions}
    \index{InnerNormalBasisFieldFunctions}
    \index{FiniteFieldPolynomialPackage}
    \index{FiniteFieldPolynomialPackage2}
    \index{FiniteFieldHomomorphisms}
    \index{FiniteFieldFactorizationWithSizeParseBySideEffect}
    \index{Grabmeier, Johannes}
    \index{Scheerhorn, Alfred}
    \begin{chunk}{axiom.bib}
    @techreport{Grab92,
      author = "Grabmeier, Johannes and Scheerhorn, Alfred",
      title = "Finite fields in Axiom",
      type = "technical report",
      number = "AXIOM Technical Report TR7/92 (ATR/5)(NP2522)",
      institution = "Numerical Algorithms Group, Inc.",
      address = "Downer's Grove, IL, USA and Oxford, UK",
      year = "1992",
      url = "http://www.nag.co.uk/doc/TechRep/axiomtr.html",
      algebra =
       "\newline\refto{category CHARNZ CharacteristicNonZero}
        \newline\refto{category FPC FieldOfPrimeCharacteristic}
        \newline\refto{category XF ExtensionField}
        \newline\refto{category FFIELDC FiniteFieldCategory}
        \newline\refto{category FAXF FiniteAlgebraicExtensionField}
        \newline\refto{domain SAE SimpleAlgebraicExtension}
        \newline\refto{domain IPF InnerPrimeField}
        \newline\refto{domain PF PrimeField}
        \newline\refto{domain FFP FiniteFieldExtensionByPolynomial}
        \newline\refto{domain FFCGP FiniteFieldCyclicGroupExtensionByPolynomial}
        \newline\refto{domain FFNBP FiniteFieldNormalBasisExtensionByPolynomial}
        \newline\refto{domain FFX FiniteFieldExtension}
        \newline\refto{domain FFCGX FiniteFieldCyclicGroupExtension}
        \newline\refto{domain FFNBX FiniteFieldNormalBasisExtension}
        \newline\refto{domain IFF InnerFiniteField}
        \newline\refto{domain FF FiniteField}
        \newline\refto{domain FFCG FiniteFieldCyclicGroup}
        \newline\refto{domain FFNB FiniteFieldNormalBasis}
        \newline\refto{package DLP DiscreteLogarithmPackage}
        \newline\refto{package FFF FiniteFieldFunctions}
        \newline\refto{package INBFF InnerNormalBasisFieldFunctions}
        \newline\refto{package FFPOLY FiniteFieldPolynomialPackage}
        \newline\refto{package FFPOLY2 FiniteFieldPolynomialPackage2}
        \newline\refto{package FFHOM FiniteFieldHomomorphisms}
        \newline\refto
            {package FFFACTSE FiniteFieldFactorizationWithSizeParseBySideEffect}",
      abstract =
        "Finite fields play an important role for many applications (e.g. coding
        theory, cryptograpy). There are different ways to construct a finite
        field for a given prime power. The paper describes the different
        constructions implemented in AXIOM. These are {\sl polynomial basis
        representation}, {\sl cyclic group representation}, and {\sl normal
        basis representation}. Furthermore, the concept of the implementation,
        the used algorithms and the various datatype coercions between these
        representations are discussed.",
      paper = "Grab92.pdf",
      keywords = "axiomref",
      beebe = "Grabmeier:1992:FFA"
    }
    
    \end{chunk}
    \begin{chunk}{Grabmeier:1992:FFA}
    @TechReport{Grabmeier:1992:FFA,
      author =       "J. Grabmeier and A. Scheerhorn",
      title =        "Finite Fields in {AXIOM}",
      type =         "AXIOM Technical Report",
      number =       "TR7/92 (ATR/5) (NP2522)",
      institution =  inst-NAG,
      address =      inst-NAG:adr,
      pages =        "??",
      month =        dec,
      year =         "1992",
      bibdate =      "Fri Dec 29 16:31:49 1995",
      bibsource =    "/usr/local/src/bib/bibliography/Theory/Comp.Alg.bib;
                     http://www.math.utah.edu/pub/tex/bib/axiom.bib",
      URL =          "http://www.nag.co.uk/doc/TechRep/axiomtr.html",
      acknowledgement = ack-nhfb,
    }
    
    \end{chunk}
    
    \index{Mullin, R.C.}
    \index{Onyszchuk, I.M.}
    \index{Vanstone, S.A.}
    \begin{chunk}{axiom.bib}
    @article{Mull88,
      author = "Mullin, R.C. and Onyszchuk, I.M. and Vanstone, S.A.",
      title = {Optimal Normal Bases in $GF(p^n)},
      journal = "Discrete Applied Mathematics",
      volume = "22",
      pages = "149-161",
      year = "1988"
    }
    
    \end{chunk}
    
    \index{Nickel, W.}
    \begin{chunk}{axiom.bib}
    @misc{Nick88,
      author = "Nickel, W.",
      title = {Endliche K\"orper in dem gruppentheoretischen Programmsystem GAP},
      comment = "Diplomarbeit, RWTH Aachen",
      year = "1988"
    }
    
    \end{chunk}
    
    \index{Odlyzko, A.M.}
    \begin{chunk}{axiom.bib}
    @article{Odly85,
      author = "Odlyzko, A.M.",
      title = "Discrete logarithms in finite fields and their cryptographic
               significance",
      journal = "Proc. Eurocrypt '84, LNCS",
      volume = "209",
      publisher = "Springer-Verlag",
      pages = "224-314",
      year = "1985"
    }
    
    \end{chunk}
    
    \index{Pincin, A}
    \begin{chunk}{axiom.bib}
    @article{Pinc89,
      author = "Pincin, A",
      title = "Bases for finite fields and a canonical decomposition for a
               normal basis generator",
      journal = "Communications in Algebra",
      volume = "17",
      number = "6",
      pages = "1337-1352",
      year = "1989"
    }
    
    \end{chunk}
    
    \index{Pohlig, S.C.}
    \index{Hellman, M.}
    \begin{chunk}{axiom.bib}
    @article{Pohl78,
      author = "Pohlig, S.C. and Hellman, M.",
      title = {An improved algorith for computing logarithms over $GF(p)$
               and its cryptographic significance},
      journal = "IEEE Trans Information Theory",
      volume = "IT-24",
      pages = "106-110",
      year = "1978"
    }
    
    \end{chunk}
    
    \index{Rybowicz, M}
    \begin{chunk}{axiom.bib}
    @article{Rybo89,
      author = "Rybowicz, M",
      title = "Search of primitive polynomials over finite fields",
      journal = "J. Pure Appl.",
      volume = "65",
      pages = "139-151",
      year = "1989"
    }
    
    \end{chunk}
    
    \index{Scheerhorn, A.}
    \begin{chunk}{axiom.bib}
    @misc{Sche92,
      author = "Scheerhorn, A.",
      title = "Trace- and Norm-Compatible Extensions of Finite Fields",
      journal = "Appl. Alg. in Eng., Comm. and Comp.",
      year = "1992"
    }
    
    \end{chunk}
    
    \index{Scheerhorn, Alfred}
    \begin{chunk}{axiom.bib}
    @misc{Sche93,
      author = "Scheerhorn, Alfred",
      title = "Presentation of the algebraic closure of finite fields and
               trace-compatible polynomial sequences",
      comment = "Darstellungen des algebraischen Abschlusses endlicher Korper
                 und spur-kompatible Polynomfolgen",
      year = "1993",
      abstract =
        "For numerical experiments concerning various problems in a finite
        field $\mathbb{F}_q$ it is useful to have an explicit data
        presentation $\mathbb{F}_{q^m}$ of for large $m$, and a method for the
        construction of towers
        \[\mathbb{F}_q \subset \mathbb{F}_{q^{d_1}} \subset \cdots \subset
        \mathbb{F}_{q^{d_k}} = \mathbb{F}_{q^m}\]
        In order to avoid the identification problem it is advantageous to
        have all fields in the tower presented by properly chosen normal bases,
        whereby the embedding
        $\mathbb{F}_{q^{d_i}} \subset \mathbb{F}_{q^{d_{i+1}}}$
        is given by the trace function.
    
        The following notion is introduced: A sequence of polynomials
        $\{f_n | n \ge 1\}$ with degree$(f_n)=n$ called trace-compatible over
        $\mathbb{F}_q$ if (1) $f_n$ is a normal polynomial over $\mathbb{F}_q$,
        (2) if $\alpha_n \in \mathbb{F}_{q^n}$ is a root of $f_n$, then for any
        proper divisor $d$ of $n$ the trace of $\alpha_n$ over $\mathbb{F}_{q^d}$
        is a root of $f_d$.
    
        The main goal of the dissertation is to give algorithms for
        construction of sequences of trace-compatible polynomials and to
        present explicit numerical data. An analogous notion of
        norm-compatible sequences is also introduced and studied.
    
        The dissertation consists of four chapters and a supplement, as
        follows: (1) Basic notions (1-31). (2) Presentation of the algebraic
        closure of a finite field (32-59). (3) Sequences of polynomials and
        sequences of elements (60-115). (4) Implementations (118-139). (5)
        Supplement (142-171).
    
        In chapters (1)–(3) various known results and algorithms are
        collected, and new results are added and compared with those
        previously used.
    
        The numerical results in the supplement contain sequences of
        trace-compatible polynomials of degree $n$, where $n \le 100$, and
        $q=2,3,5,7,11,13$. For implementation, the computer-algebra system
        AXIOM has been used. The details contained in this dissertation are
        not readily describable in a short review.",
      keywords = "axiomref"
    }
    
    \end{chunk}
    
    \index{Shoup, V.}
    \begin{chunk}{axiom.bib}
    @article{Shou92,
      author = "Shoup, V.",
      title = "Searching for Primitive Roots in Finite Fields",
      journal = "Math. of Comp.",
      volume = "58",
      number = "197",
      pages = "369-380",
      year = "1992"
    }
    
    \end{chunk}
    
    \index{Stinson, D.R.}
    \begin{chunk}{axiom.bib}
    @article{Stin90,
      author = "Stinson, D.R.",
      title = {Some oberservations on parallel algorithms for fast exponentiation
               in $GF(2^n)$},
      journal = "SIAM J. Comp.",
      volume = "19",
      number = "4",
      pages = "711-717",
      year = "1990"
    }
    
    \end{chunk}
    
    \index{Varshamov, Gamkrelidze}
    \begin{chunk}{axiom.bib}
    @article{Vars81,
      author = "Varshamov, Gamkrelidze",
      title = "Method of construction of primitive polynomials over finite fields",
      journal = "Soobsheh. Akad. Nauk Gruzin.",
      volume = "99",
      pages = "61-64",
      year = "1981"
    }
    
    \end{chunk}
    
    \index{Wassermann, A.}
    \begin{chunk}{axiom.bib}
    @article{Wass89,
      author = "Wassermann, A.",
      title = "Konstruktion von Normalbasen",
      journal = "Bayreuther Math. Schriften",
      volume = "31",
      pages = "1-9",
      year = "1989"
    }
    
    \end{chunk}
    committed Oct 24, 2016
Commits on Oct 8, 2016
  1. books/bookvolbib Case16 General Number Field Sieve

    Goal: Axiom Algebra
    
    \index{Case, Michael}
    \begin{chunk}{axiom.bib}
    @misc{Case16,
      author = "Case, Michael",
      title = "A Beginner's Guide to the General Number Field Sieve",
      year = "2016"
      url = "http://citeseerx.ist.psu.edu/viewdoc/download?rep=rep1&type=pdf&doi=10.1.1.219.2389",
      paper = "Case16.pdf"
    }
    
    \end{chunk}
    committed Oct 8, 2016
Commits on Oct 4, 2016
Commits on Oct 3, 2016
  1. books/bookvolbib add DeMilo paper on proofs of programs

    Goal: Proving Axiom Correct
    
    \index{DeMilo, Richard A.}
    \index{Lipton, Richard J.}
    \index{Perlis, Alan J.}
    \begin{chunk}{axiom.bib}
    @article{Demi79,
      author = "DeMilo, Richard A. and Lipton, Richard J. and Perlis, Alan J.",
      title = "Social Processes and Proofs of Theorems and Programs",
      journal = "Communications of the ACM",
      volume = "22",
      number = "5",
      year = "1979",
      pages = "271-280",
      abstract =
        "It is argued that formal verifications of programs, no matter how
        obtained, will not play the same key role in the development of
        computer science and software engineering as proofs do in mathematics.
        Furthermore the absence of continuity, the inevitability of change, and
        the complexity of specification of significantly many real programs
        make the formal verification process difficult to justify and manage.
        It is felt that ease of formal verification should not dominate program
        language design.",
      paper = "Dimi79.pdf"
    }
    
    \end{chunk}
    committed Oct 3, 2016
  2. books/bookvolbib add Levenshtein distance reference

    Goal: Axiom Literate Programming
    
    A distance algorithm between two string.
    
    \begin{chunk}{axiom.bib}
    @misc{Wiki16,
      author = "Anonymous",
      title = "Levenshtein distance",
      year = "2016",
      url = "https://en.wikipedia.org/wiki/Levenshtein\_distance"
    }
    
    \end{chunk}
    committed Oct 3, 2016
Commits on Oct 1, 2016
  1. readme: Clarify the question of "Joint Work"

    Goal: Axiom Collaboration
    committed Oct 1, 2016
Commits on Sep 27, 2016
  1. src/share/algebra/*.daase update databases

    Goal: Axiom Maintenance
    committed Sep 27, 2016
Commits on Sep 25, 2016
  1. books/bookvolbib add Salo16 Exploring Abstract Algebra II

    Goal: Axiom Literate Programming
    
    \index{Salomone, Matthew}
    \begin{chunk}{axiom.bib}
    @misc{Salo16,
      author = "Salomone, Matthew",
      title = "Exploring Abstract Algebra II",
      year = "2016",
      url = "https://www.youtube.com/watch?v=RNpdUG_yH_s\&list=PLL0ATV5XYF8DTGAPKRP}
    
    \end{chunk}
    committed Sep 25, 2016
  2. src/interp/format.lisp bug 7237: coerce failure fixed

    Goal: Axiom Maintenance
    
    %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
    \subsection{bug 7237: coerce failure}
    \begin{verbatim}
    
    )d op coerce
    
    There are 194 exposed functions called coerce :
       [1] List(D2) -> D from D if D2 has FIELD and D has AFSPCAT(D2)
       [2] D -> List(D2) from D if D has AFSPCAT(D2) and D2 has FIELD
       [3] D1 -> D from D if D has ALGEBRA(D1) and D1 has COMRING
    
    Daly Bug
       >> System error:
       D2 is not of type SEQUENCE.
    
       Continuing to read the file...
    
    --R
    --R
    --RThere are 194 exposed functions called coerce :
    --R   [1] List D2 -> D from D if D2 has FIELD and D has AFSPCAT D2
    --R   [2] D -> List D2 from D if D has AFSPCAT D2 and D2 has FIELD
    --R   [3] D1 -> D from D if D has ALGEBRA D1 and D1 has COMRING
    --R   [4] Vector D2 -> AlgebraGivenByStructuralConstants(D2,D3,D4,D5)
    --R            from AlgebraGivenByStructuralConstants(D2,D3,D4,D5)
    --R            if D2 has FIELD and D5: VECTOR MATRIX D2 and D3: PI and D4
    --R            : LIST SYMBOL
    
    \end{verbatim}
    
    Now reads:
    
    (1) -> )d op coerce
    
    There are 195 exposed functions called coerce :
       [1] List(D2) -> D from D if D2 has FIELD and D has AFSPCAT(D2)
       [2] D -> List(D2) from D if D has AFSPCAT(D2) and D2 has FIELD
       [3] D1 -> D from D if D has ALGEBRA(D1) and D1 has COMRING
       [4] Vector(D2) -> AlgebraGivenByStructuralConstants(D2,D3,D4,D5)
                 from AlgebraGivenByStructuralConstants(D2,D3,D4,D5)
                 if D2 has FIELD and D5: VECTOR(MATRIX(D2)) and D3: PI and
                D4: LIST(SYMBOL)
       [5] SparseMultivariatePolynomial(Integer,Kernel(AlgebraicNumber))
                 -> AlgebraicNumber
                 from AlgebraicNumber
       [6] D2 -> Any from AnyFunctions1(D2) if D2 has TYPE
       [7] Vector(FortranExpression([construct,QUOTEJINT,QUOTEX,QUOTEELAM],
                [construct],MachineFloat)) -> Asp10(D2)
                 from Asp10(D2) if D2: SYMBOL
       [8] Vector(FortranExpression([construct],[construct,QUOTEXC],
                MachineFloat)) -> Asp19(D2)
                 from Asp19(D2) if D2: SYMBOL
       [9] FortranExpression([construct,QUOTEX],[construct],MachineFloat)
                 -> Asp1(D2)
                 from Asp1(D2) if D2: SYMBOL
       [10] Matrix(FortranExpression([construct],[construct,QUOTEX,QUOTE
                HESS],MachineFloat)) -> Asp20(D2)
                 from Asp20(D2) if D2: SYMBOL
       [11] FortranExpression([construct],[construct,QUOTEXC],MachineFloat)
                 -> Asp24(D2)
                 from Asp24(D2) if D2: SYMBOL
       [12] Vector(FortranExpression([construct,QUOTEX],[construct,QUOTEY],
                MachineFloat)) -> Asp31(D2)
                 from Asp31(D2) if D2: SYMBOL
       [13] Vector(FortranExpression([construct],[construct,QUOTEX],
                MachineFloat)) -> Asp35(D2)
                 from Asp35(D2) if D2: SYMBOL
       [14] Vector(FortranExpression([construct,QUOTEX,QUOTEEPS],[construct
                ,QUOTEY],MachineFloat)) -> Asp41(D2,D3,D4)
                 from Asp41(D2,D3,D4) if D2: SYMBOL and D3: SYMBOL and D4:
                SYMBOL
       [15] Vector(FortranExpression([construct,QUOTEEPS],[construct,QUOTE
                YA,QUOTEYB],MachineFloat)) -> Asp42(D2,D3,D4)
                 from Asp42(D2,D3,D4) if D2: SYMBOL and D3: SYMBOL and D4:
                SYMBOL
       [16] FortranExpression([construct],[construct,QUOTEX],MachineFloat)
                 -> Asp49(D2)
                 from Asp49(D2) if D2: SYMBOL
       [17] FortranExpression([construct],[construct,QUOTEX],MachineFloat)
                 -> Asp4(D2)
                 from Asp4(D2) if D2: SYMBOL
       [18] Vector(FortranExpression([construct],[construct,QUOTEXC],
                MachineFloat)) -> Asp50(D2)
                 from Asp50(D2) if D2: SYMBOL
       [19] Vector(FortranExpression([construct],[construct,QUOTEX],
                MachineFloat)) -> Asp55(D2)
                 from Asp55(D2) if D2: SYMBOL
       [20] Vector(FortranExpression([construct],[construct,QUOTEX],
                MachineFloat)) -> Asp6(D2)
                 from Asp6(D2) if D2: SYMBOL
       [21] Vector(FortranExpression([construct,QUOTEX,QUOTEY],[construct],
                MachineFloat)) -> Asp73(D2)
                 from Asp73(D2) if D2: SYMBOL
       [22] Matrix(FortranExpression([construct,QUOTEX,QUOTEY],[construct],
                MachineFloat)) -> Asp74(D2)
                 from Asp74(D2) if D2: SYMBOL
       [23] Matrix(FortranExpression([construct,QUOTEX],[construct],
                MachineFloat)) -> Asp77(D2)
                 from Asp77(D2) if D2: SYMBOL
       [24] Vector(FortranExpression([construct,QUOTEX],[construct],
                MachineFloat)) -> Asp78(D2)
                 from Asp78(D2) if D2: SYMBOL
       [25] Vector(FortranExpression([construct,QUOTEX],[construct,QUOTEY],
                MachineFloat)) -> Asp7(D2)
                 from Asp7(D2) if D2: SYMBOL
       [26] Matrix(FortranExpression([construct,QUOTEXL,QUOTEXR,QUOTEELAM],
                [construct],MachineFloat)) -> Asp80(D2)
                 from Asp80(D2) if D2: SYMBOL
       [27] FortranExpression([construct,QUOTEX],[construct,QUOTEY],
                MachineFloat) -> Asp9(D2)
                 from Asp9(D2) if D2: SYMBOL
       [28] ArrayStack(D2) -> OutputForm from ArrayStack(D2)
                 if D2 has SETCAT and D2 has SETCAT
       [29] BinaryExpansion -> RadixExpansion(2) from BinaryExpansion
       [30] BinaryExpansion -> Fraction(Integer) from BinaryExpansion
       [31] List(Integer) -> D from D if D has BLMETCT
       [32] List(CartesianTensor(D2,D3,D4)) -> CartesianTensor(D2,D3,D4)
                 from CartesianTensor(D2,D3,D4) if D2: INT and D3: NNI and
                D4 has COMRING
       [33] List(D4) -> CartesianTensor(D2,D3,D4) from CartesianTensor(D2,
                D3,D4)
                 if D4 has COMRING and D2: INT and D3: NNI
       [34] SquareMatrix(D3,D4) -> CartesianTensor(D2,D3,D4)
                 from CartesianTensor(D2,D3,D4) if D3: NNI and D4 has
                COMRING and D2: INT
       [35] DirectProduct(D3,D4) -> CartesianTensor(D2,D3,D4)
                 from CartesianTensor(D2,D3,D4) if D3: NNI and D4 has
                COMRING and D2: INT
       [36] List(D2) -> Database(D2) from Database(D2)
                 if D2 has OrderedSetwith
                   ?.? : (%,Symbol) -> String
                   display : % -> Void
                   fullDisplay : % -> Void
       [37] DecimalExpansion -> RadixExpansion(10) from DecimalExpansion
    
       [38] DecimalExpansion -> Fraction(Integer) from DecimalExpansion
       [39] Dequeue(D2) -> OutputForm from Dequeue(D2) if D2 has SETCAT and
                D2 has SETCAT
       [40] DirichletRing(D2) -> Stream(D2) from DirichletRing(D2) if D2
                 has RING
       [41] Stream(D2) -> DirichletRing(D2) from DirichletRing(D2) if D2
                 has RING
       [42] DirichletRing(D2) -> (PositiveInteger -> D2) from DirichletRing
                (D2)
                 if D2 has RING
       [43] (PositiveInteger -> D2) -> DirichletRing(D2) from DirichletRing
                (D2)
                 if D2 has RING
       [44] DataList(D2) -> List(D2) from DataList(D2) if D2 has ORDSET
       [45] List(D2) -> DataList(D2) from DataList(D2) if D2 has ORDSET
       [46] SegmentBinding(Expression(D3)) -> SegmentBinding(Float)
                 from DrawNumericHack(D3)
                 if D3 has Join(OrderedSet,IntegralDomain,ConvertibleTo(
                Float))
       [47] D1 -> D from D if D has DVARCAT(D1) and D1 has ORDSET
       [48] FortranCode -> OutputForm from FortranCode
       [49] FortranExpression(D2,D3,D4) -> Expression(D4)
                 from FortranExpression(D2,D3,D4)
                 if D2: LIST(SYMBOL) and D3: LIST(SYMBOL) and D4 has FMTC
    
       [50] D2 -> D1 from FiniteFieldHomomorphisms(D2,D3,D1)
                 if D3 has FFIELDC and D1 has FAXF(D3) and D2 has FAXF(D3)
    
       [51] D2 -> D1 from FiniteFieldHomomorphisms(D1,D3,D2)
                 if D3 has FFIELDC and D1 has FAXF(D3) and D2 has FAXF(D3)
    
       [52] D -> XRecursivePolynomial(D2,D3) from D
                 if D has FLALG(D2,D3) and D2 has ORDSET and D3 has COMRING
    
       [53] D -> XDistributedPolynomial(D2,D3) from D
                 if D has FLALG(D2,D3) and D2 has ORDSET and D3 has COMRING
    
       [54] D1 -> D from D if D has FLALG(D1,D2) and D1 has ORDSET and D2
                 has COMRING
       [55] Record(localSymbols: SymbolTable,code: List(FortranCode)) -> D
                 from D
                 if D has FMC
       [56] FortranCode -> D from D if D has FMC
       [57] List(FortranCode) -> D from D if D has FMC
       [58] Matrix(MachineFloat) -> D from D if D has FMC
       [59] Record(localSymbols: SymbolTable,code: List(FortranCode)) -> D
                 from D
                 if D has FMFUN
       [60] FortranCode -> D from D if D has FMFUN
       [61] List(FortranCode) -> D from D if D has FMFUN
       [62] D -> String from D if D has FNCAT
       [63] String -> D from D if D has FNCAT
       [64] D2 -> ScriptFormulaFormat from ScriptFormulaFormat1(D2) if D2
                 has SETCAT
       [65] OutputForm -> ScriptFormulaFormat from ScriptFormulaFormat
       [66] Record(localSymbols: SymbolTable,code: List(FortranCode)) -> D
                 from D
                 if D has FORTFN
       [67] FortranCode -> D from D if D has FORTFN
       [68] List(FortranCode) -> D from D if D has FORTFN
       [69] Equation(Expression(Complex(Float))) -> FortranProgram(D2,D3,D4
                ,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [70] Equation(Expression(Float)) -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [71] Equation(Expression(Integer)) -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [72] Expression(Complex(Float)) -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [73] Expression(Float) -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [74] Expression(Integer) -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [75] Equation(Expression(MachineComplex)) -> FortranProgram(D2,D3,D4
                ,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [76] Equation(Expression(MachineFloat)) -> FortranProgram(D2,D3,D4,
                D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [77] Equation(Expression(MachineInteger)) -> FortranProgram(D2,D3,D4
                ,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [78] Expression(MachineComplex) -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [79] Expression(MachineFloat) -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [80] Expression(MachineInteger) -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [81] Record(localSymbols: SymbolTable,code: List(FortranCode)) ->
                FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [82] List(FortranCode) -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [83] FortranCode -> FortranProgram(D2,D3,D4,D5)
                 from FortranProgram(D2,D3,D4,D5)
                 if D2: SYMBOL and D3: Union(fst: FortranScalarType,void:
                void) and D4: LIST(SYMBOL) and D5: SYMTAB
       [84] FourierComponent(D3) -> FourierSeries(D2,D3) from FourierSeries
                (D2,D3)
                 if D3 has Join(OrderedSet,AbelianGroup) and D2 has Join(
                CommutativeRing,Algebra(Fraction(Integer)))
       [85] D1 -> FourierSeries(D1,D2) from FourierSeries(D1,D2)
                 if D1 has Join(CommutativeRing,Algebra(Fraction(Integer)))
                and D2 has Join(OrderedSet,AbelianGroup)
       [86] Fraction(Polynomial(Fraction(D2))) -> D from D
                 if D2 has INTDOM and D2 has ORDSET and D has FS(D2)
       [87] Polynomial(Fraction(D2)) -> D from D
                 if D2 has INTDOM and D2 has ORDSET and D has FS(D2)
       [88] Fraction(D2) -> D from D if D2 has INTDOM and D2 has ORDSET and
                D has FS(D2)
       [89] SparseMultivariatePolynomial(D2,Kernel(D)) -> D from D
                 if D2 has RING and D2 has ORDSET and D has FS(D2)
       [90] FortranScalarType -> SExpression from FortranScalarType
       [91] FortranScalarType -> Symbol from FortranScalarType
       [92] Symbol -> FortranScalarType from FortranScalarType
       [93] String -> FortranScalarType from FortranScalarType
       [94] FortranScalarType -> FortranType from FortranType
       [95] FortranType -> OutputForm from FortranType
       [96] Record(localSymbols: SymbolTable,code: List(FortranCode)) -> D
                 from D
                 if D has FVC
       [97] FortranCode -> D from D if D has FVC
       [98] List(FortranCode) -> D from D if D has FVC
       [99] Vector(MachineFloat) -> D from D if D has FVC
       [100] Record(localSymbols: SymbolTable,code: List(FortranCode)) -> D
                 from D
                 if D has FVFUN
       [101] FortranCode -> D from D if D has FVFUN
       [102] List(FortranCode) -> D from D if D has FVFUN
       [103] UnivariatePuiseuxSeries(D2,D3,D4) ->
                GeneralUnivariatePowerSeries(D2,D3,D4)
                 from GeneralUnivariatePowerSeries(D2,D3,D4)
                 if D2 has RING and D3: SYMBOL and D4: D2
       [104] Variable(D3) -> GeneralUnivariatePowerSeries(D2,D3,D4)
                 from GeneralUnivariatePowerSeries(D2,D3,D4)
                 if D3: SYMBOL and D2 has RING and D4: D2
       [105] Heap(D2) -> OutputForm from Heap(D2) if D2 has SETCAT and D2
                 has ORDSET
       [106] HexadecimalExpansion -> RadixExpansion(16) from
                HexadecimalExpansion
       [107] HexadecimalExpansion -> Fraction(Integer) from
                HexadecimalExpansion
       [108] OutputForm -> String from HTMLFormat
       [109] String -> IndexCard from IndexCard
       [110] List(D5) -> PolynomialIdeals(D2,D3,D4,D5)
                 from PolynomialIdeals(D2,D3,D4,D5)
                 if D5 has POLYCAT(D2,D3,D4) and D2 has FIELD and D3 has
                OAMONS and D4 has ORDSET
       [111] D1 -> AssociatedJordanAlgebra(D2,D1) from
                AssociatedJordanAlgebra(D2,D1)
                 if D2 has COMRING and D1 has NAALG(D2)
       [112] D -> D1 from D if D has KOERCE(D1) and D1 has TYPE
       [113] D1 -> D from D if D has LALG(D1) and D1 has RING
       [114] D1 -> AssociatedLieAlgebra(D2,D1) from AssociatedLieAlgebra(D2
                ,D1)
                 if D2 has COMRING and D1 has NAALG(D2)
       [115] D -> Stream(Record(k: Integer,c: D2)) from D
                 if D has LOCPOWC(D2) and D2 has FIELD
       [116] Stream(Record(k: Integer,c: D2)) -> D from D
                 if D2 has FIELD and D has LOCPOWC(D2)
       [117] ThreeDimensionalMatrix(D2) -> PrimitiveArray(PrimitiveArray(
                PrimitiveArray(D2)))
                 from ThreeDimensionalMatrix(D2) if D2 has SETCAT
       [118] PrimitiveArray(PrimitiveArray(PrimitiveArray(D2))) ->
                ThreeDimensionalMatrix(D2)
                 from ThreeDimensionalMatrix(D2) if D2 has SETCAT
       [119] D2 -> (() -> D2) from MappingPackage1(D2) if D2 has SETCAT
       [120] D1 -> D from D
                 if D2 has RING and D has MATCAT(D2,D3,D1) and D3 has FLAGG
                (D2) and D1 has FLAGG(D2)
       [121] MachineComplex -> Complex(Float) from MachineComplex
       [122] Complex(MachineInteger) -> MachineComplex from MachineComplex
    
       [123] Complex(MachineFloat) -> MachineComplex from MachineComplex
    
       [124] Complex(Integer) -> MachineComplex from MachineComplex
       [125] Complex(Float) -> MachineComplex from MachineComplex
       [126] MachineInteger -> MachineFloat from MachineFloat
       [127] MachineFloat -> Float from MachineFloat
       [128] Expression(Integer) -> Expression(MachineInteger) from
                MachineInteger
       [129] OutputForm -> String from MathMLFormat
       [130] Fraction(MyUnivariatePolynomial(D2,D3)) -> MyExpression(D2,D3)
                 from MyExpression(D2,D3)
                 if D2: SYMBOL and D3 has Join(Ring,OrderedSet,
                IntegralDomain)
       [131] Polynomial(D3) -> MyUnivariatePolynomial(D2,D3)
                 from MyUnivariatePolynomial(D2,D3) if D3 has RING and D2:
                SYMBOL
       [132] Variable(D2) -> MyUnivariatePolynomial(D2,D3)
                 from MyUnivariatePolynomial(D2,D3) if D2: SYMBOL and D3
                 has RING
       [133] D1 -> MyUnivariatePolynomial(D2,D1) from
                MyUnivariatePolynomial(D2,D1)
                 if D2: SYMBOL and D1 has RING
       [134] Integer -> D from D if D has NASRING
       [135] Union(nia: Record(var: Symbol,fn: Expression(DoubleFloat),
                range: Segment(OrderedCompletion(DoubleFloat)),abserr:
                DoubleFloat,relerr: DoubleFloat),mdnia: Record(fn: Expression(
                DoubleFloat),range: List(Segment(OrderedCompletion(DoubleFloat)))
                ,abserr: DoubleFloat,relerr: DoubleFloat)) ->
                NumericalIntegrationProblem
                 from NumericalIntegrationProblem
       [136] Record(fn: Expression(DoubleFloat),range: List(Segment(
                OrderedCompletion(DoubleFloat))),abserr: DoubleFloat,relerr:
                DoubleFloat) -> NumericalIntegrationProblem
                 from NumericalIntegrationProblem
       [137] Record(var: Symbol,fn: Expression(DoubleFloat),range: Segment(
                OrderedCompletion(DoubleFloat)),abserr: DoubleFloat,relerr:
                DoubleFloat) -> NumericalIntegrationProblem
                 from NumericalIntegrationProblem
       [138] NumericalIntegrationProblem -> OutputForm
                 from NumericalIntegrationProblem
       [139] D2 -> None from NoneFunctions1(D2) if D2 has TYPE
       [140] Record(xinit: DoubleFloat,xend: DoubleFloat,fn: Vector(
                Expression(DoubleFloat)),yinit: List(DoubleFloat),intvals: List(
                DoubleFloat),g: Expression(DoubleFloat),abserr: DoubleFloat,
                relerr: DoubleFloat) -> NumericalODEProblem
                 from NumericalODEProblem
       [141] NumericalODEProblem -> OutputForm from NumericalODEProblem
       [142] OrdinaryDifferentialRing(D2,D1,D3) -> D1
                 from OrdinaryDifferentialRing(D2,D1,D3)
                 if D1 has PDRING(D2) and D2 has SETCAT and D3: D2
       [143] D1 -> OrdinaryDifferentialRing(D2,D1,D3)
                 from OrdinaryDifferentialRing(D2,D1,D3)
                 if D2 has SETCAT and D3: D2 and D1 has PDRING(D2)
       [144] Symbol -> OpenMathErrorKind from OpenMathErrorKind
       [145] Union(noa: Record(fn: Expression(DoubleFloat),init: List(
                DoubleFloat),lb: List(OrderedCompletion(DoubleFloat)),cf: List(
                Expression(DoubleFloat)),ub: List(OrderedCompletion(DoubleFloat))
                ),lsa: Record(lfn: List(Expression(DoubleFloat)),init: List(
                DoubleFloat))) -> NumericalOptimizationProblem
                 from NumericalOptimizationProblem
       [146] Record(lfn: List(Expression(DoubleFloat)),init: List(
                DoubleFloat)) -> NumericalOptimizationProblem
                 from NumericalOptimizationProblem
       [147] Record(fn: Expression(DoubleFloat),init: List(DoubleFloat),lb
                : List(OrderedCompletion(DoubleFloat)),cf: List(Expression(
                DoubleFloat)),ub: List(OrderedCompletion(DoubleFloat))) ->
                NumericalOptimizationProblem
                 from NumericalOptimizationProblem
       [148] NumericalOptimizationProblem -> OutputForm
                 from NumericalOptimizationProblem
       [149] Integer -> OrdSetInts from OrdSetInts
       [150] Color -> Palette from Palette
       [151] Polynomial(AlgebraicNumber) -> Expression(Integer)
                 from PolynomialAN2Expression
       [152] Fraction(Polynomial(AlgebraicNumber)) -> Expression(Integer)
                 from PolynomialAN2Expression
       [153] Record(pde: List(Expression(DoubleFloat)),constraints: List(
                Record(start: DoubleFloat,finish: DoubleFloat,grid:
                NonNegativeInteger,boundaryType: Integer,dStart: Matrix(
                DoubleFloat),dFinish: Matrix(DoubleFloat))),f: List(List(
                Expression(DoubleFloat))),st: String,tol: DoubleFloat) ->
                NumericalPDEProblem
                 from NumericalPDEProblem
       [154] NumericalPDEProblem -> OutputForm from NumericalPDEProblem
       [155] PendantTree(D2) -> Tree(D2) from PendantTree(D2) if D2 has
                SETCAT
       [156] List(Permutation(D2)) -> PermutationGroup(D2) from
                PermutationGroup(D2)
                 if D2 has SETCAT
       [157] PermutationGroup(D2) -> List(Permutation(D2)) from
                PermutationGroup(D2)
                 if D2 has SETCAT
       [158] List(D2) -> Permutation(D2) from Permutation(D2) if D2 has
                SETCAT
       [159] List(List(D2)) -> Permutation(D2) from Permutation(D2) if D2
                 has SETCAT
       [160] Fraction(Factored(D2)) -> PartialFraction(D2) from
                PartialFraction(D2)
                 if D2 has EUCDOM
       [161] PartialFraction(D2) -> Fraction(D2) from PartialFraction(D2)
                 if D2 has EUCDOM
       [162] Pi -> Expression(D3) from PiCoercions(D3)
                 if D3 has Join(OrderedSet,IntegralDomain)
       [163] List(D2) -> D from D if D2 has FIELD and D has PRSPCAT(D2)
       [164] D -> List(D2) from D if D has PRSPCAT(D2) and D2 has FIELD
       [165] Queue(D2) -> OutputForm from Queue(D2) if D2 has SETCAT and D2
                 has SETCAT
       [166] RadixExpansion(D2) -> Fraction(Integer) from RadixExpansion(D2
                ) if D2: INT
       [167] D2 -> Void from ResolveLatticeCompletion(D2) if D2 has TYPE
    
       [168] Exit -> D1 from ResolveLatticeCompletion(D1) if D1 has TYPE
    
       [169] D1 -> D from D if D has RETRACT(D1) and D1 has TYPE
       [170] D2 -> Fraction(Polynomial(D2)) from RationalFunction(D2) if D2
                 has INTDOM
       [171] Integer -> D from D if D has RING
       [172] SparseEchelonMatrix(D2,D3) -> Matrix(D3) from
                SparseEchelonMatrix(D2,D3)
                 if D2 has ORDSET and D3 has RING
       [173] D -> OutputForm from D if D has SPACEC(D2) and D2 has RING
       [174] Character -> D from D if D has SRAGG
       [175] Stack(D2) -> OutputForm from Stack(D2) if D2 has SETCAT and D2
                 has SETCAT
       [176] List(D2) -> Stream(D2) from Stream(D2) if D2 has TYPE
       [177] Symbol -> Switch from Switch
       [178] String -> Symbol from Symbol
       [179] SymbolTable -> Table(Symbol,FortranType) from SymbolTable
       [180] Tableau(D2) -> OutputForm from Tableau(D2) if D2 has SETCAT
    
       [181] D2 -> TexFormat from TexFormat1(D2) if D2 has SETCAT
       [182] OutputForm -> TexFormat from TexFormat
       [183] Polynomial(D2) -> TaylorSeries(D2) from TaylorSeries(D2) if D2
                 has RING
       [184] Symbol -> TaylorSeries(D2) from TaylorSeries(D2) if D2 has
                RING
       [185] Variable(QUOTE(x)) -> UnivariateFormalPowerSeries(D2)
                 from UnivariateFormalPowerSeries(D2) if D2 has RING
       [186] UnivariatePolynomial(QUOTE(x),D2) ->
                UnivariateFormalPowerSeries(D2)
                 from UnivariateFormalPowerSeries(D2) if D2 has RING
       [187] D1 -> D from D if D2 has RING and D has ULSCCAT(D2,D1) and D1
                 has UTSCAT(D2)
       [188] Segment(D2) -> UniversalSegment(D2) from UniversalSegment(D2)
                 if D2 has TYPE
       [189] Variable(D2) -> UnivariatePolynomial(D2,D3)
                 from UnivariatePolynomial(D2,D3) if D2: SYMBOL and D3 has
                RING
       [190] D1 -> D from D if D2 has RING and D has UPXSCCA(D2,D1) and D1
                 has ULSCAT(D2)
       [191] Variable(D3) -> UnivariateTaylorSeriesCZero(D2,D3)
                 from UnivariateTaylorSeriesCZero(D2,D3) if D3: SYMBOL and
                D2 has RING
       [192] UnivariatePolynomial(D3,D2) -> UnivariateTaylorSeriesCZero(D2,
                D3)
                 from UnivariateTaylorSeriesCZero(D2,D3) if D2 has RING and
                D3: SYMBOL
       [193] Void -> OutputForm from Void
       [194] D1 -> D from D if D has XALG(D1) and D1 has RING
       [195] D1 -> D from D if D has XFALG(D1,D2) and D1 has ORDSET and D2
                 has RING
    
    There are 50 unexposed functions called coerce :
       [1] Vector(Matrix(D3)) -> Vector(Matrix(Fraction(Polynomial(D3))))
                 from CoerceVectorMatrixPackage(D3) if D3 has COMRING
       [2] List(Integer) -> ExtAlgBasis from ExtAlgBasis
       [3] EuclideanModularRing(D2,D1,D3,D4,D5,D6) -> D1
                 from EuclideanModularRing(D2,D1,D3,D4,D5,D6)
                 if D1 has UPOLYC(D2) and D2 has COMRING and D3 has ABELMON
                and D4: ((D1,D3) -> D1) and D5: ((D3,D3) -> Union(D3,
                "failed")) and D6: ((D1,D1,D3) -> Union(D1,"failed"))
       [4] UnivariatePuiseuxSeries(D3,D4,D5) -> ExponentialExpansion(D2,D3,
                D4,D5)
                 from ExponentialExpansion(D2,D3,D4,D5)
                 if D3 has Join(AlgebraicallyClosedField,
                TranscendentalFunctionCategory,FunctionSpace(D2)) and D4:
                SYMBOL and D5: D3 and D2 has Join(OrderedSet,RetractableTo(
                Integer),LinearlyExplicitRingOver(Integer),GcdDomain)
       [5] Vector(Fraction(Polynomial(D2))) -> GenericNonAssociativeAlgebra
                (D2,D3,D4,D5)
                 from GenericNonAssociativeAlgebra(D2,D3,D4,D5)
                 if D2 has COMRING and D5: VECTOR(MATRIX(D2)) and D3: PI
                and D4: LIST(SYMBOL)
       [6] List(List(Point(DoubleFloat))) -> GraphImage from GraphImage
       [7] GraphImage -> OutputForm from GraphImage
       [8] SparseMultivariatePolynomial(Integer,Kernel(InnerAlgebraicNumber
                )) -> InnerAlgebraicNumber
                 from InnerAlgebraicNumber
       [9] LieExponentials(D2,D3,D4) -> XPBWPolynomial(D2,D3)
                 from LieExponentials(D2,D3,D4)
                 if D2 has ORDSET and D3 has Join(CommutativeRing,Module(
                Fraction(Integer))) and D4: PI
       [10] LieExponentials(D2,D3,D4) -> XDistributedPolynomial(D2,D3)
                 from LieExponentials(D2,D3,D4)
                 if D2 has ORDSET and D3 has Join(CommutativeRing,Module(
                Fraction(Integer))) and D4: PI
       [11] LyndonWord(D2) -> Magma(D2) from LyndonWord(D2) if D2 has
                ORDSET
       [12] LyndonWord(D2) -> OrderedFreeMonoid(D2) from LyndonWord(D2) if
                D2 has ORDSET
       [13] Magma(D2) -> OrderedFreeMonoid(D2) from Magma(D2) if D2 has
                ORDSET
       [14] D1 -> MakeCachableSet(D1) from MakeCachableSet(D1) if D1 has
                SETCAT
       [15] ModularField(D1,D2,D3,D4,D5) -> D1 from ModularField(D1,D2,D3,
                D4,D5)
                 if D1 has COMRING and D2 has ABELMON and D3: ((D1,D2) ->
                D1) and D4: ((D2,D2) -> Union(D2,"failed")) and D5: ((D1,D1
                ,D2) -> Union(D1,"failed"))
       [16] D1 -> ModMonic(D2,D1) from ModMonic(D2,D1)
                 if D2 has RING and D1 has UPOLYC(D2)
       [17] ModuleMonomial(D2,D3,D4) -> Record(index: D2,exponent: D3)
                 from ModuleMonomial(D2,D3,D4)
                 if D2 has ORDSET and D3 has SETCAT and D4: ((Record(index
                : D2,exponent: D3),Record(index: D2,exponent: D3)) ->
                Boolean)
       [18] Record(index: D2,exponent: D3) -> ModuleMonomial(D2,D3,D4)
                 from ModuleMonomial(D2,D3,D4)
                 if D2 has ORDSET and D3 has SETCAT and D4: ((Record(index
                : D2,exponent: D3),Record(index: D2,exponent: D3)) ->
                Boolean)
       [19] ModularRing(D1,D2,D3,D4,D5) -> D1 from ModularRing(D1,D2,D3,D4,
                D5)
                 if D1 has COMRING and D2 has ABELMON and D3: ((D1,D2) ->
                D1) and D4: ((D2,D2) -> Union(D2,"failed")) and D5: ((D1,D1
                ,D2) -> Union(D1,"failed"))
       [20] List(Record(coef: D2,monom: D3)) -> MonoidRing(D2,D3)
                 from MonoidRing(D2,D3) if D2 has RING and D3 has MONOID
    
       [21] Variable(D2) -> UnivariateSkewPolynomial(D2,D3,D4,D5)
                 from UnivariateSkewPolynomial(D2,D3,D4,D5)
                 if D2: SYMBOL and D3 has RING and D4: AUTOMOR(D3) and D5:
                (D3 -> D3)
       [22] Polynomial(D2) -> OrdinaryWeightedPolynomials(D2,D3,D4,D5)
                 from OrdinaryWeightedPolynomials(D2,D3,D4,D5)
                 if D2 has RING and D3: LIST(SYMBOL) and D4: LIST(NNI) and
                D5: NNI
       [23] OrdinaryWeightedPolynomials(D2,D3,D4,D5) -> Polynomial(D2)
                 from OrdinaryWeightedPolynomials(D2,D3,D4,D5)
                 if D2 has RING and D3: LIST(SYMBOL) and D4: LIST(NNI) and
                D5: NNI
       [24] D1 -> PoincareBirkhoffWittLyndonBasis(D1)
                 from PoincareBirkhoffWittLyndonBasis(D1) if D1 has ORDSET
    
       [25] PoincareBirkhoffWittLyndonBasis(D2) -> OrderedFreeMonoid(D2)
                 from PoincareBirkhoffWittLyndonBasis(D2) if D2 has ORDSET
    
       [26] Partition -> List(Integer) from Partition
       [27] D1 -> ResidueRing(D2,D3,D4,D1,D5) from ResidueRing(D2,D3,D4,D1,
                D5)
                 if D2 has FIELD and D3 has OAMONS and D4 has ORDSET and D1
                 has POLYCAT(D2,D3,D4) and D5: LIST(D1)
       [28] RectangularMatrix(D2,D3,D4) -> Matrix(D4)
                 from RectangularMatrix(D2,D3,D4) if D2: NNI and D3: NNI
                and D4 has RING
       [29] D1 -> SparseMultivariateTaylorSeries(D2,D3,D1)
                 from SparseMultivariateTaylorSeries(D2,D3,D1)
                 if D2 has RING and D3 has ORDSET and D1 has POLYCAT(D2,
                INDE(D3),D3)
       [30] D1 -> SparseMultivariateTaylorSeries(D2,D1,D3)
                 from SparseMultivariateTaylorSeries(D2,D1,D3)
                 if D2 has RING and D1 has ORDSET and D3 has POLYCAT(D2,
                INDE(D1),D1)
       [31] SquareMatrix(D2,D3) -> Matrix(D3) from SquareMatrix(D2,D3)
                 if D2: NNI and D3 has RING
       [32] D2 -> Stream(D2) from StreamTaylorSeriesOperations(D2) if D2
                 has RING
       [33] Variable(D3) -> SparseUnivariateLaurentSeries(D2,D3,D4)
                 from SparseUnivariateLaurentSeries(D2,D3,D4)
                 if D3: SYMBOL and D2 has RING and D4: D2
       [34] Variable(D3) -> SparseUnivariatePuiseuxSeries(D2,D3,D4)
                 from SparseUnivariatePuiseuxSeries(D2,D3,D4)
                 if D3: SYMBOL and D2 has RING and D4: D2
       [35] Variable(D3) -> SparseUnivariateTaylorSeries(D2,D3,D4)
                 from SparseUnivariateTaylorSeries(D2,D3,D4)
                 if D3: SYMBOL and D2 has RING and D4: D2
       [36] UnivariatePolynomial(D3,D2) -> SparseUnivariateTaylorSeries(D2,
                D3,D4)
                 from SparseUnivariateTaylorSeries(D2,D3,D4)
                 if D2 has RING and D3: SYMBOL and D4: D2
       [37] PrimitiveArray(D2) -> Tuple(D2) from Tuple(D2) if D2 has TYPE
    
       [38] Variable(D3) -> UnivariateLaurentSeries(D2,D3,D4)
                 from UnivariateLaurentSeries(D2,D3,D4)
                 if D3: SYMBOL and D2 has RING and D4: D2
       [39] Variable(D3) -> UnivariatePuiseuxSeries(D2,D3,D4)
                 from UnivariatePuiseuxSeries(D2,D3,D4)
                 if D3: SYMBOL and D2 has RING and D4: D2
       [40] Variable(D3) -> UnivariateTaylorSeries(D2,D3,D4)
                 from UnivariateTaylorSeries(D2,D3,D4)
                 if D3: SYMBOL and D2 has RING and D4: D2
       [41] UnivariatePolynomial(D3,D2) -> UnivariateTaylorSeries(D2,D3,D4)
                 from UnivariateTaylorSeries(D2,D3,D4)
                 if D2 has RING and D3: SYMBOL and D4: D2
       [42] Variable(D2) -> Symbol from Variable(D2) if D2: SYMBOL
       [43] TwoDimensionalViewport -> OutputForm from
                TwoDimensionalViewport
       [44] GraphImage -> TwoDimensionalViewport from ViewportPackage
       [45] D1 -> WeightedPolynomials(D2,D3,D4,D1,D5,D6,D7)
                 from WeightedPolynomials(D2,D3,D4,D1,D5,D6,D7)
                 if D2 has RING and D3 has ORDSET and D4 has OAMONS and D5
                : LIST(D3) and D1 has POLYCAT(D2,D4,D3) and D6: LIST(NNI)
                and D7: NNI
       [46] WeightedPolynomials(D2,D3,D4,D1,D5,D6,D7) -> D1
                 from WeightedPolynomials(D2,D3,D4,D1,D5,D6,D7)
                 if D1 has POLYCAT(D2,D4,D3) and D2 has RING and D3 has
                ORDSET and D4 has OAMONS and D5: LIST(D3) and D6: LIST(NNI)
                and D7: NNI
       [47] XPBWPolynomial(D2,D3) -> XRecursivePolynomial(D2,D3)
                 from XPBWPolynomial(D2,D3) if D2 has ORDSET and D3 has
                COMRING
       [48] XPBWPolynomial(D2,D3) -> XDistributedPolynomial(D2,D3)
                 from XPBWPolynomial(D2,D3) if D2 has ORDSET and D3 has
                COMRING
       [49] LiePolynomial(D2,D3) -> XPBWPolynomial(D2,D3) from
                XPBWPolynomial(D2,D3)
                 if D2 has ORDSET and D3 has COMRING
       [50] D1 -> XPolynomialRing(D2,D1) from XPolynomialRing(D2,D1)
                 if D2 has RING and D1 has ORDMON
    
    Examples of coerce from AffineSpaceCategory
    
    Examples of coerce from Algebra
    
    Examples of coerce from AlgebraGivenByStructuralConstants
    
    Examples of coerce from AlgebraicNumber
    
    Examples of coerce from AnyFunctions1
    
    Examples of coerce from Asp10
    
    Examples of coerce from Asp19
    
    Examples of coerce from Asp1
    
    Examples of coerce from Asp20
    
    Examples of coerce from Asp24
    
    Examples of coerce from Asp31
    
    Examples of coerce from Asp35
    
    Examples of coerce from Asp41
    
    Examples of coerce from Asp42
    
    Examples of coerce from Asp49
    
    Examples of coerce from Asp4
    
    Examples of coerce from Asp50
    
    Examples of coerce from Asp55
    
    Examples of coerce from Asp6
    
    Examples of coerce from Asp73
    
    Examples of coerce from Asp74
    
    Examples of coerce from Asp77
    
    Examples of coerce from Asp78
    
    Examples of coerce from Asp7
    
    Examples of coerce from Asp80
    
    Examples of coerce from Asp9
    
    Examples of coerce from ArrayStack
    
    a:ArrayStack INT:= arrayStack [1,2,3,4,5]
    coerce a
    
    Examples of coerce from BinaryExpansion
    
    Examples of coerce from BlowUpMethodCategory
    
    Examples of coerce from CartesianTensor
    
    v:=[2,3]
    tv:CartesianTensor(1,2,Integer):=v
    tm:CartesianTensor(1,2,Integer):=[tv,tv]
    
    v:=[2,3]
    tv:CartesianTensor(1,2,Integer):=v
    
    v:SquareMatrix(2,Integer):=[[1,2],[3,4]]
    tv:CartesianTensor(1,2,Integer):=v
    
    v:DirectProduct(2,Integer):=directProduct [3,4]
    tv:CartesianTensor(1,2,Integer):=v
    
    Examples of coerce from CoerceVectorMatrixPackage
    
    Examples of coerce from Database
    
    Examples of coerce from DecimalExpansion
    
    Examples of coerce from Dequeue
    
    a:Dequeue INT:= dequeue [1,2,3,4,5]
    coerce a
    
    Examples of coerce from DirichletRing
    
    Examples of coerce from DataList
    
    Examples of coerce from DrawNumericHack
    
    Examples of coerce from DifferentialVariableCategory
    
    Examples of coerce from ExtAlgBasis
    
    Examples of coerce from EuclideanModularRing
    
    Examples of coerce from ExponentialExpansion
    
    Examples of coerce from FortranCode
    
    Examples of coerce from FortranExpression
    
    Examples of coerce from FiniteFieldHomomorphisms
    
    Examples of coerce from FreeLieAlgebra
    
    Examples of coerce from FortranMatrixCategory
    
    Examples of coerce from FortranMatrixFunctionCategory
    
    Examples of coerce from FileNameCategory
    
    Examples of coerce from ScriptFormulaFormat1
    
    Examples of coerce from ScriptFormulaFormat
    
    Examples of coerce from FortranFunctionCategory
    
    Examples of coerce from FortranProgram
    
    Examples of coerce from FourierSeries
    
    Examples of coerce from FunctionSpace
    
    Examples of coerce from FortranScalarType
    
    Examples of coerce from FortranType
    
    Examples of coerce from FortranVectorCategory
    
    Examples of coerce from FortranVectorFunctionCategory
    
    Examples of coerce from GenericNonAssociativeAlgebra
    
    Examples of coerce from GraphImage
    
    Examples of coerce from GeneralUnivariatePowerSeries
    
    Examples of coerce from Heap
    
    a:Heap INT:= heap [1,2,3,4,5]
    coerce a
    
    Examples of coerce from HexadecimalExpansion
    
    Examples of coerce from HTMLFormat
    
    coerce(sqrt(3+x)::OutputForm)$HTMLFORM
    
    Examples of coerce from InnerAlgebraicNumber
    
    Examples of coerce from IndexCard
    
    Examples of coerce from PolynomialIdeals
    
    Examples of coerce from AssociatedJordanAlgebra
    
    Examples of coerce from CoercibleTo
    
    Examples of coerce from LeftAlgebra
    
    Examples of coerce from LieExponentials
    
    Examples of coerce from AssociatedLieAlgebra
    
    Examples of coerce from LocalPowerSeriesCategory
    
    Examples of coerce from LyndonWord
    
    Examples of coerce from ThreeDimensionalMatrix
    
    Examples of coerce from Magma
    
    Examples of coerce from MappingPackage1
    
    Examples of coerce from MatrixCategory
    
    coerce([1,2,3])@Matrix(INT)
    
    Examples of coerce from MachineComplex
    
    Examples of coerce from MachineFloat
    
    Examples of coerce from MachineInteger
    
    Examples of coerce from MakeCachableSet
    
    Examples of coerce from MathMLFormat
    
    Examples of coerce from ModularField
    
    Examples of coerce from ModMonic
    
    Examples of coerce from ModuleMonomial
    
    Examples of coerce from ModularRing
    
    Examples of coerce from MonoidRing
    
    Examples of coerce from MyExpression
    
    Examples of coerce from MyUnivariatePolynomial
    
    Examples of coerce from NonAssociativeRing
    
    Examples of coerce from NumericalIntegrationProblem
    
    Examples of coerce from NoneFunctions1
    
    Examples of coerce from NumericalODEProblem
    
    Examples of coerce from OrdinaryDifferentialRing
    
    Examples of coerce from OpenMathErrorKind
    
    Examples of coerce from NumericalOptimizationProblem
    
    Examples of coerce from UnivariateSkewPolynomial
    
    Examples of coerce from OrdSetInts
    
    Examples of coerce from OrdinaryWeightedPolynomials
    
    Examples of coerce from Palette
    
    Examples of coerce from PolynomialAN2Expression
    
    Examples of coerce from PoincareBirkhoffWittLyndonBasis
    
    Examples of coerce from NumericalPDEProblem
    
    Examples of coerce from PendantTree
    
    t1:=ptree([1,2,3])
    t2:=ptree(t1,ptree([1,2,3]))
    t2::Tree List PositiveInteger
    
    Examples of coerce from PermutationGroup
    
    y : PERM INT := [[3,5,7,9]]
    z : PERM INT := [1,3,11]
    g : PERMGRP INT := [ y , z ]
    
    x : PERM INT := [[1,3,5],[7,11,9]]
    
    Examples of coerce from Permutation
    
    Examples of coerce from PartialFraction
    
    (13/74)::PFR(INT)
    
    a:=(13/74)::PFR(INT)
    a::FRAC(INT)
    
    Examples of coerce from PiCoercions
    
    Examples of coerce from ProjectiveSpaceCategory
    
    Examples of coerce from Partition
    
    Examples of coerce from Queue
    
    a:Queue INT:= queue [1,2,3,4,5]
    coerce a
    
    Examples of coerce from RadixExpansion
    
    Examples of coerce from ResolveLatticeCompletion
    
    Examples of coerce from ResidueRing
    
    Examples of coerce from RetractableTo
    
    Examples of coerce from RationalFunction
    
    Examples of coerce from Ring
    
    Examples of coerce from RectangularMatrix
    
    Examples of coerce from SparseEchelonMatrix
    
    Examples of coerce from SparseMultivariateTaylorSeries
    
    Examples of coerce from ThreeSpaceCategory
    
    Examples of coerce from SquareMatrix
    
    Examples of coerce from StringAggregate
    
    Examples of coerce from Stack
    
    a:Stack INT:= stack [1,2,3,4,5]
    coerce a
    
    Examples of coerce from Stream
    
    m:=[1,2,3,4,5,6,7,8,9,10,11,12]
    coerce(m)@Stream(Integer)
    m::Stream(Integer)
    
    Examples of coerce from StreamTaylorSeriesOperations
    
    Examples of coerce from SparseUnivariateLaurentSeries
    
    Examples of coerce from SparseUnivariatePuiseuxSeries
    
    Examples of coerce from SparseUnivariateTaylorSeries
    
    Examples of coerce from Switch
    
    Examples of coerce from Symbol
    
    Examples of coerce from SymbolTable
    
    Examples of coerce from Tableau
    
    Examples of coerce from TexFormat1
    
    Examples of coerce from TexFormat
    
    Examples of coerce from TaylorSeries
    
    Examples of coerce from Tuple
    
    t1:PrimitiveArray(Integer):= [i for i in 1..10]
    t2:=coerce(t1)$Tuple(Integer)
    
    Examples of coerce from UnivariateFormalPowerSeries
    
    Examples of coerce from UnivariateLaurentSeriesConstructorCategory
    
    Examples of coerce from UnivariateLaurentSeries
    
    Examples of coerce from UniversalSegment
    
    Examples of coerce from UnivariatePolynomial
    
    Examples of coerce from UnivariatePuiseuxSeriesConstructorCategory
    
    Examples of coerce from UnivariatePuiseuxSeries
    
    Examples of coerce from UnivariateTaylorSeries
    
    Examples of coerce from UnivariateTaylorSeriesCZero
    
    Examples of coerce from Variable
    
    Examples of coerce from TwoDimensionalViewport
    
    Examples of coerce from ViewportPackage
    
    Examples of coerce from Void
    
    Examples of coerce from WeightedPolynomials
    
    Examples of coerce from XAlgebra
    
    Examples of coerce from XFreeAlgebra
    
    Examples of coerce from XPBWPolynomial
    
    Examples of coerce from XPolynomialRing
    
    (1) ->
    committed Sep 25, 2016
Commits on Sep 19, 2016
  1. books/bookvol10.5 add Sven Hammarling chapter

    Goal: Axiom Literate Programming
    
    Note that adding the Hammarling equations forced the addition of
    mathtools.sty... which forced a new version of \matrix... which
    forced a rewrite of several books. Code rot strikes. Sigh.
    
    \index{Acton, F.S.}
    \begin{chunk}{axiom.bib}
    @book{Acto70,
      author = "Acton, F.S.",
      title = "Numerical Methods that (Usually) Work",
      year = "1970",
      publisher = "Harper and Row",
      address = "New York, USA"
    }
    
    \end{chunk}
    
    \index{Acton, F.S.}
    \begin{chunk}{axiom.bib}
    @book{Acto96,
      author = "Acton, F.S.",
      title = "Real Computing Made Real: Preventing Errors in Scientific
               and Engineering Calculations",
      year = "1996",
      publisher = "Princeton University Press",
      address = "Princeton, N.J. USA",
      isbn = "0-691-03663-2"
    }
    
    \end{chunk}
    
    \index{Alefeld, G.}
    \index{Mayer, G.}
    \begin{chunk}{axiom.bib}
    @article{Alef00,
      author = "Alefeld, G. and Mayer, G.",
      title = "Interval analysis: Theory and applications",
      journal = "J. Comput. Appl. Math.",
      volume = "121",
      pages = "421-464",
      year = "2000"
    }
    
    \end{chunk}
    
    \index{Anderson, E.}
    \index{Bai, Z.}
    \index{Bischof, S.}
    \index{Blackford, S.}
    \index{Demmel, J.}
    \index{Dongarra, J. J.}
    \index{DuCroz, J.}
    \index{Greenbaum, A.}
    \index{Hammarling, S.}
    \index{McKenney, A.}
    \index{Sorensen, D. C.}
    \begin{chunk}{axiom.bib}
    @book{Ande99,
      author = "Anderson, E. and Bai, Z. and Bischof, S. and Blackford, S. and
                Demmel, J. and Dongarra, J. J. and DuCroz, J. and Greenbaum, A.
                and Hammarling, S. and McKenney, A. Sorensen, D. C.",
      title = "LAPACK Users' Guide",
      publisher = "SIAM",
      year = "1999",
      isbn = "0-89871-447-8",
      url = "www.netlib.org/lapack/lug/"
    }
    
    \end{chunk}
    
    \index{Bindel, D.}
    \index{Demmel, J.}
    \index{Kahan, W.}
    \index{Marques, O.}
    \begin{chunk}{axiom.bib}
    @article{Bind02,
      author = "Bindel, D. and Demmel, J. and Kahan, W. and Marques, O.",
      title = On computing Givens rotations reliably and efficiently",
      journal = "ACM Trans. Math. Software",
      volume = "28",
      pages = "206-238",
      year = "2002"
    }
    
    \end{chunk}
    
    \index{Blackford, L. S.}
    \index{Cleary, A.}
    \index{Demmel, J.}
    \index{Dhillon, I.}
    \index{Dongarra, J. J.}
    \index{Hammarling, S.}
    \index{Petitet, A.}
    \index{Ren, H.}
    \index{Stanley, K.}
    \index{Whaley, R. C.}
    \begin{chunk}{axiom.bib}
    @article{Blac97,
      author = "Blackford, L. S. and Cleary, A. and Demmel, J. and Dhillon, I.
                and Dongarra, J. J. and Hammarling, S. and Petitet, A. and
                Ren, H. and Stanley, K. and Whaley, R. C.",
      title = "Practical experience in the numerical dangers of heterogeneous
               computing",
      journal = "ACM Trans. Math. Software",
      volume = "23",
      pages = "133-147",
      year = "1997"
    }
    
    \end{chunk}
    
    \index{Brankin, R. W.}
    \index{Gladwell, I.}
    \begin{chunk}{axiom.bib}
    @article{Bran97,
      author = "Brankin, R. W. and Gladwell, I.",
      title = "rksuite\_90: Fortran 90 software for ordinary differential
               equation initial-value problems",
      journal = "ACM Trans. Math. Software",
      volume = "23",
      pages = "402-415",
      year = "1997"
    }
    
    \end{chunk}
    
    \index{Brankin, R. W.}
    \index{Gladwell, I.}
    \index{Shampine, L. F.}
    \begin{chunk}{axiom.bib}
    @techreport{Bran92,
      author = "Brankin, R. W. and Gladwell, I. and Shampine, L. F.",
      title = "RKSUITE: A suite of runge-kutta codes for the initial value
               problem for ODEs",
      year = "1992",
      institution = "Southern Methodist University, Dept of Math.",
      number = "Softreport 92-S1",
      type = "Technical Report"
    }
    
    \end{chunk}
    
    \index{Britton, J. L.}
    \begin{chunk}{axiom.bib}
    @book{Brit92,
      author = "Britton, J. L.",
      title = "Collected Works of A. M. Turing: Pure Mathematics",
      publisher = "North-Holland",
      years = "1992",
      isbn = "0-444-88059-3"
    }
    
    \end{chunk}
    
    \index{Chaitin-Chatelin, F.}
    \index{Fraysse, V.}
    \begin{chunk}{axiom.bib}
    @book{Chai96,
      author = "Chaitin-Chatelin, F. and Fraysse, V.",
      title = "Lectures on Finite Precision Computations",
      publisher = "SIAM",
      year = "1996",
      isbn = "0-89871-358-7"
    }
    
    \end{chunk}
    
    \index{Chan, T. F.}
    \index{Golub, G. H.}
    \index{LeVeque, R. J.}
    \begin{chunk}{axiom.bib}
    @article{Chan83,
      author = "Chan, T. F. and Golub, G. H. and LeVeque, R. J.",
      title = "Algorithms for computing the sample variance: Analysis and
               recommendations",
      journal = "The American Statistician",
      volume = "37",
      pages = "242-247",
      year = "1983"
    }
    
    \end{chunk}
    
    \index{Cools, R.}
    \index{Haegemans, A.}
    \begin{chunk}{axiom.bib}
    @article{Cool03,
      author = "Cools, R. and Haegemans, A.",
      title = "Algorithm 824: CUBPACK: A package for automatic cubature;
               framework description",
      journal = "ACM Trans. Math. Software",
      volume = "29",
      pages = "287-296",
      year = "2003"
    }
    
    \end{chunk}
    
    \index{Cox, M. G.}
    \index{Dainton, M. P.}
    \index{Harris, P. M.}
    \begin{chunk}{axiom.bib}
    @techreport{Coxx00,
      author = "Cox, M. G. and Dainton, M. P. and Harris, P. M.",
      title = "Testing spreadsheets and other packages used in metrology:
               Testing functions for the calculation of standard deviation",
      year = "2000",
      institution = "National Physical Lab, Teddington, Middlesex UK",
      type = "Technical Report",
      number = "NPL Report CMSC07/00"
    }
    
    \end{chunk}
    
    \index{Dodson, D. S.}
    \begin{chunk}{axiom.bib}
    @article{Dods83,
      author = "Dodson, D. S.",
      title = "Corrigendum: Remark on 'Algorithm 539: Basic Linear Algebra
               Subroutines for FORTRAN usage",
      journal = "ACM Trans. Math. Software",
      volume = "9",
      pages = "140",
      year = "1983"
    }
    
    \end{chunk}
    
    \index{Dodson, D. S.}
    \index{Grimes, R. G.}
    \begin{chunk}{axiom.bib}
    @article{Dods82,
      author = "Dodson, D. S. and Grimes, R. G.",
      title = "Remark on algorithm 539: Basic Linear Algebra Subprograms for
               Fortran usage",
      journal = "ACM Trans. Math. Software",
      volume = "8",
      pages = "403-404",
      year = "1982"
    }
    
    \end{chunk}
    
    \index{Dongarra, J. J.}
    \index{DuCroz, J.}
    \index{Hammarling, S.}
    \index{Hanson, R. J.}
    \begin{chunk}{axiom.bib}
    @article{Dong88,
      author = "Dongarra, J. J. and DuCroz, J. and Hammarling, S. and
                Hanson, R. J.",
      title = "An extended set of FORTRAN Basic Linear Algebra Subprograms",
      journal = "ACM Trans. Math. Software",
      volume = "14",
      pages = "1-32",
      year = "1988"
    }
    
    \end{chunk}
    
    \index{Dongarra, J.}
    \index{DuCroz, J.}
    \index{Duff, I. S.}
    \index{Hammarling, S.}
    \begin{chunk}{axiom.bib}
    @article{Dong90,
      author = "Dongarra, J. and DuCroz, J. and Duff, I. S. and Hammarling, S.",
      title = "A set of Level 3 Basic Linear Algebra Subprograms",
      journal = "ACM Trans. Math. Software",
      volume = "16",
      pages = "1-28",
      year = "1990"
    }
    
    \end{chunk}
    
    \index{Dubrulle, A. A.}
    \begin{chunk}{axiom.bib}
    @article{Dubr83,
      author = "Dubrulle, A. A.",
      title = "A class of numerical methods for the computation of Pythagorean
               sums",
      journal = "IBM J. Res. Develop.",
      volume = "27",
      number = "6",
      pages = "582-589",
      year = "1983"
    }
    
    \end{chunk}
    
    \index{Einarsson, B.}
    \begin{chunk}{axiom.bib}
    @book{Eina05,
      author = "Einarsson, B.",
      title = "Accuracy and Reliability in Scientific Computing",
      publisher = "SIAM",
      year = "2005",
      isbn = "0-89871-584-9",
      url = "http://www.nsc.liu.se/wg25/book/"
    }
    
    \end{chunk}
    
    \index{Forsythe, G. E.}
    \begin{chunk}{axiom.bib}
    @article{Fors70,
      author = "Forsythe, G. E.",
      title = "Pitfalls in computations, or why a math book isn't enough",
      journal = "Amer. Math. Monthly",
      volume = "9",
      pages = "931-995",
      year = "1970"
    }
    
    \end{chunk}
    
    \index{Forsythe, G. E.}
    \begin{chunk}{axiom.bib}
    @incollection{Fors69,
      author = "Forsythe, G. E.",
      title = "What is a satisfactory quadratic equation solver",
      booktitle = "Constructive Aspects of the Fundamental Theorem of Algebra",
      pages = "53-61",
      publisher = "Wiley",
      year = "1969"
    }
    
    \end{chunk}
    
    \index{Fox, L.}
    \begin{chunk}{axiom.bib}
    @article{Foxx71,
      author = "Fox, L.",
      title = "How to get meaningless answers in scientific computations (and
               what to do about it)",
      journal = "IMA Bulletin",
      volume = "7",
      pages = "296-302",
      year = "1971"
    }
    
    \end{chunk}
    
    \index{Givens, W.}
    \begin{chunk}{axiom.bib}
    @techreport{Give54,
      author = "Givens, W.",
      title = "Numerical computation of the characteristic values of a real
               symmetric matrix",
      year = "1954",
      institution = "Oak Ridge National Laboratory",
      type = "Technical Report",
      number = "ORNL-1574"
    }
    
    \end{chunk}
    
    \index{Golub, G.H.}
    \begin{chunk}{axiom.bib}
    @article{Golu65,
      author = "Golub, G.H.",
      title = "Numerical methods for solving linear least squares problems",
      journal = "Numer. Math.",
      volume = "7",
      pages = "206-216",
      year = "1965"
    }
    
    \end{chunk}
    
    \index{Golub, Gene H.}
    \index{Van Loan, Charles F.}
    \begin{chunk}{axiom.bib}
    @book{Golu89,
      author = "Golub, Gene H. and Van Loan, Charles F.",
      title = "Matrix Computations",
      publisher = "Johns Hopkins University Press",
      year = "1989",
      isbn = "0-8018-3772-3"
    }
    
    \end{chunk}
    
    \index{Golub, Gene H.}
    \index{Van Loan, Charles F.}
    \begin{chunk}{axiom.bib}
    @book{Golu96,
      author = "Golub, Gene H. and Van Loan, Charles F.",
      title = "Matrix Computations",
      publisher = "Johns Hopkins University Press",
      isbn = "978-0-8018-5414-9",
      year = "1996"
    }
    
    \end{chunk}
    
    \index{Hammarling S.}
    \begin{chunk}{axiom.bib}
    @article{Hamm85,
      author = "Hammarling S.",
      title = " The Singular Value Decomposition in Multivariate Statistics",
      journal = "ACM Signum Newsletter",
      volume = "20",
      number = "3",
      pages = "2--25",
      year = "1985"
    }
    
    \end{chunk}
    
    \index{Hammarling, Sven}
    \begin{chunk}{axiom.bib}
    @book{Hamm05,
      author = "Hammarling, Sven",
      title = "An Introduction to the Quality of Computed Solutions",
      booktitle = "Accuracy and Reliability in Scientific Computing",
      year = "2005",
      publisher = "SIAM",
      pages = "43-76",
      url = "http://eprints.ma.man.ac.uk/101/",
      paper = "Hamm05.pdf"
    }
    
    \end{chunk}
    
    \index{Hargreaves, G.}
    \begin{chunk}{axiom.bib}
    @mastersthesis{Harg02,
      author = "Hargreaves, G.",
      title = "Interval analysis in MATLAB",
      school = "University of Manchester, Dept. of Mathematics",
      year = "2002"
    }
    
    \end{chunk}
    
    \index{Higham, Nicholas J.}
    \begin{chunk}{axiom.bib}
    @book{High02,
      author = "Higham, Nicholas J.",
      title = "Accuracy and stability of numerical algorithms",
      publisher = "SIAM",
      isbn = "0-89871-521-0",
      year = "2002"
    }
    
    \end{chunk}
    
    \index{Higham, Nicholas J.}
    \begin{chunk}{axiom.bib}
    @article{High88,
      author = "Higham, Nicholas J.",
      title = "FORTRAN codes for estimating the one-norm of a real or complex
               matrix, with applications to condition estimation",
      journal = "ACM Trans. Math. Soft",
      volume = "14",
      number = "4",
      pages = "381-396",
      year = "1988"
    }
    
    \end{chunk}
    
    \begin{chunk}{axiom.bib}
    @misc{IEEE85,
      author = "IEEE",
      title = "ANSI/IEEE Standard for Binary Floating Point Arithmetic:
               Std 754-1985",
      publisher = "IEEE Press",
      year = "1985"
    }
    
    \end{chunk}
    
    \begin{chunk}{axiom.bib}
    @misc{IEEE87,
      author = "IEEE",
      title = "ANSI/IEEE Standard for Radix Independent Floating Point Arithmetic:
               Std 854-1987",
      publisher = "IEEE Press",
      year = "1987"
    }
    
    \end{chunk}
    
    \index{Kn\"usel, L.}
    \begin{chunk}{axiom.bib}
    @article{Knus98,
      author = {Kn\"usel, L.},
      title = "On the accuracy of statistical distributions in Microsoft
               Excel 97",
      journal = "Comput. Statist. Data Anal.",
      volume = "26",
      pages = "375-377",
      year = "1998"
    }
    
    \end{chunk}
    
    \index{Kreinovich, V.}
    \begin{chunk}{axiom.bib}
    @misc{Krei05,
      author = "Kreinovich, V.",
      title = "Interval cmoputations",
      year = "2005",
      url = "http://www.cs.utep.edu/interval-comp/"
    }
    
    \end{chunk}
    
    \index{Lawson, C. L.}
    \index{Hanson, R. J.}
    \begin{chunk}{axiom.bib}
    @book{Laws75,
      author = "Lawson, C. L. and Hanson, R. J.",
      title = "Solving Least Squares Problems",
      publisher = "Prentice-Hall",
      year = "1974"
    }
    
    \end{chunk}
    
    \index{Lawson, C. L.}
    \index{Hanson, R. J.}
    \begin{chunk}{axiom.bib}
    @book{Laws95,
      author = "Lawson, C. L. and Hanson, R. J.",
      title = "Solving Least Squares Problems",
      publisher = "SIAM",
      isbn = "0-89871-356-0",
      year = "1995"
    }
    
    \end{chunk}
    
    \index{Lawson, C. L.}
    \index{Hanson, R. J.}
    \index{Kincaid, D.}
    \index{Krogh, F. T.}
    \begin{chunk}{axiom.bib}
    @article{Laws79,
      author = "Lawson, C. L. and Hanson, R. J. and Kincaid, D. and Krogh, F. T.",
      title = "Basic Linear Algebra Subprograms for FORTRAN usage",
      journal = "ACM Trans. Math. Software",
      volume = "5",
      pages = "308-323",
      year = "1979"
    }
    
    \end{chunk}
    
    \index{Martin, R. S.}
    \index{Wilkinson, J. H.}
    \begin{chunk}{axiom.bib}
    @article{Mart68,
      author = "Martin, R. S. and Wilkinson, J. H.",
      title = "Similarity reduction ofa general matrix to Hessenberg form",
      journal = "Numer. Math.",
      volume = "12",
      pages = "349-368",
      year = "1968"
    }
    
    \end{chunk}
    
    \begin{chunk}{axiom.bib}
    @misc{Math05,
      author = "MathWorks",
      title = "MATLAB",
      publisher = "The Mathworks, Inc.",
      url = "http://www.mathworks.com"
    }
    
    \end{chunk}
    
    \index{McCullough, B. D.}
    \index{Wilson, B.}
    \begin{chunk}{axiom.bib}
    @article{Mccu02,
      author = "McCullough, B. D. and Wilson, B.",
      title = "On the accuracy of statistical procedures in Microsoft Excel
               2000 and Excel XP",
      journal = "Comput. Statist. Data Anal.",
      volume = "40",
      pages = "713-721",
      year = "2002"
    }
    
    \end{chunk}
    
    \index{McCullough, B. D.}
    \index{Wilson, B.}
    \begin{chunk}{axiom.bib}
    @article{Mccu99,
      author = "McCullough, B. D. and Wilson, B.",
      title = "On the accuracy of statistical procedures in Microsoft Excel 97",
      journal = "Comput. Statist. Data Anal.",
      volume = "31",
      pages = "27-37",
      year = "1999"
    }
    
    \end{chunk}
    
    \index{Metcalf, M.}
    \index{Reid, J. K.}
    \begin{chunk}{axiom.bib}
    @book{Metc96,
      author = "Metcalf, M. and Reid, J. K.",
      title = "Fortran 90/95 Explained",
      publisher = "Oxford University Press",
      year = "1996"
    }
    
    \end{chunk}
    
    \index{Metcalf, M.}
    \index{Reid, J. K.}
    \index{Cohen, M.}
    \begin{chunk}{axiom.bib}
    @book{Metc04,
      author = "Metcalf, M. and Reid, J. K. and Cohen, M.",
      title = "Fortran 95/2003 Explained",
      publisher = "Oxford University Press",
      year = "2004",
      isbn = "0-19-852693-8"
    }
    
    \end{chunk}
    
    \index{Moler, C.}
    \index{Morrison, D.}
    \begin{chunk}{axiom.bib}
    @article{Mole83,
      author = "Moler, C. and Morrison, D.",
      title = "Replacing square roots by Pythagorena sums",
      journal = "IBM J. Res. Develop.",
      volume = "27",
      number = "6",
      pages = "577-581",
      year = "1983"
    }
    
    \end{chunk}
    
    \index{Moore, R. E.}
    \begin{chunk}{axiom.bib}
    @books{Moor79,
      author = "Moore, R. E.",
      title = "methods and Applications of Interval Analysis",
      publisher = "SIAM",
      year = "1979"
    }
    
    \end{chunk}
    
    \begin{chunk}{axiom.bib}
    @misc{NAGa05,
      author = "Numerical Algorithms Group",
      title = "The NAG Library",
      url = "http://www.nag.co.uk/numeric",
      year = "2005"
    }
    
    \end{chunk}
    
    \begin{chunk}{axiom.bib}
    @misc{NAGb05,
      author = "Numerical Algorithms Group",
      title = "The NAG Fortran Library Manual",
      url = "http://www.nag.co.uk/numeric/fl/manual/html/FLlibrarymanual.asp",
      year = "2005"
    }
    
    \end{chunk}
    
    \index{Overton, M. L.}
    \begin{chunk}{axiom.bib}
    @book{Over01,
      author = "Overton, M. L.",
      title = "Numerical Computing with IEEE Floating Point Arithmetic",
      publisher = "SIAM",
      year = "2001",
      isbn = "0-89871-482-6"
    }
    
    \end{chunk}
    
    \index{Piessens, R.}
    \index{de Doncker-Kapenga, E.},
    \index{\"Uberhuber, C. W.}
    \index{Kahaner, D. K.}
    \begin{chunk}{axiom.bib}
    @book{Pies83,
      author = {Piessens, R. and de Doncker-Kapenga, E. and \"Uberhuber, C. W.
                and Kahaner, D. K.},
      title = "QUADPACK - A Subroutine Package for Automatic Integration",
      publisher = "Springer-Verlag",
      year = "1983"
    }
    
    \end{chunk}
    
    \index{Priest, D. M.}
    \begin{chunk}{axiom.bib}
    @article{Prie04,
      author = "Priest, D. M.",
      title = "Efficient scaling for complex division",
      journal = "ACM Trans. Math. Software",
      volume = "30",
      pages = "389-401",
      year = "2004"
    }
    
    \end{chunk}
    
    \index{Rump, S. M.}
    \begin{chunk}{axiom.bib}
    @InProceedings{Rump99,
      author = "Rump, S. M.",
      title = "INTLAB - INTerval LABoratory",
      booktitle = "Developments in Reliable Computing",
      pages = "77-104",
      publisher = "Kluwer Academic",
      year = "1999"
    }
    
    \end{chunk}
    
    \index{Shampine, L. F.}
    \index{Gladwell, I.}
    \begin{chunk}{axiom.bib}
    @InProceedings{Sham92,
      author = "Shampine, L. F. and Gladwell, I.",
      title = "The next generation of runge-kutta codes",
      booktitle = "Computational Ordinary Differential Equations",
      pages = "145-164",
      publisher = "Oxford University Press",
      year = "1992"
    }
    
    \end{chunk}
    
    \index{Smith, R. L.}
    \begin{chunk}{axiom.bib}
    @article{Smit62,
      author = "Smith, R. L.",
      title = "Algorithm 116: Complex division",
      journal = "Communs. Ass. comput. Mach.",
      volume = "5",
      pages = "435",
      year = "1962"
    }
    
    \end{chunk}
    
    \index{Stewart, G. W.}
    \begin{chunk}{axiom.bib}
    @book{Stew98,
      author = "Stewart, G. W.",
      title = "Matrix Algorithms: Basic Decompositions, volume I",
      publisher = "SIAM",
      year = "1998",
      isbn = "0-89871-414-1"
    }
    
    \end{chunk}
    
    \index{Stewart, G. W.}
    \begin{chunk}{axiom.bib}
    @article{Stew85,
      author = "Stewart, G. W.",
      title = "A note on complex division",
      journal = "ACM Trans. Math. Software",
      volume = "11",
      pages = "238-241",
      year = "1985"
    }
    
    \end{chunk}
    
    \index{Stewart, G. W.}
    \index{Sun, J.}
    \begin{chunk}{axiom.bib}
    @book{Stew90,
      author = "Stewart, G. W. and Sun, J.",
      title = "Matrix Perturbation Theory",
      publisher = "Academic Press",
      year = "1990"
    }
    
    \end{chunk}
    
    \index{Turing, A. M.}
    \begin{chunk}{axiom.bib}
    @article{Turi48,
      author = "Turing, A. M.",
      title = "Rounding-off errors in matrix processes",
      journal = "Q. J. Mech. Appl. Math.",
      volume = "1",
      pages = "287-308",
      year = "1948"
    }
    
    \end{chunk}
    
    \index{Vignes, J.}
    \begin{chunk}{axiom.bib}
    @article{Vign93,
      author = "Vignes, J.",
      title = "A stochastic arithmetic for reliable scientific computation",
      jouirnal = "Math. and Comp. in Sim.",
      volume = "25",
      pages = "233-261",
      year = "1993"
    }
    
    \end{chunk}
    
    \index{Wilkinson, J. H.}
    \begin{chunk}{axiom.bib}
    @book{Wilk63,
      author = "Wilkinson, J. H.",
      title = "Rounding Erroors in Algebraic Processes",
      publisher = "HMSO",
      series = "Notes on Applied Science, No. 32",
      year = "1963"
    }
    
    \end{chunk}
    
    \index{Wilkinson, J. H.}
    \begin{chunk}{axiom.bib}
    @book{Wilk65,
      author = "Wilkinson, J. H.",
      title = "The Algebraic Eigenvalue Problem",
      publisher = "Oxford University Press",
      year = "1965"
    }
    
    \end{chunk}
    
    \index{Wilkinson, J. H.}
    \begin{chunk}{axiom.bib}
    @InProceedings{Wilk84,
      author = "Wilkinson, J. H.",
      title = "The perfidious polynomial",
      booktitle = "Studies in Numerical Analysis",
      volume = "24",
      chapter = "1",
      pages = "1-28",
      year = "1984"
    }
    
    \end{chunk}
    
    \index{Wilkinson, J. H.}
    \begin{chunk}{axiom.bib}
    @article{Wilk86,
      author = "Wilkinson, J. H.",
      title = "Error analysis revisited",
      journal = "IMA Bulletin",
      volume = "22",
      pages = "192-200",
      year = "1986"
    }
    
    \end{chunk}
    
    \index{Wilkinson, J. H.}
    \begin{chunk}{axiom.bib}
    @article{Wilk61,
      author = "Wilkinson, J. H.",
      title = "Error analysis of diret methods of matrix inversion",
      journal = "J. ACM",
      volume = "8",
      pages = "281-330",
      year = "1961"
    }
    
    \end{chunk}
    
    \index{Wilkinson, J. H.}
    \begin{chunk}{axiom.bib}
    @article{Wilk85,
      author = "Wilkinson, J. H.",
      title = "The state of the art in error analysis",
      journal = "NAG Newsletter",
      volume = "2/85",
      pages = "5-28",
      year = "1985"
    }
    
    \end{chunk}
    
    \index{Wilkinson, J. H.}
    \begin{chunk}{axiom.bib}
    @article{Wilk60,
      author = "Wilkinson, J. H.",
      title = "Error analysis of floating-point computation",
      journal = "Numer. Math.",
      volume = "2",
      pages = "319-340",
      year = "1960"
    }
    
    \end{chunk}
    
    \index{Wilkinson, J. H.}
    \index{Reinsch, C.}
    \begin{chunk}{axiom.bib}
    @book{Wilk71,
      author = "Wilkinson, J. H.",
      title = "Handbook for Automatic Computation, V2, Linear Algebra",
      publisher = "Springer-Verlag",
      year = "1971"
    }
    
    \end{chunk}
    committed Sep 19, 2016
Commits on Sep 11, 2016
  1. books/bookvolbib add Hamm05, Quality Computed Solutions

    Goal: Axiom Literate Programming
    
    Permission to quote article.
    
    \index{Hammarling, Sven}
    \begin{chunk}{axiom.bib}
    @book{Hamm05,
      author = "Hammarling, Sven",
      title = "An Introduction to the Quality of Computed Solutions",
      booktitle = "Accuracy and Reliability in Scientific Computing",
      year = "2005",
      publisher = "SIAM",
      pages = "43-76",
      url = "http://eprints.ma.man.ac.uk/101/",
      paper = "Hamm05.pdf"
    }
    
    \end{chunk}
    committed Sep 11, 2016
Commits on Sep 10, 2016
  1. books/bookvolbib add Hamm05, Quality Computed Solutions

    Goal: Axiom Literate Programming
    
    \index{Hammarling, Sven}
    \begin{chunk}{axiom.bib}
    @misc{Hamm05,
      author = "Hammarling, Sven",
      title = "An Introduction to the Quality of Computed Solutions",
      year = "2005",
      url = "http://eprints.ma.man.ac.uk/101/",
      paper = "Hamm05.pdf"
    }
    
    \end{chunk}
    committed Sep 10, 2016
Commits on Aug 23, 2016
  1. src/input/spadcall.input demonstrate Spad as a DSL over Lisp

    Goal: Axiom Literate Programming
    
    The Spad language is nothing more than a domain-specific language
    in a lisp image. It is possible to use the lower level machinery
    to execute algebra code without using the usual interpreter.
    committed Aug 23, 2016
Commits on Aug 18, 2016
  1. books/bookvol4 fix github #1, a typesetting error in bookvol4, p18

    Goal: Axiom Maintenance
    committed Aug 18, 2016
  2. books/bookvol5 fix Make/build failure (#5)

    Goal: Axiom Maintenance
    
    Date: Mon, 15 Aug 2016 13:14:38 -0700
    From: volmike <notifications@github.com>
    Subject: [daly/axiom] Make/build failure (#5)
    
    Error: UNBOUND-VARIABLE :NAME |sIG{DODOITBUTTON}{STRING|
    Fast links are on: do (si::use-fast-links nil) for debugging
    Signalled by LOAD.
    UNBOUND-VARIABLE :NAME |sIG{DODOITBUTTON}{STRING|
    
    Broken at LOAD.  Type :H for Help.
        1  Return to top level.
    BOOT>>make[3]: *** [/home/user/axiom/obj/mint/bin/depsys] Error 255
    rm /home/user/axiom/int/interp/parsing.lisp /home/user/axiom/int/interp/nocompil.lisp /home/user/axiom/int/interp/sys-pkg.lisp /home/user/axiom/int/interp/util.lisp
    make[3]: Leaving directory `/home/user/axiom/src/interp'
    make[2]: *** [interpdir] Error 2
    make[2]: Leaving directory `/home/user/axiom/src'
    make[1]: *** [srcdir] Error 2
    make[1]: Leaving directory `/home/user/axiom'
    make: *** [all] Error 2
    committed Aug 18, 2016
Commits on Aug 16, 2016
  1. books/bookvol7.1 improve literate documentation

    Goal: Axiom Literate Programming
    committed Aug 16, 2016
Commits on Aug 12, 2016
  1. books/bookvol7.1 improve literate documentation

    Goal: Axiom Literate Programming
    committed Aug 12, 2016
Commits on Aug 10, 2016
  1. books/bookvol7.1 improve literate documentation

    Goal: Axiom Literate Programming
    committed Aug 10, 2016
Commits on Aug 9, 2016
  1. books/bookvol7.1 improve literate documentation

    Goal: Axiom Literate Programming
    committed Aug 9, 2016
Commits on Aug 7, 2016
  1. books/bookvol7.1 improve literate documentation

    Goal: Axiom Literate Programming
    committed Aug 7, 2016
Commits on Aug 6, 2016
  1. books/bookvol7.1 improve literate documentation

    Goal: Axiom Literate Programming
    committed Aug 6, 2016
  2. books/bookvolbug bug 7320: bookvol7.1 ugInOutFortranPage fails}

    Goal: Axiom Literate Programming
    
    \subsection{bug 7320: bookvol7.1 ugInOutFortranPage fails}
    \begin{verbatim}
    
    Attempting to format page crashes hyperdoc
    
    Reference
     -> Axiom Book
      -> Input Files and Output Styles
       -> Fortran Format
    
    \end{chunk}
    committed Aug 6, 2016
Commits on Aug 5, 2016
  1. books/bookvolbib Axiom Citations in the Literature

    Goal: Axiom Literate Programming
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @misc{Fate13a,
      author = "Fateman, Richard J.",
      title = "Rational Function Computing with Poles and Residues",
      url = "http://www.cs.berkeley.edu/~/fateman/papers/openmathcrit.pdf",
      year = "2013",
      abstract =
        "Computer algebra systems (CAS) usually support computation with exact
        or approximate rational functions as ratios of polynomials in
        ``expanded form'' with explicit coefficients. We examine the
        consequences of introducing a partial-fraction type of form in which
        some of the usual rational operations can be implemented in
        substantially faster times. In this form an expression in one
        variable, say $x$, is expressed as a polynomial in $x$ plus a sum of
        terms each of which has a denominator $x-c$ perhaps to an integer
        power, where $c$ is in general a complex constant. We show that some
        common operations including rational function addition,
        multiplication, and matrix determinant calculation can be performed
        many times faster than in the conventional representation. Polynomial
        GCD operations, the costliest part of rational additions, are entirely
        eliminated. Applicaiton of Cauchy's integral theorem allow for trivial
        integration of an expression around a closed contour. In some cases
        the approximate evaluation of transcendental functions can be
        accelerated, especially in parallel, by evaluation of a formula in
        pole+residue form.",
      paper = "Fate13a.pdf"
    }
    
    \end{chunk}
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @inproceedings{Fate03a,
      author = "Fateman, Richard J.",
      title = "High-level proofs of mathematical programs using automatic
               differentiation, simplification, and some common sense",
      booktitle = "Proc. ISSAC 2003",
      pages = "88-94",
      year = "2003",
      isbn = "1-58113-641-2",
      abstract =
        "One problem in applying elementary methods to prove correctness of
        interesting scientific programs is the large discrepancy in level of
        discourse between low-level proof methods and the logic of scientific
        calculation, especially that used in a complex numerical program. The
        justification of an algorithm typically relies on algebra or analysis,
        but the correctness of the program requires that the arithmetic
        expressions are written correctly and that iterations converge to
        correct values in spite of truncation of infinite processes or series
        and the commission of numerical roundoff errors. We hope to help
        bridge this gap by showing how we can, in some cases, state a
        high-level requirement and by using a computer algebra system (CAS)
        demonstrate that a program satisfies that requirement. A CAS can
        contribute program manipulation, partial evaluation, simplification or
        other algorithmic methods. A novelty here is that we add to the usual
        list of techniques automatic differentiation, a method already widely
        used in optimization contexts where algorithms are differentiated. We
        sketch a proof of a numerical program to compute sine, and display a
        related approach to a version of a Bessel function algorithm for J0(x)
        based on a recurrence.",
      paper = "Fate03a.pdf"
    }
    
    \end{chunk}
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @misc{Fate07,
      author = "Fateman, Richard J.",
      title = "Rational Function Computing with Poles and Residues",
      url = "http://www.cs.berkeley.edu/~/fateman/papers/qd.pdf",
      year = "2007",
      abstract =
        "In a numerical calculation sometimes we need higher-than
        double-precision floating-point arithmetic to allow us to be confident
        of a result. One alternative is to rewrite the program to use a
        software package implementing arbitrary-precision extended
        floating-point arithmetic such as ARPREC or MPFR, and try to choose a
        suitable precision.
    
        Such an arithmetic scheme, in spite of helpful tools, may be
        inconvenient to write. There are also facilities in computer algebra
        systems (CAS) for such software-implemented ``bigfloats.'' These
        facilities are convenient if one is already using the CAS. In any of
        these situations the bigfloats may be rather slow, a cost of its
        generality.
    
        There are possibilities intermediate between the largest hardware
        floating-point format and the general arbitrary-precision software
        which combine a considerable (but not arbitrary) amount of extra
        precision with a (relatively speaking) modest factor loss in
        speed. Sometimes merely doubling the number of bits in a
        double-floating-point fraction is enough, in which case arithmetic on
        double-double (DD) operands would suffice. Another possibility is to
        go for yet another doubling to quad-double (QD) arithmetic: instead of
        using the machine double-floats to give about 16 decimal digits of
        precision, QD supplies about 64 digits. DD and QD as used here provide
        the same exponent range as ordinary double.
    
        Here we describe how we incorporated QD arithmetic implemented in a
        library into a Common Lisp system, providing a smooth interface while
        adding only modest overhead to the run-time costs (compared to
        accessing the library from C or C++). One advantage is that we keep
        the program text almost untouched while switching from double to
        quad-double. Another is that the programs can be written, debugged,
        and run in an interactive environment. Most of the lessons from QD can
        be used for other versions of arithmetic which can be embedded in
        Lisp, including MPFR, for indefinite (arbitrary) precision, should QD
        provide inadequate precision or range.",
      paper = "Fate07.pdf,
      keywords = "axiomref"
    }
    
    \end{chunk}
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @misc{Fate99b,
      author = "Fateman, Richard J.",
      title = "Generation and Optimization of Numerical Programs by
               Symbolic Mathematical Methods",
      url = "http://www.cs.berkeley.edu/~/fateman/papers/RIMS.pdf",
      year = "1999",
      abstract =
        "Symbolic mathematical methods and systems
        \begin{itemize}
        \item support scientific and engineering ``problem solving environments''
        (PSEs),
        \item The specific manipulation of mathematical models as a precursor
        to the coding of algorithms
        \item Expert system selection of modules from numerical libraries and
        other facilities
        \item The production of custom numerical software such as derivatives
        or non-standard arithmetic code-generation packages,
        \item The complete solution of certain classes of mathematical problems
        that simply cannot be handled solely by conventional floating-point
        computation.
        \end{itemize}
    
        Viewing computational objects and algorithms from a symbolic
        perspective and then specializing them to numerical or graphical views
        provides substantial additional flexibility over a more conventional view.
    
        We also consider interactive symbolic computing as a tool to provide
        an organizing principle or glue among otherwise dissimilar components.",
      paper = "Fate99b.pdf",
      keywords = "axiomref"
    }
    
    \end{chunk}
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @misc{Fate09,
      author = "Fateman, Richard J.",
      title = "Rational Integration, Simplified",
      url = "http://www.cs.berkeley.edu/~/fateman/papers/root-integ.pdf",
      year = "2009",
      abstract =
        "After all this computer algebra stuff, and several PhD theses in
        the last few decades, what more could we say about symbolic
        rational function integration?
    
        How about a closed formula for the result, subject to a few algebraic
        side-conditions, which works even with parameters in the denominator?",
      paper = "Fate09.pdf"
    }
    
    \end{chunk}
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @misc{Fate09a,
      author = "Fateman, Richard J.",
      title = "Simplifying RootSum Expressions",
      url = "http://www.cs.berkeley.edu/~/fateman/papers/rootsum.pdf",
      year = "2009",
      abstract =
        "It's useful to sum an expression with a parameter varying over all
        the roots of a given polynomial. Here's a defense of that statement
        and a method to do the task.",
      paper = "Fate09a.pdf"
    }
    
    \end{chunk}
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @misc{Fate02a,
      author = "Fateman, Richard J.",
      title = "Symbolic Execution Merges Construction, Debugging and Proving",
      url = "http://www.cs.berkeley.edu/~/fateman/papers/symex.pdf",
      year = "2002",
      abstract =
        "There is naturally an interest in any technology which promises to
        assist us in producing correct programs. Some efforts attempt to
        insure correct programs by making their construction simpler. Some
        efforts are oriented toward increasing the effectiveness of testing to
        make the programs appear to perform as required. Other efforts are
        directed to prove the correctness of the resulting program. Symbolic
        execution, in which symbols instead of numbers are used in what
        appears to be a numerical program, is an old but to-date still not
        widely-used technique. It has been available in various forms for
        decades from the computer algebra community. Symbolic execution has
        the potential to assist in all these phases: construction, debugging,
        and proof. We describe how this might work specifically with regard to
        our own recent experience in the construction of correct linear
        algebra programs for structured matrices and LU factorization. We show
        how developing these programs with a computer algebra system, and then
        converting incrementally to use more efficient forms. Frequent symbolic
        execution of the algorithms, equivalent to testing over infinite test
        sets, aids in debugging, while strengthening beliefs that the correctness
        of results is an algebraic truth rather than an accident.",
      paper = "Fate02a.pdf"
    }
    
    \end{chunk}
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @misc{Fate03b,
      author = "Fateman, Richard J.",
      title = "Manipulation of Matrices Symbolically",
      url = "http://www.cs.berkeley.edu/~/fateman/papers/symmat2.pdf",
      year = "2003",
      abstract =
        "Traditionally, matrix algebra in computer algebra systems is
        ``implemented'' in three ways:
        \begin{itemize}
        \item numeric explicit computation in a special arithmetic domain:
        exact rational or integer, high-precision software floating-point,
        interval, or conventional hardware floating-point.
        \item ‘symbolic’ explicit computation with polynomial or other
        expression entries,
        \item (implicit) matrix computation with symbols defined over a
        (non-commuting) ring.
        \end{itemize}
        Manipulations which involve matrices of indefinite size (n × m) or
        perhaps have components which are block submatrices of indefinite size
        have little or no support in general-purpose computer algebra systems,
        in spite of their importance in theorems, proofs, and generation of
        programs. We describe some efforts to design and implement tools for
        this mode of thinking about matrices in computer systems.",
      paper = "Fate03b.pdf"
    }
    
    \end{chunk}
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @misc{Fate08b,
      author = "Fateman, Richard J.",
      title = "Applications and Methods for Recognition of (Anti)-Symmetric
               Functions",
      url = "http://www.cs.berkeley.edu/~/fateman/papers/symmetry.pdf",
      year = "2008",
      abstract =
        "One of the important advantages held by computer algebra systems (CAS)
        over purely-numerical computational frameworks is that the CAS can
        provide a higher-level ``symbolic'' viewpoint for problem
        solving. Sometimes this can convert apparently impossible problems to
        trivial ones. Sometimes the symbolic perspective can provide
        information about questions which cannot be directly answered, or
        questions which might be hard to pose. For example, we might be able
        to analyze the asymptotic behavior of a solution to a differential
        equation even though we cannot solve the equation. One route to
        implicitly solving problems is the use of symmetry arguments. In this
        paper we suggest how, through symmetry, one can solve a large class of
        definite integration problems, including some that we found could not
        be solved by computer algebra systems. One case of symmetry provides
        for recognition of periodicity, and this solves additional problems,
        since removal of periodic components can be important in integration
        and in asymptotic expansions.",
      paper = "Fate08b.pdf"
    }
    
    \end{chunk}
    
    \index{Fateman, Richard J.}
    \begin{chunk}{axiom.bib}
    @phdthesis{Fate72,
      author = "Fateman, Richard J.",
      title = "Essays in Algebraic Simplification",
      url = "http://www.cs.berkeley.edu/~/fateman/papers/tr-95.pdf",
      institution = "MIT",
      comment = "MAC TR-95 technical report",
      year = "1972",
      abstract =
        "This thesis consists of essays on several aspects of the problem
        of algebraic simplification by computer. We first discuss a pattern
        matching system intended to recognize non-obvious occurrences of
        patterns within Algebraic expression. A user of such a system can
        ``teach'' the computer new simplification rules. Then we report on
        new applications of canonical simplification of rational functions.
        These applications include techniques for picking out coefficients,
        and for substituting for summs, products, quotients, etc. Our final
        essay is on a new, practical, canonical simplification algorithms
        for radical expressions (i.g. algebraic expressions including roots
        of polynomials). The effectiveness of the procedure is assured
        through proofs of appropriate properties of the simplified forms.
        Two appendices describe MACSYM, a computer system for algebraic
        manipulations, which served as the basis for this work.",
      paper = "Fate72.pdf"
    }
    
    \end{chunk}
    
    \index{Redfield, J.Howard}
    \begin{chunk}{axiom.bib}
    @article{Redf27,
      author = "Redfield, J.Howard",
      title = "The Theory of Group-Reduced Distributions",
      journal = "American J. Math.",
      volume = "49",
      number = "3",
      year = "1927",
      pages = "433-455"
    }
    
    \end{chunk}
    
    \index{Judson, Tom}
    @book{Juds15,
      author = "Judson, Tom",
      title = "Abstract Algebra: Theory and Applications",
      year = "2015",
      publisher = "Tom Judson",
      url = "http://abstract.ups.edu/download/aata-20150812.pdf",
      paper = "Juds15.pdf"
    }
    
    \index{Judson, Tom}
    \index{Beezer, Rob}
    @book{Beez15,
      author = "Judson, Tom and Beezer, Rob",
      title = "Abstract Algebra: Theory and Applications",
      year = "2015",
      publisher = "Tom Judson",
      url = "http://abstract.ups.edu/download/aata-20150812-sage-6.8.pdf",
      paper = "Beez15.pdf"
    }
    
    \index{Axiom Authors}
    \begin{chunk}{axiom.bib}
    @book{Bookbug,
      author = "Axiom Authors",
      title = "Volume BugList: Axiom Bugs",
      url = "http://axiom-developer.org/axiom-website/bookvolbug.pdf",
      publisher = "Axiom Project",
      year = "2016"
    }
    
    \end{chunk}
    committed Aug 5, 2016
  2. books/bookvolbug: add todo 341: merge endpapers with text

    Goal: Axiom Literate Programming
    
    The books/endpaper.pamphlet should be added to the Jenks book
    committed Aug 5, 2016