From b81fc0eb48b68c421b7a2c0cc90ed1719656348f Mon Sep 17 00:00:00 2001
From: Tim Daly <daly@axiom-developer.org>
Date: Sat, 11 Jul 2015 17:53:55 -0400
Subject: [PATCH] books/bookvol10.3, src/input/intlf,series minor test fixes

Goal: Clean Axiom Test Suite

Minor test fixes.
---
 books/bookvol10.3.pamphlet      |  644 ++++++++++++++++++++-------------------
 changelog                       |   12 +-
 patch                           |   14 +-
 src/axiom-website/patches.html  |    2 +
 src/input/intlf.input.pamphlet  |    1 +
 src/input/series.input.pamphlet |    2 -
 6 files changed, 338 insertions(+), 337 deletions(-)

diff --git a/books/bookvol10.3.pamphlet b/books/bookvol10.3.pamphlet
index 5329aa3..7a036f9 100644
--- a/books/bookvol10.3.pamphlet
+++ b/books/bookvol10.3.pamphlet
@@ -26494,120 +26494,121 @@ g := gcd(p, q)
 
 --S 8 of 8
 )show DecimalExpansion
- DecimalExpansion  is a domain constructor
- Abbreviation for DecimalExpansion is DECIMAL 
- This constructor is exposed in this frame.
- Issue )edit bookvol10.3.pamphlet to see algebra source code for DECIMAL 
-
-------------------------------- Operations --------------------------------
- ?*? : (%,Integer) -> %                ?*? : (Integer,%) -> %
- ?*? : (Fraction(Integer),%) -> %      ?*? : (%,Fraction(Integer)) -> %
- ?*? : (%,%) -> %                      ?*? : (Integer,%) -> %
- ?*? : (NonNegativeInteger,%) -> %     ?*? : (PositiveInteger,%) -> %
- ?**? : (%,Integer) -> %               ?**? : (%,NonNegativeInteger) -> %
- ?**? : (%,PositiveInteger) -> %       ?+? : (%,%) -> %
- ?-? : (%,%) -> %                      -? : % -> %
- ?/? : (Integer,Integer) -> %          ?/? : (%,%) -> %
- ?=? : (%,%) -> Boolean                D : (%,(Integer -> Integer)) -> %
- D : % -> % if Integer has DIFRING     1 : () -> %
- 0 : () -> %                           ?^? : (%,Integer) -> %
- ?^? : (%,NonNegativeInteger) -> %     ?^? : (%,PositiveInteger) -> %
- associates? : (%,%) -> Boolean        coerce : % -> RadixExpansion(10)
- coerce : % -> Fraction(Integer)       coerce : Integer -> %
- coerce : Fraction(Integer) -> %       coerce : % -> %
- coerce : Integer -> %                 coerce : % -> OutputForm
- decimal : Fraction(Integer) -> %      denom : % -> Integer
- denominator : % -> %                  factor : % -> Factored(%)
- gcd : List(%) -> %                    gcd : (%,%) -> %
- hash : % -> SingleInteger             init : () -> % if Integer has STEP
- inv : % -> %                          latex : % -> String
- lcm : List(%) -> %                    lcm : (%,%) -> %
- numer : % -> Integer                  numerator : % -> %
- one? : % -> Boolean                   prime? : % -> Boolean
- ?quo? : (%,%) -> %                    random : () -> % if Integer has INS
- recip : % -> Union(%,"failed")        ?rem? : (%,%) -> %
- retract : % -> Integer                sample : () -> %
- sizeLess? : (%,%) -> Boolean          squareFree : % -> Factored(%)
- squareFreePart : % -> %               unit? : % -> Boolean
- unitCanonical : % -> %                zero? : % -> Boolean
- ?~=? : (%,%) -> Boolean              
- ?<? : (%,%) -> Boolean if Integer has ORDSET
- ?<=? : (%,%) -> Boolean if Integer has ORDSET
- ?>? : (%,%) -> Boolean if Integer has ORDSET
- ?>=? : (%,%) -> Boolean if Integer has ORDSET
- D : (%,(Integer -> Integer),NonNegativeInteger) -> %
- D : (%,List(Symbol),List(NonNegativeInteger)) -> % if Integer has PDRING(SYMBOL)
- D : (%,Symbol,NonNegativeInteger) -> % if Integer has PDRING(SYMBOL)
- D : (%,List(Symbol)) -> % if Integer has PDRING(SYMBOL)
- D : (%,Symbol) -> % if Integer has PDRING(SYMBOL)
- D : (%,NonNegativeInteger) -> % if Integer has DIFRING
- abs : % -> % if Integer has OINTDOM
- ceiling : % -> Integer if Integer has INS
- characteristic : () -> NonNegativeInteger
- charthRoot : % -> Union(%,"failed") if $ has CHARNZ and Integer has PFECAT or Integer has CHARNZ
- coerce : Symbol -> % if Integer has RETRACT(SYMBOL)
- conditionP : Matrix(%) -> Union(Vector(%),"failed") if $ has CHARNZ and Integer has PFECAT
- convert : % -> DoubleFloat if Integer has REAL
- convert : % -> Float if Integer has REAL
- convert : % -> InputForm if Integer has KONVERT(INFORM)
- convert : % -> Pattern(Float) if Integer has KONVERT(PATTERN(FLOAT))
- convert : % -> Pattern(Integer) if Integer has KONVERT(PATTERN(INT))
- differentiate : (%,(Integer -> Integer)) -> %
- differentiate : (%,(Integer -> Integer),NonNegativeInteger) -> %
- differentiate : (%,List(Symbol),List(NonNegativeInteger)) -> % if Integer has PDRING(SYMBOL)
- differentiate : (%,Symbol,NonNegativeInteger) -> % if Integer has PDRING(SYMBOL)
- differentiate : (%,List(Symbol)) -> % if Integer has PDRING(SYMBOL)
- differentiate : (%,Symbol) -> % if Integer has PDRING(SYMBOL)
- differentiate : (%,NonNegativeInteger) -> % if Integer has DIFRING
- differentiate : % -> % if Integer has DIFRING
- divide : (%,%) -> Record(quotient: %,remainder: %)
- ?.? : (%,Integer) -> % if Integer has ELTAB(INT,INT)
- euclideanSize : % -> NonNegativeInteger
- eval : (%,Symbol,Integer) -> % if Integer has IEVALAB(SYMBOL,INT)
- eval : (%,List(Symbol),List(Integer)) -> % if Integer has IEVALAB(SYMBOL,INT)
- eval : (%,List(Equation(Integer))) -> % if Integer has EVALAB(INT)
- eval : (%,Equation(Integer)) -> % if Integer has EVALAB(INT)
- eval : (%,Integer,Integer) -> % if Integer has EVALAB(INT)
- eval : (%,List(Integer),List(Integer)) -> % if Integer has EVALAB(INT)
- expressIdealMember : (List(%),%) -> Union(List(%),"failed")
- exquo : (%,%) -> Union(%,"failed")
- extendedEuclidean : (%,%,%) -> Union(Record(coef1: %,coef2: %),"failed")
- extendedEuclidean : (%,%) -> Record(coef1: %,coef2: %,generator: %)
- factorPolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if Integer has PFECAT
- factorSquareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if Integer has PFECAT
- floor : % -> Integer if Integer has INS
- fractionPart : % -> Fraction(Integer)
- fractionPart : % -> % if Integer has EUCDOM
- gcdPolynomial : (SparseUnivariatePolynomial(%),SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%)
- lcmCoef : (%,%) -> Record(llcmres: %,coeff1: %,coeff2: %)
- map : ((Integer -> Integer),%) -> %
- max : (%,%) -> % if Integer has ORDSET
- min : (%,%) -> % if Integer has ORDSET
- multiEuclidean : (List(%),%) -> Union(List(%),"failed")
- negative? : % -> Boolean if Integer has OINTDOM
- nextItem : % -> Union(%,"failed") if Integer has STEP
- patternMatch : (%,Pattern(Float),PatternMatchResult(Float,%)) -> PatternMatchResult(Float,%) if Integer has PATMAB(FLOAT)
- patternMatch : (%,Pattern(Integer),PatternMatchResult(Integer,%)) -> PatternMatchResult(Integer,%) if Integer has PATMAB(INT)
- positive? : % -> Boolean if Integer has OINTDOM
- principalIdeal : List(%) -> Record(coef: List(%),generator: %)
- reducedSystem : Matrix(%) -> Matrix(Integer)
- reducedSystem : (Matrix(%),Vector(%)) -> Record(mat: Matrix(Integer),vec: Vector(Integer))
- reducedSystem : (Matrix(%),Vector(%)) -> Record(mat: Matrix(Integer),vec: Vector(Integer)) if Integer has LINEXP(INT)
- reducedSystem : Matrix(%) -> Matrix(Integer) if Integer has LINEXP(INT)
- retract : % -> Integer if Integer has RETRACT(INT)
- retract : % -> Fraction(Integer) if Integer has RETRACT(INT)
- retract : % -> Symbol if Integer has RETRACT(SYMBOL)
- retractIfCan : % -> Union(Integer,"failed") if Integer has RETRACT(INT)
- retractIfCan : % -> Union(Fraction(Integer),"failed") if Integer has RETRACT(INT)
- retractIfCan : % -> Union(Symbol,"failed") if Integer has RETRACT(SYMBOL)
- retractIfCan : % -> Union(Integer,"failed")
- sign : % -> Integer if Integer has OINTDOM
- solveLinearPolynomialEquation : (List(SparseUnivariatePolynomial(%)),SparseUnivariatePolynomial(%)) -> Union(List(SparseUnivariatePolynomial(%)),"failed") if Integer has PFECAT
- squareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if Integer has PFECAT
- subtractIfCan : (%,%) -> Union(%,"failed")
- unitNormal : % -> Record(unit: %,canonical: %,associate: %)
- wholePart : % -> Integer if Integer has EUCDOM
-
+--R 
+--R DecimalExpansion  is a domain constructor
+--R Abbreviation for DecimalExpansion is DECIMAL 
+--R This constructor is exposed in this frame.
+--R Issue )edit bookvol10.3.pamphlet to see algebra source code for DECIMAL 
+--R
+--R------------------------------- Operations --------------------------------
+--R ?*? : (%,Integer) -> %                ?*? : (Integer,%) -> %
+--R ?*? : (Fraction(Integer),%) -> %      ?*? : (%,Fraction(Integer)) -> %
+--R ?*? : (%,%) -> %                      ?*? : (Integer,%) -> %
+--R ?*? : (NonNegativeInteger,%) -> %     ?*? : (PositiveInteger,%) -> %
+--R ?**? : (%,Integer) -> %               ?**? : (%,NonNegativeInteger) -> %
+--R ?**? : (%,PositiveInteger) -> %       ?+? : (%,%) -> %
+--R ?-? : (%,%) -> %                      -? : % -> %
+--R ?/? : (Integer,Integer) -> %          ?/? : (%,%) -> %
+--R ?=? : (%,%) -> Boolean                D : (%,(Integer -> Integer)) -> %
+--R D : % -> % if Integer has DIFRING     1 : () -> %
+--R 0 : () -> %                           ?^? : (%,Integer) -> %
+--R ?^? : (%,NonNegativeInteger) -> %     ?^? : (%,PositiveInteger) -> %
+--R associates? : (%,%) -> Boolean        coerce : % -> RadixExpansion(10)
+--R coerce : % -> Fraction(Integer)       coerce : Integer -> %
+--R coerce : Fraction(Integer) -> %       coerce : % -> %
+--R coerce : Integer -> %                 coerce : % -> OutputForm
+--R decimal : Fraction(Integer) -> %      denom : % -> Integer
+--R denominator : % -> %                  factor : % -> Factored(%)
+--R gcd : List(%) -> %                    gcd : (%,%) -> %
+--R hash : % -> SingleInteger             init : () -> % if Integer has STEP
+--R inv : % -> %                          latex : % -> String
+--R lcm : List(%) -> %                    lcm : (%,%) -> %
+--R numer : % -> Integer                  numerator : % -> %
+--R one? : % -> Boolean                   prime? : % -> Boolean
+--R ?quo? : (%,%) -> %                    random : () -> % if Integer has INS
+--R recip : % -> Union(%,"failed")        ?rem? : (%,%) -> %
+--R retract : % -> Integer                sample : () -> %
+--R sizeLess? : (%,%) -> Boolean          squareFree : % -> Factored(%)
+--R squareFreePart : % -> %               unit? : % -> Boolean
+--R unitCanonical : % -> %                zero? : % -> Boolean
+--R ?~=? : (%,%) -> Boolean              
+--R ?<? : (%,%) -> Boolean if Integer has ORDSET
+--R ?<=? : (%,%) -> Boolean if Integer has ORDSET
+--R ?>? : (%,%) -> Boolean if Integer has ORDSET
+--R ?>=? : (%,%) -> Boolean if Integer has ORDSET
+--R D : (%,(Integer -> Integer),NonNegativeInteger) -> %
+--R D : (%,List(Symbol),List(NonNegativeInteger)) -> % if Integer has PDRING(SYMBOL)
+--R D : (%,Symbol,NonNegativeInteger) -> % if Integer has PDRING(SYMBOL)
+--R D : (%,List(Symbol)) -> % if Integer has PDRING(SYMBOL)
+--R D : (%,Symbol) -> % if Integer has PDRING(SYMBOL)
+--R D : (%,NonNegativeInteger) -> % if Integer has DIFRING
+--R abs : % -> % if Integer has OINTDOM
+--R ceiling : % -> Integer if Integer has INS
+--R characteristic : () -> NonNegativeInteger
+--R charthRoot : % -> Union(%,"failed") if $ has CHARNZ and Integer has PFECAT or Integer has CHARNZ
+--R coerce : Symbol -> % if Integer has RETRACT(SYMBOL)
+--R conditionP : Matrix(%) -> Union(Vector(%),"failed") if $ has CHARNZ and Integer has PFECAT
+--R convert : % -> DoubleFloat if Integer has REAL
+--R convert : % -> Float if Integer has REAL
+--R convert : % -> InputForm if Integer has KONVERT(INFORM)
+--R convert : % -> Pattern(Float) if Integer has KONVERT(PATTERN(FLOAT))
+--R convert : % -> Pattern(Integer) if Integer has KONVERT(PATTERN(INT))
+--R differentiate : (%,(Integer -> Integer)) -> %
+--R differentiate : (%,(Integer -> Integer),NonNegativeInteger) -> %
+--R differentiate : (%,List(Symbol),List(NonNegativeInteger)) -> % if Integer has PDRING(SYMBOL)
+--R differentiate : (%,Symbol,NonNegativeInteger) -> % if Integer has PDRING(SYMBOL)
+--R differentiate : (%,List(Symbol)) -> % if Integer has PDRING(SYMBOL)
+--R differentiate : (%,Symbol) -> % if Integer has PDRING(SYMBOL)
+--R differentiate : (%,NonNegativeInteger) -> % if Integer has DIFRING
+--R differentiate : % -> % if Integer has DIFRING
+--R divide : (%,%) -> Record(quotient: %,remainder: %)
+--R ?.? : (%,Integer) -> % if Integer has ELTAB(INT,INT)
+--R euclideanSize : % -> NonNegativeInteger
+--R eval : (%,Symbol,Integer) -> % if Integer has IEVALAB(SYMBOL,INT)
+--R eval : (%,List(Symbol),List(Integer)) -> % if Integer has IEVALAB(SYMBOL,INT)
+--R eval : (%,List(Equation(Integer))) -> % if Integer has EVALAB(INT)
+--R eval : (%,Equation(Integer)) -> % if Integer has EVALAB(INT)
+--R eval : (%,Integer,Integer) -> % if Integer has EVALAB(INT)
+--R eval : (%,List(Integer),List(Integer)) -> % if Integer has EVALAB(INT)
+--R expressIdealMember : (List(%),%) -> Union(List(%),"failed")
+--R exquo : (%,%) -> Union(%,"failed")
+--R extendedEuclidean : (%,%,%) -> Union(Record(coef1: %,coef2: %),"failed")
+--R extendedEuclidean : (%,%) -> Record(coef1: %,coef2: %,generator: %)
+--R factorPolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if Integer has PFECAT
+--R factorSquareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if Integer has PFECAT
+--R floor : % -> Integer if Integer has INS
+--R fractionPart : % -> Fraction(Integer)
+--R fractionPart : % -> % if Integer has EUCDOM
+--R gcdPolynomial : (SparseUnivariatePolynomial(%),SparseUnivariatePolynomial(%)) -> SparseUnivariatePolynomial(%)
+--R lcmCoef : (%,%) -> Record(llcmres: %,coeff1: %,coeff2: %)
+--R map : ((Integer -> Integer),%) -> %
+--R max : (%,%) -> % if Integer has ORDSET
+--R min : (%,%) -> % if Integer has ORDSET
+--R multiEuclidean : (List(%),%) -> Union(List(%),"failed")
+--R negative? : % -> Boolean if Integer has OINTDOM
+--R nextItem : % -> Union(%,"failed") if Integer has STEP
+--R patternMatch : (%,Pattern(Float),PatternMatchResult(Float,%)) -> PatternMatchResult(Float,%) if Integer has PATMAB(FLOAT)
+--R patternMatch : (%,Pattern(Integer),PatternMatchResult(Integer,%)) -> PatternMatchResult(Integer,%) if Integer has PATMAB(INT)
+--R positive? : % -> Boolean if Integer has OINTDOM
+--R principalIdeal : List(%) -> Record(coef: List(%),generator: %)
+--R reducedSystem : Matrix(%) -> Matrix(Integer)
+--R reducedSystem : (Matrix(%),Vector(%)) -> Record(mat: Matrix(Integer),vec: Vector(Integer))
+--R reducedSystem : (Matrix(%),Vector(%)) -> Record(mat: Matrix(Integer),vec: Vector(Integer)) if Integer has LINEXP(INT)
+--R reducedSystem : Matrix(%) -> Matrix(Integer) if Integer has LINEXP(INT)
+--R retract : % -> Integer if Integer has RETRACT(INT)
+--R retract : % -> Fraction(Integer) if Integer has RETRACT(INT)
+--R retract : % -> Symbol if Integer has RETRACT(SYMBOL)
+--R retractIfCan : % -> Union(Integer,"failed") if Integer has RETRACT(INT)
+--R retractIfCan : % -> Union(Fraction(Integer),"failed") if Integer has RETRACT(INT)
+--R retractIfCan : % -> Union(Symbol,"failed") if Integer has RETRACT(SYMBOL)
+--R retractIfCan : % -> Union(Integer,"failed")
+--R sign : % -> Integer if Integer has OINTDOM
+--R solveLinearPolynomialEquation : (List(SparseUnivariatePolynomial(%)),SparseUnivariatePolynomial(%)) -> Union(List(SparseUnivariatePolynomial(%)),"failed") if Integer has PFECAT
+--R squareFreePolynomial : SparseUnivariatePolynomial(%) -> Factored(SparseUnivariatePolynomial(%)) if Integer has PFECAT
+--R subtractIfCan : (%,%) -> Union(%,"failed")
+--R unitNormal : % -> Record(unit: %,canonical: %,associate: %)
+--R wholePart : % -> Integer if Integer has EUCDOM
+--R
 --E 8
 
 )spool
