# daly/axiom

Commits on Nov 16, 2016
1. 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. Goal: Axiom Maintenance
committed Nov 14, 2016
Commits on Nov 13, 2016
1. Goal: Axiom Maintenance
committed Nov 13, 2016
2. …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. 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. 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. 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. 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. 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. 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. Goal: Axiom Literate Programming committed Oct 25, 2016 Commits on Oct 24, 2016 1. 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. 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"
paper = "Case16.pdf"
}

\end{chunk}
committed Oct 8, 2016
Commits on Oct 4, 2016
1. Goal: Axiom Literate Programming

\href{http://axiom-developer.org/axiom-website/VisualGroupTheory/Macauley.html#1.1}{rubiksGroup}
committed Oct 4, 2016
Commits on Oct 3, 2016
1. 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. 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. Goal: Axiom Collaboration
committed Oct 1, 2016
Commits on Sep 27, 2016
1. Goal: Axiom Maintenance
committed Sep 27, 2016
Commits on Sep 25, 2016
1. Goal: Axiom Literate Programming

\index{Salomone, Matthew}
\begin{chunk}{axiom.bib}
@misc{Salo16,
author = "Salomone, Matthew",
title = "Exploring Abstract Algebra II",
year = "2016",

\end{chunk}
committed Sep 25, 2016
2. 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.

--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}

(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
[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
) 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 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. Goal: Axiom Literate Programming

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",
}

\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",
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.}
\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{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}

\begin{chunk}{axiom.bib}
@book{Eina05,
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
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",
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",
year = "1999"
}

\end{chunk}

\index{Shampine, L. F.}
\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",
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",
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. 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. 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. 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. Goal: Axiom Maintenance
committed Aug 18, 2016
2. Goal: Axiom Maintenance

Date: Mon, 15 Aug 2016 13:14:38 -0700
Subject: [daly/axiom] Make/build failure (#5)

Error: UNBOUND-VARIABLE :NAME |sIG{DODOITBUTTON}{STRING|
UNBOUND-VARIABLE :NAME |sIG{DODOITBUTTON}{STRING|

Broken at LOAD.  Type :H for Help.
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. Goal: Axiom Literate Programming
committed Aug 16, 2016
Commits on Aug 12, 2016
1. Goal: Axiom Literate Programming
committed Aug 12, 2016
Commits on Aug 10, 2016
1. Goal: Axiom Literate Programming
committed Aug 10, 2016
Commits on Aug 9, 2016
1. Goal: Axiom Literate Programming
committed Aug 9, 2016
Commits on Aug 7, 2016
1. Goal: Axiom Literate Programming
committed Aug 7, 2016
Commits on Aug 6, 2016
1. Goal: Axiom Literate Programming
committed Aug 6, 2016
2. 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. 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
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
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
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
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
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",
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",
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. Goal: Axiom Literate Programming

The books/endpaper.pamphlet should be added to the Jenks book`
committed Aug 5, 2016