@@ -52224,93 +52225,94 @@ shrinkable(false)$FlexibleArray(Integer)
 
 --S 17 of 17
 )show FlexibleArray
- FlexibleArray(S: Type)  is a domain constructor
- Abbreviation for FlexibleArray is FARRAY 
- This constructor is exposed in this frame.
- Issue )edit bookvol10.3.pamphlet to see algebra source code for FARRAY 
-
-------------------------------- Operations --------------------------------
- concat : List(%) -> %                 concat : (%,%) -> %
- concat : (S,%) -> %                   concat : (%,S) -> %
- concat! : (%,S) -> %                  concat! : (%,%) -> %
- construct : List(S) -> %              copy : % -> %
- delete : (%,Integer) -> %             delete! : (%,Integer) -> %
- ?.? : (%,Integer) -> S                elt : (%,Integer,S) -> S
- empty : () -> %                       empty? : % -> Boolean
- entries : % -> List(S)                eq? : (%,%) -> Boolean
- flexibleArray : List(S) -> %          index? : (Integer,%) -> Boolean
- indices : % -> List(Integer)          insert : (%,%,Integer) -> %
- insert : (S,%,Integer) -> %           insert! : (S,%,Integer) -> %
- insert! : (%,%,Integer) -> %          latex : % -> String if S has SETCAT
- map : (((S,S) -> S),%,%) -> %         map : ((S -> S),%) -> %
- max : (%,%) -> % if S has ORDSET      min : (%,%) -> % if S has ORDSET
- new : (NonNegativeInteger,S) -> %     physicalLength! : (%,Integer) -> %
- qelt : (%,Integer) -> S               remove! : ((S -> Boolean),%) -> %
- reverse : % -> %                      sample : () -> %
- select! : ((S -> Boolean),%) -> %     shrinkable : Boolean -> Boolean
- sort : % -> % if S has ORDSET         sort : (((S,S) -> Boolean),%) -> %
- #? : % -> NonNegativeInteger if $ has finiteAggregate
- ?<? : (%,%) -> Boolean if S has ORDSET
- ?<=? : (%,%) -> Boolean if S has ORDSET
- ?=? : (%,%) -> Boolean if S has SETCAT
- ?>? : (%,%) -> Boolean if S has ORDSET
- ?>=? : (%,%) -> Boolean if S has ORDSET
- any? : ((S -> Boolean),%) -> Boolean if $ has finiteAggregate
- coerce : % -> OutputForm if S has SETCAT
- convert : % -> InputForm if S has KONVERT(INFORM)
- copyInto! : (%,%,Integer) -> % if $ has shallowlyMutable
- count : (S,%) -> NonNegativeInteger if $ has finiteAggregate and S has SETCAT
- count : ((S -> Boolean),%) -> NonNegativeInteger if $ has finiteAggregate
- delete : (%,UniversalSegment(Integer)) -> %
- delete! : (%,UniversalSegment(Integer)) -> %
- ?.? : (%,UniversalSegment(Integer)) -> %
- entry? : (S,%) -> Boolean if $ has finiteAggregate and S has SETCAT
- eval : (%,List(S),List(S)) -> % if S has EVALAB(S) and S has SETCAT
- eval : (%,S,S) -> % if S has EVALAB(S) and S has SETCAT
- eval : (%,Equation(S)) -> % if S has EVALAB(S) and S has SETCAT
- eval : (%,List(Equation(S))) -> % if S has EVALAB(S) and S has SETCAT
- every? : ((S -> Boolean),%) -> Boolean if $ has finiteAggregate
- fill! : (%,S) -> % if $ has shallowlyMutable
- find : ((S -> Boolean),%) -> Union(S,"failed")
- first : % -> S if Integer has ORDSET
- hash : % -> SingleInteger if S has SETCAT
- less? : (%,NonNegativeInteger) -> Boolean
- map! : ((S -> S),%) -> % if $ has shallowlyMutable
- maxIndex : % -> Integer if Integer has ORDSET
- member? : (S,%) -> Boolean if $ has finiteAggregate and S has SETCAT
- members : % -> List(S) if $ has finiteAggregate
- merge : (%,%) -> % if S has ORDSET
- merge : (((S,S) -> Boolean),%,%) -> %
- merge! : (((S,S) -> Boolean),%,%) -> %
- merge! : (%,%) -> % if S has ORDSET
- minIndex : % -> Integer if Integer has ORDSET
- more? : (%,NonNegativeInteger) -> Boolean
- parts : % -> List(S) if $ has finiteAggregate
- physicalLength : % -> NonNegativeInteger
- position : (S,%,Integer) -> Integer if S has SETCAT
- position : (S,%) -> Integer if S has SETCAT
- position : ((S -> Boolean),%) -> Integer
- qsetelt! : (%,Integer,S) -> S if $ has shallowlyMutable
- reduce : (((S,S) -> S),%) -> S if $ has finiteAggregate
- reduce : (((S,S) -> S),%,S) -> S if $ has finiteAggregate
- reduce : (((S,S) -> S),%,S,S) -> S if $ has finiteAggregate and S has SETCAT
- remove : ((S -> Boolean),%) -> % if $ has finiteAggregate
- remove : (S,%) -> % if $ has finiteAggregate and S has SETCAT
- remove! : (S,%) -> % if S has SETCAT
- removeDuplicates : % -> % if $ has finiteAggregate and S has SETCAT
- removeDuplicates! : % -> % if S has SETCAT
- reverse! : % -> % if $ has shallowlyMutable
- select : ((S -> Boolean),%) -> % if $ has finiteAggregate
- setelt : (%,UniversalSegment(Integer),S) -> S if $ has shallowlyMutable
- setelt : (%,Integer,S) -> S if $ has shallowlyMutable
- size? : (%,NonNegativeInteger) -> Boolean
- sort! : % -> % if $ has shallowlyMutable and S has ORDSET
- sort! : (((S,S) -> Boolean),%) -> % if $ has shallowlyMutable
- sorted? : % -> Boolean if S has ORDSET
- sorted? : (((S,S) -> Boolean),%) -> Boolean
- swap! : (%,Integer,Integer) -> Void if $ has shallowlyMutable
- ?~=? : (%,%) -> Boolean if S has SETCAT
-
+--R 
+--R FlexibleArray(S: Type)  is a domain constructor
+--R Abbreviation for FlexibleArray is FARRAY 
+--R This constructor is exposed in this frame.
+--R Issue )edit bookvol10.3.pamphlet to see algebra source code for FARRAY 
+--R
+--R------------------------------- Operations --------------------------------
+--R concat : List(%) -> %                 concat : (%,%) -> %
+--R concat : (S,%) -> %                   concat : (%,S) -> %
+--R concat! : (%,S) -> %                  concat! : (%,%) -> %
+--R construct : List(S) -> %              copy : % -> %
+--R delete : (%,Integer) -> %             delete! : (%,Integer) -> %
+--R ?.? : (%,Integer) -> S                elt : (%,Integer,S) -> S
+--R empty : () -> %                       empty? : % -> Boolean
+--R entries : % -> List(S)                eq? : (%,%) -> Boolean
+--R flexibleArray : List(S) -> %          index? : (Integer,%) -> Boolean
+--R indices : % -> List(Integer)          insert : (%,%,Integer) -> %
+--R insert : (S,%,Integer) -> %           insert! : (S,%,Integer) -> %
+--R insert! : (%,%,Integer) -> %          latex : % -> String if S has SETCAT
+--R map : (((S,S) -> S),%,%) -> %         map : ((S -> S),%) -> %
+--R max : (%,%) -> % if S has ORDSET      min : (%,%) -> % if S has ORDSET
+--R new : (NonNegativeInteger,S) -> %     physicalLength! : (%,Integer) -> %
+--R qelt : (%,Integer) -> S               remove! : ((S -> Boolean),%) -> %
+--R reverse : % -> %                      sample : () -> %
+--R select! : ((S -> Boolean),%) -> %     shrinkable : Boolean -> Boolean
+--R sort : % -> % if S has ORDSET         sort : (((S,S) -> Boolean),%) -> %
+--R #? : % -> NonNegativeInteger if $ has finiteAggregate
+--R ?<? : (%,%) -> Boolean if S has ORDSET
+--R ?<=? : (%,%) -> Boolean if S has ORDSET
+--R ?=? : (%,%) -> Boolean if S has SETCAT
+--R ?>? : (%,%) -> Boolean if S has ORDSET
+--R ?>=? : (%,%) -> Boolean if S has ORDSET
+--R any? : ((S -> Boolean),%) -> Boolean if $ has finiteAggregate
+--R coerce : % -> OutputForm if S has SETCAT
+--R convert : % -> InputForm if S has KONVERT(INFORM)
+--R copyInto! : (%,%,Integer) -> % if $ has shallowlyMutable
+--R count : (S,%) -> NonNegativeInteger if $ has finiteAggregate and S has SETCAT
+--R count : ((S -> Boolean),%) -> NonNegativeInteger if $ has finiteAggregate
+--R delete : (%,UniversalSegment(Integer)) -> %
+--R delete! : (%,UniversalSegment(Integer)) -> %
+--R ?.? : (%,UniversalSegment(Integer)) -> %
+--R entry? : (S,%) -> Boolean if $ has finiteAggregate and S has SETCAT
+--R eval : (%,List(S),List(S)) -> % if S has EVALAB(S) and S has SETCAT
+--R eval : (%,S,S) -> % if S has EVALAB(S) and S has SETCAT
+--R eval : (%,Equation(S)) -> % if S has EVALAB(S) and S has SETCAT
+--R eval : (%,List(Equation(S))) -> % if S has EVALAB(S) and S has SETCAT
+--R every? : ((S -> Boolean),%) -> Boolean if $ has finiteAggregate
+--R fill! : (%,S) -> % if $ has shallowlyMutable
+--R find : ((S -> Boolean),%) -> Union(S,"failed")
+--R first : % -> S if Integer has ORDSET
+--R hash : % -> SingleInteger if S has SETCAT
+--R less? : (%,NonNegativeInteger) -> Boolean
+--R map! : ((S -> S),%) -> % if $ has shallowlyMutable
+--R maxIndex : % -> Integer if Integer has ORDSET
+--R member? : (S,%) -> Boolean if $ has finiteAggregate and S has SETCAT
+--R members : % -> List(S) if $ has finiteAggregate
+--R merge : (%,%) -> % if S has ORDSET
+--R merge : (((S,S) -> Boolean),%,%) -> %
+--R merge! : (((S,S) -> Boolean),%,%) -> %
+--R merge! : (%,%) -> % if S has ORDSET
+--R minIndex : % -> Integer if Integer has ORDSET
+--R more? : (%,NonNegativeInteger) -> Boolean
+--R parts : % -> List(S) if $ has finiteAggregate
+--R physicalLength : % -> NonNegativeInteger
+--R position : (S,%,Integer) -> Integer if S has SETCAT
+--R position : (S,%) -> Integer if S has SETCAT
+--R position : ((S -> Boolean),%) -> Integer
+--R qsetelt! : (%,Integer,S) -> S if $ has shallowlyMutable
+--R reduce : (((S,S) -> S),%) -> S if $ has finiteAggregate
+--R reduce : (((S,S) -> S),%,S) -> S if $ has finiteAggregate
+--R reduce : (((S,S) -> S),%,S,S) -> S if $ has finiteAggregate and S has SETCAT
+--R remove : ((S -> Boolean),%) -> % if $ has finiteAggregate
+--R remove : (S,%) -> % if $ has finiteAggregate and S has SETCAT
+--R remove! : (S,%) -> % if S has SETCAT
+--R removeDuplicates : % -> % if $ has finiteAggregate and S has SETCAT
+--R removeDuplicates! : % -> % if S has SETCAT
+--R reverse! : % -> % if $ has shallowlyMutable
+--R select : ((S -> Boolean),%) -> % if $ has finiteAggregate
+--R setelt : (%,UniversalSegment(Integer),S) -> S if $ has shallowlyMutable
+--R setelt : (%,Integer,S) -> S if $ has shallowlyMutable
+--R size? : (%,NonNegativeInteger) -> Boolean
+--R sort! : % -> % if $ has shallowlyMutable and S has ORDSET
+--R sort! : (((S,S) -> Boolean),%) -> % if $ has shallowlyMutable
+--R sorted? : % -> Boolean if S has ORDSET
+--R sorted? : (((S,S) -> Boolean),%) -> Boolean
+--R swap! : (%,Integer,Integer) -> Void if $ has shallowlyMutable
+--R ?~=? : (%,%) -> Boolean if S has SETCAT
+--R
 --E 17
 
 )spool
@@ -119244,82 +119246,83 @@ q * %
 
 --S 14 of 14
 )show Quaternion
- Quaternion(R: CommutativeRing)  is a domain constructor
- Abbreviation for Quaternion is QUAT 
- This constructor is exposed in this frame.
- Issue )edit bookvol10.3.pamphlet to see algebra source code for QUAT 
-
-------------------------------- Operations --------------------------------
- ?*? : (R,%) -> %                      ?*? : (%,R) -> %
- ?*? : (%,%) -> %                      ?*? : (Integer,%) -> %
- ?*? : (PositiveInteger,%) -> %        ?**? : (%,PositiveInteger) -> %
- ?+? : (%,%) -> %                      ?-? : (%,%) -> %
- -? : % -> %                           ?=? : (%,%) -> Boolean
- D : (%,(R -> R)) -> %                 D : % -> % if R has DIFRING
- 1 : () -> %                           0 : () -> %
- ?^? : (%,PositiveInteger) -> %        abs : % -> R if R has RNS
- coerce : R -> %                       coerce : Integer -> %
- coerce : % -> OutputForm              conjugate : % -> %
- hash : % -> SingleInteger             imagI : % -> R
- imagJ : % -> R                        imagK : % -> R
- inv : % -> % if R has FIELD           latex : % -> String
- map : ((R -> R),%) -> %               norm : % -> R
- one? : % -> Boolean                   quatern : (R,R,R,R) -> %
- real : % -> R                         recip : % -> Union(%,"failed")
- retract : % -> R                      sample : () -> %
- zero? : % -> Boolean                  ?~=? : (%,%) -> Boolean
- ?*? : (Fraction(Integer),%) -> % if R has FIELD
- ?*? : (%,Fraction(Integer)) -> % if R has FIELD
- ?*? : (NonNegativeInteger,%) -> %
- ?**? : (%,Integer) -> % if R has FIELD
- ?**? : (%,NonNegativeInteger) -> %
- ?<? : (%,%) -> Boolean if R has ORDSET
- ?<=? : (%,%) -> Boolean if R has ORDSET
- ?>? : (%,%) -> Boolean if R has ORDSET
- ?>=? : (%,%) -> Boolean if R has ORDSET
- D : (%,(R -> R),NonNegativeInteger) -> %
- D : (%,List(Symbol),List(NonNegativeInteger)) -> % if R has PDRING(SYMBOL)
- D : (%,Symbol,NonNegativeInteger) -> % if R has PDRING(SYMBOL)
- D : (%,List(Symbol)) -> % if R has PDRING(SYMBOL)
- D : (%,Symbol) -> % if R has PDRING(SYMBOL)
- D : (%,NonNegativeInteger) -> % if R has DIFRING
- ?^? : (%,Integer) -> % if R has FIELD
- ?^? : (%,NonNegativeInteger) -> %
- characteristic : () -> NonNegativeInteger
- charthRoot : % -> Union(%,"failed") if R has CHARNZ
- coerce : Fraction(Integer) -> % if R has FIELD or R has RETRACT(FRAC(INT))
- convert : % -> InputForm if R has KONVERT(INFORM)
- differentiate : (%,(R -> R)) -> %
- differentiate : (%,(R -> R),NonNegativeInteger) -> %
- differentiate : (%,List(Symbol),List(NonNegativeInteger)) -> % if R has PDRING(SYMBOL)
- differentiate : (%,Symbol,NonNegativeInteger) -> % if R has PDRING(SYMBOL)
- differentiate : (%,List(Symbol)) -> % if R has PDRING(SYMBOL)
- differentiate : (%,Symbol) -> % if R has PDRING(SYMBOL)
- differentiate : (%,NonNegativeInteger) -> % if R has DIFRING
- differentiate : % -> % if R has DIFRING
- ?.? : (%,R) -> % if R has ELTAB(R,R)
- eval : (%,Symbol,R) -> % if R has IEVALAB(SYMBOL,R)
- eval : (%,List(Symbol),List(R)) -> % if R has IEVALAB(SYMBOL,R)
- eval : (%,List(Equation(R))) -> % if R has EVALAB(R)
- eval : (%,Equation(R)) -> % if R has EVALAB(R)
- eval : (%,R,R) -> % if R has EVALAB(R)
- eval : (%,List(R),List(R)) -> % if R has EVALAB(R)
- max : (%,%) -> % if R has ORDSET
- min : (%,%) -> % if R has ORDSET
- rational : % -> Fraction(Integer) if R has INS
- rational? : % -> Boolean if R has INS
- rationalIfCan : % -> Union(Fraction(Integer),"failed") if R has INS
- reducedSystem : Matrix(%) -> Matrix(R)
- reducedSystem : (Matrix(%),Vector(%)) -> Record(mat: Matrix(R),vec: Vector(R))
- reducedSystem : (Matrix(%),Vector(%)) -> Record(mat: Matrix(Integer),vec: Vector(Integer)) if R has LINEXP(INT)
- reducedSystem : Matrix(%) -> Matrix(Integer) if R has LINEXP(INT)
- retract : % -> Fraction(Integer) if R has RETRACT(FRAC(INT))
- retract : % -> Integer if R has RETRACT(INT)
- retractIfCan : % -> Union(R,"failed")
- retractIfCan : % -> Union(Fraction(Integer),"failed") if R has RETRACT(FRAC(INT))
- retractIfCan : % -> Union(Integer,"failed") if R has RETRACT(INT)
- subtractIfCan : (%,%) -> Union(%,"failed")
-
+--R 
+--R Quaternion(R: CommutativeRing)  is a domain constructor
+--R Abbreviation for Quaternion is QUAT 
+--R This constructor is exposed in this frame.
+--R Issue )edit bookvol10.3.pamphlet to see algebra source code for QUAT 
+--R
+--R------------------------------- Operations --------------------------------
+--R ?*? : (R,%) -> %                      ?*? : (%,R) -> %
+--R ?*? : (%,%) -> %                      ?*? : (Integer,%) -> %
+--R ?*? : (PositiveInteger,%) -> %        ?**? : (%,PositiveInteger) -> %
+--R ?+? : (%,%) -> %                      ?-? : (%,%) -> %
+--R -? : % -> %                           ?=? : (%,%) -> Boolean
+--R D : (%,(R -> R)) -> %                 D : % -> % if R has DIFRING
+--R 1 : () -> %                           0 : () -> %
+--R ?^? : (%,PositiveInteger) -> %        abs : % -> R if R has RNS
+--R coerce : R -> %                       coerce : Integer -> %
+--R coerce : % -> OutputForm              conjugate : % -> %
+--R hash : % -> SingleInteger             imagI : % -> R
+--R imagJ : % -> R                        imagK : % -> R
+--R inv : % -> % if R has FIELD           latex : % -> String
+--R map : ((R -> R),%) -> %               norm : % -> R
+--R one? : % -> Boolean                   quatern : (R,R,R,R) -> %
+--R real : % -> R                         recip : % -> Union(%,"failed")
+--R retract : % -> R                      sample : () -> %
+--R zero? : % -> Boolean                  ?~=? : (%,%) -> Boolean
+--R ?*? : (Fraction(Integer),%) -> % if R has FIELD
+--R ?*? : (%,Fraction(Integer)) -> % if R has FIELD
+--R ?*? : (NonNegativeInteger,%) -> %
+--R ?**? : (%,Integer) -> % if R has FIELD
+--R ?**? : (%,NonNegativeInteger) -> %
+--R ?<? : (%,%) -> Boolean if R has ORDSET
+--R ?<=? : (%,%) -> Boolean if R has ORDSET
+--R ?>? : (%,%) -> Boolean if R has ORDSET
+--R ?>=? : (%,%) -> Boolean if R has ORDSET
+--R D : (%,(R -> R),NonNegativeInteger) -> %
+--R D : (%,List(Symbol),List(NonNegativeInteger)) -> % if R has PDRING(SYMBOL)
+--R D : (%,Symbol,NonNegativeInteger) -> % if R has PDRING(SYMBOL)
+--R D : (%,List(Symbol)) -> % if R has PDRING(SYMBOL)
+--R D : (%,Symbol) -> % if R has PDRING(SYMBOL)
+--R D : (%,NonNegativeInteger) -> % if R has DIFRING
+--R ?^? : (%,Integer) -> % if R has FIELD
+--R ?^? : (%,NonNegativeInteger) -> %
+--R characteristic : () -> NonNegativeInteger
+--R charthRoot : % -> Union(%,"failed") if R has CHARNZ
+--R coerce : Fraction(Integer) -> % if R has FIELD or R has RETRACT(FRAC(INT))
+--R convert : % -> InputForm if R has KONVERT(INFORM)
+--R differentiate : (%,(R -> R)) -> %
+--R differentiate : (%,(R -> R),NonNegativeInteger) -> %
+--R differentiate : (%,List(Symbol),List(NonNegativeInteger)) -> % if R has PDRING(SYMBOL)
+--R differentiate : (%,Symbol,NonNegativeInteger) -> % if R has PDRING(SYMBOL)
+--R differentiate : (%,List(Symbol)) -> % if R has PDRING(SYMBOL)
+--R differentiate : (%,Symbol) -> % if R has PDRING(SYMBOL)
+--R differentiate : (%,NonNegativeInteger) -> % if R has DIFRING
+--R differentiate : % -> % if R has DIFRING
+--R ?.? : (%,R) -> % if R has ELTAB(R,R)
+--R eval : (%,Symbol,R) -> % if R has IEVALAB(SYMBOL,R)
+--R eval : (%,List(Symbol),List(R)) -> % if R has IEVALAB(SYMBOL,R)
+--R eval : (%,List(Equation(R))) -> % if R has EVALAB(R)
+--R eval : (%,Equation(R)) -> % if R has EVALAB(R)
+--R eval : (%,R,R) -> % if R has EVALAB(R)
+--R eval : (%,List(R),List(R)) -> % if R has EVALAB(R)
+--R max : (%,%) -> % if R has ORDSET
+--R min : (%,%) -> % if R has ORDSET
+--R rational : % -> Fraction(Integer) if R has INS
+--R rational? : % -> Boolean if R has INS
+--R rationalIfCan : % -> Union(Fraction(Integer),"failed") if R has INS
+--R reducedSystem : Matrix(%) -> Matrix(R)
+--R reducedSystem : (Matrix(%),Vector(%)) -> Record(mat: Matrix(R),vec: Vector(R))
+--R reducedSystem : (Matrix(%),Vector(%)) -> Record(mat: Matrix(Integer),vec: Vector(Integer)) if R has LINEXP(INT)
+--R reducedSystem : Matrix(%) -> Matrix(Integer) if R has LINEXP(INT)
+--R retract : % -> Fraction(Integer) if R has RETRACT(FRAC(INT))
+--R retract : % -> Integer if R has RETRACT(INT)
+--R retractIfCan : % -> Union(R,"failed")
+--R retractIfCan : % -> Union(Fraction(Integer),"failed") if R has RETRACT(FRAC(INT))
+--R retractIfCan : % -> Union(Integer,"failed") if R has RETRACT(INT)
+--R subtractIfCan : (%,%) -> Union(%,"failed")
+--R
 --E 14
 
 )spool
@@ -151395,49 +151398,50 @@ count(0,arr)
 
 --S 21 of 21
 )show TwoDimensionalArray
- TwoDimensionalArray(R: Type)  is a domain constructor
- Abbreviation for TwoDimensionalArray is ARRAY2 
- This constructor is not exposed in this frame.
- Issue )edit bookvol10.3.pamphlet to see algebra source code for ARRAY2 
-
-------------------------------- Operations --------------------------------
- copy : % -> %                         elt : (%,Integer,Integer,R) -> R
- elt : (%,Integer,Integer) -> R        empty : () -> %
- empty? : % -> Boolean                 eq? : (%,%) -> Boolean
- fill! : (%,R) -> %                    map : (((R,R) -> R),%,%,R) -> %
- map : (((R,R) -> R),%,%) -> %         map : ((R -> R),%) -> %
- map! : ((R -> R),%) -> %              maxColIndex : % -> Integer
- maxRowIndex : % -> Integer            minColIndex : % -> Integer
- minRowIndex : % -> Integer            ncols : % -> NonNegativeInteger
- nrows : % -> NonNegativeInteger       parts : % -> List(R)
- qelt : (%,Integer,Integer) -> R       sample : () -> %
- #? : % -> NonNegativeInteger if $ has finiteAggregate
- ?=? : (%,%) -> Boolean if R has SETCAT
- any? : ((R -> Boolean),%) -> Boolean if $ has finiteAggregate
- coerce : % -> OutputForm if R has SETCAT
- column : (%,Integer) -> OneDimensionalArray(R)
- count : (R,%) -> NonNegativeInteger if $ has finiteAggregate and R has SETCAT
- count : ((R -> Boolean),%) -> NonNegativeInteger if $ has finiteAggregate
- eval : (%,List(R),List(R)) -> % if R has EVALAB(R) and R has SETCAT
- eval : (%,R,R) -> % if R has EVALAB(R) and R has SETCAT
- eval : (%,Equation(R)) -> % if R has EVALAB(R) and R has SETCAT
- eval : (%,List(Equation(R))) -> % if R has EVALAB(R) and R has SETCAT
- every? : ((R -> Boolean),%) -> Boolean if $ has finiteAggregate
- hash : % -> SingleInteger if R has SETCAT
- latex : % -> String if R has SETCAT
- less? : (%,NonNegativeInteger) -> Boolean
- member? : (R,%) -> Boolean if $ has finiteAggregate and R has SETCAT
- members : % -> List(R) if $ has finiteAggregate
- more? : (%,NonNegativeInteger) -> Boolean
- new : (NonNegativeInteger,NonNegativeInteger,R) -> %
- qsetelt! : (%,Integer,Integer,R) -> R
- row : (%,Integer) -> OneDimensionalArray(R)
- setColumn! : (%,Integer,OneDimensionalArray(R)) -> %
- setRow! : (%,Integer,OneDimensionalArray(R)) -> %
- setelt : (%,Integer,Integer,R) -> R
- size? : (%,NonNegativeInteger) -> Boolean
- ?~=? : (%,%) -> Boolean if R has SETCAT
-
+--R 
+--R TwoDimensionalArray(R: Type)  is a domain constructor
+--R Abbreviation for TwoDimensionalArray is ARRAY2 
+--R This constructor is not exposed in this frame.
+--R Issue )edit bookvol10.3.pamphlet to see algebra source code for ARRAY2 
+--R
+--R------------------------------- Operations --------------------------------
+--R copy : % -> %                         elt : (%,Integer,Integer,R) -> R
+--R elt : (%,Integer,Integer) -> R        empty : () -> %
+--R empty? : % -> Boolean                 eq? : (%,%) -> Boolean
+--R fill! : (%,R) -> %                    map : (((R,R) -> R),%,%,R) -> %
+--R map : (((R,R) -> R),%,%) -> %         map : ((R -> R),%) -> %
+--R map! : ((R -> R),%) -> %              maxColIndex : % -> Integer
+--R maxRowIndex : % -> Integer            minColIndex : % -> Integer
+--R minRowIndex : % -> Integer            ncols : % -> NonNegativeInteger
+--R nrows : % -> NonNegativeInteger       parts : % -> List(R)
+--R qelt : (%,Integer,Integer) -> R       sample : () -> %
+--R #? : % -> NonNegativeInteger if $ has finiteAggregate
+--R ?=? : (%,%) -> Boolean if R has SETCAT
+--R any? : ((R -> Boolean),%) -> Boolean if $ has finiteAggregate
+--R coerce : % -> OutputForm if R has SETCAT
+--R column : (%,Integer) -> OneDimensionalArray(R)
+--R count : (R,%) -> NonNegativeInteger if $ has finiteAggregate and R has SETCAT
+--R count : ((R -> Boolean),%) -> NonNegativeInteger if $ has finiteAggregate
+--R eval : (%,List(R),List(R)) -> % if R has EVALAB(R) and R has SETCAT
+--R eval : (%,R,R) -> % if R has EVALAB(R) and R has SETCAT
+--R eval : (%,Equation(R)) -> % if R has EVALAB(R) and R has SETCAT
+--R eval : (%,List(Equation(R))) -> % if R has EVALAB(R) and R has SETCAT
+--R every? : ((R -> Boolean),%) -> Boolean if $ has finiteAggregate
+--R hash : % -> SingleInteger if R has SETCAT
+--R latex : % -> String if R has SETCAT
+--R less? : (%,NonNegativeInteger) -> Boolean
+--R member? : (R,%) -> Boolean if $ has finiteAggregate and R has SETCAT
+--R members : % -> List(R) if $ has finiteAggregate
+--R more? : (%,NonNegativeInteger) -> Boolean
+--R new : (NonNegativeInteger,NonNegativeInteger,R) -> %
+--R qsetelt! : (%,Integer,Integer,R) -> R
+--R row : (%,Integer) -> OneDimensionalArray(R)
+--R setColumn! : (%,Integer,OneDimensionalArray(R)) -> %
+--R setRow! : (%,Integer,OneDimensionalArray(R)) -> %
+--R setelt : (%,Integer,Integer,R) -> R
+--R size? : (%,NonNegativeInteger) -> Boolean
+--R ?~=? : (%,%) -> Boolean if R has SETCAT
+--R
 --E 21
 
 )spool
diff --git a/changelog b/changelog
index bb3d757..25e65dc 100644
--- a/changelog
+++ b/changelog
@@ -1,11 +1,15 @@
+20150711 tpd src/axiom-website/patches.html 20150711.02.tpd.patch 
+20150711 tpd src/input/series.input minor fixes to test suite
+20150711 tpd src/input/intlf.input minor fixes to test suite
+20150711 tpd books/bookvol10.3 minor fixes to test suite
 20150711 tpd src/axiom-website/patches.html 20150711.01.tpd.patch 
 20150711 tpd books/bookvolbib add references to CQQ proofs
 21050711 tpd books/bookvol13 add references to CQQ proofs
 20150701 tpd src/axiom-website/patches.html 20150701.01.tpd.patch 
-20150701 tpd src/input/tuplebug.inputminor fixes to test suite
-20150701 tpd src/input/polycoer.inputminor fixes to test suite
-20150701 tpd src/input/clements.inputminor fixes to test suite
-20150701 tpd src/input/cachedf.inputminor fixes to test suite
+20150701 tpd src/input/tuplebug.input minor fixes to test suite
+20150701 tpd src/input/polycoer.input minor fixes to test suite
+20150701 tpd src/input/clements.input minor fixes to test suite
+20150701 tpd src/input/cachedf.input minor fixes to test suite
 20150701 tpd books/bookvol10.4minor fixes to test suite
 20150621 tpd src/axiom-website/patches.html 20150621.01.tpd.patch 
 20150621 tpd books/bookvol5 merge and purge interop.lisp
diff --git a/patch b/patch
index c853db1..3ebf28b 100644
--- a/patch
+++ b/patch
@@ -1,13 +1,5 @@
-books/bookvol13 more work on proving Axiom
-
-Goal: Axiom proven correct
-
-Add references for proofs in COQ using OCaml and Common Lisp.
-Obtained permission to use Theiry work.
-
-
-
-
-
+books/bookvol10.3, src/input/intlf,series minor test fixes
 
+Goal: Clean Axiom Test Suite
 
+Minor test fixes.
diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html
index 98ac3e9..3205461 100644
--- a/src/axiom-website/patches.html
+++ b/src/axiom-website/patches.html
@@ -5092,6 +5092,8 @@ src/interp/interop.lisp merge and purge code<br/>
 src/input/*.input<br/>
 <a href="patches/20150711.01.tpd.patch">20150711.01.tpd.patch</a>
 books/bookvol13 add references to CQQ proofs<br/>
+<a href="patches/20150711.02.tpd.patch">20150711.02.tpd.patch</a>
+books/bookvol10.3, src/input/intlf,series minor test fixes<br/>
  </body>
 </html>
 
diff --git a/src/input/intlf.input.pamphlet b/src/input/intlf.input.pamphlet
index 6f6e440..9ba78c3 100644
--- a/src/input/intlf.input.pamphlet
+++ b/src/input/intlf.input.pamphlet
@@ -16,6 +16,7 @@
 \end{chunk}
 \begin{chunk}{*}
 )set break resume
+)sys rm -f intlf.output
 )spool intlf.output
 )set message test on
 )set message auto off
diff --git a/src/input/series.input.pamphlet b/src/input/series.input.pamphlet
index 42aedbb..f965aaa 100644
--- a/src/input/series.input.pamphlet
+++ b/src/input/series.input.pamphlet
@@ -281,8 +281,6 @@ univariatePolynomial(b,9)
 --R         362880      5040      120      6
 --R                              Type: UnivariatePolynomial(x,Fraction(Integer))
 --E 20
-)spool 
- 
 
 )spool 
 )lisp (bye)
-- 
1.7.5.4