diff --git a/books/bookvol10.2.pamphlet b/books/bookvol10.2.pamphlet index c01ab93..2daf16b 100644 --- a/books/bookvol10.2.pamphlet +++ b/books/bookvol10.2.pamphlet @@ -4566,7 +4566,7 @@ These exports come from \refto{ConvertibleTo}(Float): \begin{chunk}{category REAL RealConstant} )abbrev category REAL RealConstant ++ Description: -++ The category of real numeric domains, i.e. convertible to floats. +++ The category of real numeric domains, that is, convertible to floats. RealConstant(): Category == Join(ConvertibleTo DoubleFloat, ConvertibleTo Float) @@ -8046,29 +8046,37 @@ These exports come from \refto{TranscendentalFunctionCategory}(): LiouvillianFunctionCategory(): Category == Join(PrimitiveFunctionCategory, TranscendentalFunctionCategory) with + Ei : $ -> $ - ++ Ei(x) returns the exponential integral of x, i.e. + ++ Ei(x) returns the exponential integral of x, that is, ++ the integral of \spad{exp(x)/x dx}. + Si : $ -> $ - ++ Si(x) returns the sine integral of x, i.e. + ++ Si(x) returns the sine integral of x, that is, ++ the integral of \spad{sin(x) / x dx}. + Ci : $ -> $ - ++ Ci(x) returns the cosine integral of x, i.e. + ++ Ci(x) returns the cosine integral of x, that is, ++ the integral of \spad{cos(x) / x dx}. + li : $ -> $ - ++ li(x) returns the logarithmic integral of x, i.e. + ++ li(x) returns the logarithmic integral of x, that is, ++ the integral of \spad{dx / log(x)}. + dilog : $ -> $ - ++ dilog(x) returns the dilogarithm of x, i.e. + ++ dilog(x) returns the dilogarithm of x, that is, ++ the integral of \spad{log(x) / (1 - x) dx}. + erf : $ -> $ - ++ erf(x) returns the error function of x, i.e. + ++ erf(x) returns the error function of x, that is, ++ \spad{2 / sqrt(%pi)} times the integral of \spad{exp(-x**2) dx}. + fresnelS : $ -> $ - ++ fresnelS is the Fresnel integral S, defined by + ++ fresnelS(x) is the Fresnel integral S, defined by ++ S(x) = integrate(sin(t^2),t=0..x) + fresnelC : $ -> $ - ++ fresnelC is the Fresnel integral C, defined by + ++ fresnelC(x) is the Fresnel integral C, defined by ++ C(x) = integrate(cos(t^2),t=0..x) \end{chunk} @@ -9886,7 +9894,7 @@ These exports come from \refto{SetCategory}(): \begin{chunk}{category SGROUP SemiGroup} )abbrev category SGROUP SemiGroup ++ Description: -++ the class of all multiplicative semigroups, i.e. a set +++ the class of all multiplicative semigroups, that is, a set ++ with an associative operation \spadop{*}. ++ ++ Axioms\br @@ -9896,15 +9904,21 @@ These exports come from \refto{SetCategory}(): ++ \tab{5}\spad{commutative("*":(%,%)->%)}\tab{5}\spad{ x*y = y*x } SemiGroup(): Category == SetCategory with - "*": (%,%) -> % ++ x*y returns the product of x and y. - "**": (%,PositiveInteger) -> % ++ x**n returns the repeated product - ++ of x n times, i.e. exponentiation. - "^": (%,PositiveInteger) -> % ++ x^n returns the repeated product - ++ of x n times, i.e. exponentiation. - add - import RepeatedSquaring(%) - x:% ** n:PositiveInteger == expt(x,n) - _^(x:%, n:PositiveInteger):% == x ** n + + "*": (%,%) -> % + ++ x*y returns the product of x and y. + + "**": (%,PositiveInteger) -> % + ++ x**n returns the repeated product of x n times, exponentiation. + + "^": (%,PositiveInteger) -> % + ++ x^n returns the repeated product of x n times, exponentiation. + add + import RepeatedSquaring(%) + + x:% ** n:PositiveInteger == expt(x,n) + + _^(x:%, n:PositiveInteger):% == x ** n \end{chunk} \begin{chunk}{SGROUP.dotabb} @@ -10686,16 +10700,20 @@ ThreeSpaceCategory(R:Ring): Exports == Implementation where Exports ==> Category Implementation ==> SetCategory with + create3Space : () -> % ++ create3Space() creates a \spadtype{ThreeSpace} object capable of ++ holding point, curve, mesh components and any combination. + create3Space : SUBSPACE -> % ++ create3Space(s) creates a \spadtype{ThreeSpace} object containing ++ objects pre-defined within some \spadtype{SubSpace} s. + numberOfComponents : % -> NNI ++ numberOfComponents(s) returns the number of distinct ++ object components in the indicated \spadtype{ThreeSpace}, s, such ++ as points, curves, polygons, and constructs. + numberOfComposites : % -> NNI ++ numberOfComposites(s) returns the number of supercomponents, ++ or composites, in the \spadtype{ThreeSpace}, s; Composites are @@ -10704,35 +10722,43 @@ ThreeSpaceCategory(R:Ring): Exports == Implementation where ++ and, outside of the requirement that no component can belong ++ to more than one composite at a time, the definition and ++ interpretation of composites are unrestricted. + merge : L % -> % ++ merge([s1,s2,...,sn]) will create a new \spadtype{ThreeSpace} that ++ has the components of all the ones in the list; Groupings of ++ components into composites are maintained. + merge : (%,%) -> % ++ merge(s1,s2) will create a new \spadtype{ThreeSpace} that has the ++ components of \spad{s1} and \spad{s2}; Groupings of components ++ into composites are maintained. + composite : L % -> % ++ composite([s1,s2,...,sn]) will create a new \spadtype{ThreeSpace} ++ that is a union of all the components from each ++ \spadtype{ThreeSpace} in the parameter list, grouped as a composite. + components : % -> L % ++ components(s) takes the \spadtype{ThreeSpace} s, and creates a list ++ containing a unique \spadtype{ThreeSpace} for each single component ++ of s. If s has no components defined, the list returned is empty. + composites : % -> L % ++ composites(s) takes the \spadtype{ThreeSpace} s, and creates a list ++ containing a unique \spadtype{ThreeSpace} for each single composite ++ of s. If s has no composites defined (composites need to be ++ explicitly created), the list returned is empty. Note that not all ++ the components need to be part of a composite. + copy : % -> % ++ copy(s) returns a new \spadtype{ThreeSpace} that is an exact copy ++ of s. + enterPointData : (%,L POINT) -> NNI ++ enterPointData(s,[p0,p1,...,pn]) adds a list of points from p0 ++ through pn to the \spadtype{ThreeSpace}, s, and returns the index, ++ to the starting point of the list; + modifyPointData : (%,NNI,POINT) -> % ++ modifyPointData(s,i,p) changes the point at the indexed ++ location i in the \spadtype{ThreeSpace}, s, to that of point p. @@ -10740,58 +10766,71 @@ ThreeSpaceCategory(R:Ring): Exports == Implementation where ++ transformed. -- 3D primitives + point : (%,POINT) -> % ++ point(s,p) adds a point component defined by the point, p, ++ specified as a list from \spad{List(R)}, to the ++ \spadtype{ThreeSpace}, s, where R is the \spadtype{Ring} over ++ which the point is defined. + point : (%,L R) -> % ++ point(s,[x,y,z]) adds a point component defined by a list of ++ elements which are from the \spad{PointDomain(R)} to the ++ \spadtype{ThreeSpace}, s, where R is the \spadtype{Ring} over ++ which the point elements are defined. + point : (%,NNI) -> % ++ point(s,i) adds a point component which is placed into a component ++ list of the \spadtype{ThreeSpace}, s, at the index given by i. + point : POINT -> % ++ point(p) returns a \spadtype{ThreeSpace} object which is composed ++ of one component, the point p. + point : % -> POINT ++ point(s) checks to see if the \spadtype{ThreeSpace}, s, is ++ composed of only a single point and if so, returns the point. ++ An error is signaled otherwise. + point? : % -> B ++ point?(s) queries whether the \spadtype{ThreeSpace}, s, is ++ composed of a single component which is a point and returns the ++ boolean result. + curve : (%,L POINT) -> % ++ curve(s,[p0,p1,...,pn]) adds a space curve component defined by a ++ list of points \spad{p0} through \spad{pn}, to the ++ \spadtype{ThreeSpace} s. + curve : (%,L L R) -> % ++ curve(s,[[p0],[p1],...,[pn]]) adds a space curve which is a list of ++ points p0 through pn defined by lists of elements from the domain ++ \spad{PointDomain(m,R)}, where R is the \spadtype{Ring} over which ++ the point elements are defined and m is the dimension of the ++ points, to the \spadtype{ThreeSpace} s. + curve : L POINT -> % ++ curve([p0,p1,p2,...,pn]) creates a space curve defined ++ by the list of points \spad{p0} through \spad{pn}, and returns the ++ \spadtype{ThreeSpace} whose component is the curve. + curve : % -> L POINT ++ curve(s) checks to see if the \spadtype{ThreeSpace}, s, is ++ composed of a single curve defined by a list of points and if so, - ++ returns the curve, i.e., list of points. An error is signaled + ++ returns the curve, that is, list of points. An error is signaled ++ otherwise. + curve? : % -> B ++ curve?(s) queries whether the \spadtype{ThreeSpace}, s, is a curve, - ++ i.e., has one component, a list of list of points, and returns + ++ that is, has one component, a list of list of points, and returns ++ true if it is, or false otherwise. + closedCurve : (%,L POINT) -> % ++ closedCurve(s,[p0,p1,...,pn,p0]) adds a closed curve component ++ which is a list of points defined by the first element p0 through ++ the last element pn and back to the first element p0 again, to the ++ \spadtype{ThreeSpace} s. + closedCurve : (%,L L R) -> % ++ closedCurve(s,[[lr0],[lr1],...,[lrn],[lr0]]) adds a closed curve ++ component defined by a list of points \spad{lr0} through @@ -10801,42 +10840,51 @@ ThreeSpaceCategory(R:Ring): Exports == Implementation where ++ points, in which the last element of the list of points contains ++ a copy of the first element list, lr0. ++ The closed curve is added to the \spadtype{ThreeSpace}, s. + closedCurve : L POINT -> % ++ closedCurve(lp) sets a list of points defined by the first element ++ of lp through the last element of lp and back to the first elelment ++ again and returns a \spadtype{ThreeSpace} whose component is the ++ closed curve defined by lp. + closedCurve : % -> L POINT ++ closedCurve(s) checks to see if the \spadtype{ThreeSpace}, s, is ++ composed of a single closed curve component defined by a list of ++ points in which the first point is also the last point, all of ++ which are from the domain \spad{PointDomain(m,R)} and if so, ++ returns the list of points. An error is signaled otherwise. + closedCurve? : % -> B ++ closedCurve?(s) returns true if the \spadtype{ThreeSpace} s - ++ contains a single closed curve component, i.e., the first element + ++ contains a single closed curve component, that is, the first element ++ of the curve is also the last element, or false otherwise. + polygon : (%,L POINT) -> % ++ polygon(s,[p0,p1,...,pn]) adds a polygon component defined by a ++ list of points, p0 throught pn, to the \spadtype{ThreeSpace} s. + polygon : (%,L L R) -> % ++ polygon(s,[[r0],[r1],...,[rn]]) adds a polygon component defined ++ by a list of points \spad{r0} through \spad{rn}, which are lists of ++ elements from the domain \spad{PointDomain(m,R)} to the ++ \spadtype{ThreeSpace} s, where m is the dimension of the points ++ and R is the \spadtype{Ring} over which the points are defined. + polygon : L POINT -> % ++ polygon([p0,p1,...,pn]) creates a polygon defined by a list of ++ points, p0 through pn, and returns a \spadtype{ThreeSpace} whose ++ component is the polygon. + polygon : % -> L POINT ++ polygon(s) checks to see if the \spadtype{ThreeSpace}, s, is ++ composed of a single polygon component defined by a list of ++ points, and if so, returns the list of points; An error is ++ signaled otherwise. + polygon? : % -> B ++ polygon?(s) returns true if the \spadtype{ThreeSpace} s contains ++ a single polygon component, or false otherwise. + mesh : (%,L L POINT,L PROP,PROP) -> % ++ mesh(s,[[p0],[p1],...,[pn]],[props],prop) adds a surface component, ++ defined over a list curves which contains lists of points, to the @@ -10844,9 +10892,11 @@ ThreeSpaceCategory(R:Ring): Exports == Implementation where ++ subspace component properties for each surface parameter, and ++ prop is the subspace component property by which the points are ++ defined. + mesh : (%,L L L R,L PROP,PROP) -> % - ++ mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] ], - ++ [props], prop) + ++ mesh(s, LLLR, [props], prop) + ++ where LLLR is of the form: + ++ [[[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]]], ++ adds a surface component to the \spadtype{ThreeSpace} s, which is ++ defined over a rectangular domain of size WxH where W is the number ++ of lists of points from the domain \spad{PointDomain(R)} and H is @@ -10854,38 +10904,44 @@ ThreeSpaceCategory(R:Ring): Exports == Implementation where ++ of the subspace component properties for each curve list, and ++ prop is the subspace component property by which the points are ++ defined. + mesh : (%,L L POINT,B,B) -> % - ++ mesh(s,[[p0],[p1],...,[pn]], close1, close2) adds a surface + ++ mesh(s, LLP, close1, close2) + ++ where LLP is of the form [[p0],[p1],...,[pn]] adds a surface ++ component to the \spadtype{ThreeSpace}, which is defined over a ++ list of curves, in which each of these curves is a list of points. ++ The boolean arguments close1 and close2 indicate how the surface ++ is to be closed. Argument close1 equal true - ++ means that each individual list (a curve) is to be closed, i.e. the - ++ last point of the list is to be connected to the first point. + ++ means that each individual list (a curve) is to be closed, that is, + ++ the last point of the list is to be connected to the first point. ++ Argument close2 equal true ++ means that the boundary at one end of the surface is to be - ++ connected to the boundary at the other end, i.e. the boundaries + ++ connected to the boundary at the other end, that is, the boundaries ++ are defined as the first list of points (curve) and ++ the last list of points (curve). + mesh : (%,L L L R,B,B) -> % - ++ mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] ], - ++ close1, close2) + ++ mesh(s, LLLR, close1, close2) + ++ where LLLR is of the form + ++ [[[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]]], ++ adds a surface component to the \spadtype{ThreeSpace} s, which is ++ defined over a rectangular domain of size WxH where W is the number ++ of lists of points from the domain \spad{PointDomain(R)} and H is ++ the number of elements in each of those lists; the booleans close1 ++ and close2 indicate how the surface is to be closed: if close1 is ++ true this means that each individual list (a curve) is to be - ++ closed (i.e., + ++ closed (that is, ++ the last point of the list is to be connected to the first point); ++ if close2 is true, this means that the boundary at one end of the ++ surface is to be connected to the boundary at the other end ++ (the boundaries are defined as the first list of points (curve) ++ and the last list of points (curve)). + mesh : L L POINT -> % ++ mesh([[p0],[p1],...,[pn]]) creates a surface defined by a list of ++ curves which are lists, p0 through pn, of points, and returns a ++ \spadtype{ThreeSpace} whose component is the surface. + mesh : (L L POINT,B,B) -> % ++ mesh([[p0],[p1],...,[pn]], close1, close2) creates a surface ++ defined over a list of curves, p0 through pn, which are lists of @@ -10897,51 +10953,62 @@ ThreeSpaceCategory(R:Ring): Exports == Implementation where ++ the boundary at the other end (the boundaries are defined as the ++ first list of points (curve) and the last list of points (curve)); ++ the \spadtype{ThreeSpace} containing this surface is returned. + mesh : % -> L L POINT ++ mesh(s) checks to see if the \spadtype{ThreeSpace}, s, is ++ composed of a single surface component defined by a list curves ++ which contain lists of points, and if so, returns the list of ++ lists of points; An error is signaled otherwise. + mesh? : % -> B ++ mesh?(s) returns true if the \spadtype{ThreeSpace} s is composed ++ of one component, a mesh comprising a list of curves which are lists ++ of points, or returns false if otherwise + lp : % -> L POINT ++ lp(s) returns the list of points component which the ++ \spadtype{ThreeSpace}, s, contains; these points are used by - ++ reference, i.e., the component holds indices referring to the + ++ reference, that is, the component holds indices referring to the ++ points rather than the points themselves. This allows for sharing ++ of the points. + lllip : % -> L L L NNI ++ lllip(s) checks to see if the \spadtype{ThreeSpace}, s, is ++ composed of a list of components, which are lists of curves, ++ which are lists of indices to points, and if so, returns the list ++ of lists of lists; An error is signaled otherwise. + lllp : % -> L L L POINT -- used by view3D ++ lllp(s) checks to see if the \spadtype{ThreeSpace}, s, is ++ composed of a list of components, which are lists of curves, ++ which are lists of points, and if so, returns the list of ++ lists of lists; An error is signaled otherwise. + llprop : % -> L L PROP -- used by view3D ++ llprop(s) checks to see if the \spadtype{ThreeSpace}, s, is ++ composed of a list of curves which are lists of the ++ subspace component properties of the curves, and if so, returns the ++ list of lists; An error is signaled otherwise. + lprop : % -> L PROP -- used by view3D ++ lprop(s) checks to see if the \spadtype{ThreeSpace}, s, is ++ composed of a list of subspace component properties, and if so, ++ returns the list; An error is signaled otherwise. + objects : % -> OBJ3D ++ objects(s) returns the \spadtype{ThreeSpace}, s, in the form of a ++ 3D object record containing information on the number of points, ++ curves, polygons and constructs comprising the ++ \spadtype{ThreeSpace}.. + check : % -> % -- used by mesh ++ check(s) returns lllpt, list of lists of lists of point information ++ about the \spadtype{ThreeSpace} s. + subspace : % -> SUBSPACE ++ subspace(s) returns the \spadtype{SubSpace} which holds all the ++ point information in the \spadtype{ThreeSpace}, s. + coerce : % -> O ++ coerce(s) returns the \spadtype{ThreeSpace} s to Output format. @@ -18693,28 +18760,28 @@ MatrixCategory(R,Row,Col): Category == Definition where --% Predicates square? : % -> Boolean - ++ \spad{square?(m)} returns true if m is a square matrix + ++square?(m) returns true if m is a square matrix ++ (if m has the same number of rows as columns) and false otherwise. ++ ++X square matrix [[j**i for i in 0..4] for j in 1..5] diagonal?: % -> Boolean - ++ \spad{diagonal?(m)} returns true if the matrix m is square and - ++ diagonal (i.e. all entries of m not on the diagonal are zero) and + ++diagonal?(m) returns true if the matrix m is square and + ++ diagonal (that is, all entries of m not on the diagonal are zero) and ++ false otherwise. ++ ++X diagonal? matrix [[j**i for i in 0..4] for j in 1..5] symmetric?: % -> Boolean - ++ \spad{symmetric?(m)} returns true if the matrix m is square and - ++ symmetric (i.e. \spad{m[i,j] = m[j,i]} for all i and j) and false + ++symmetric?(m) returns true if the matrix m is square and + ++ symmetric (that is, \spad{m[i,j] = m[j,i]} for all i and j) and false ++ otherwise. ++ ++X symmetric? matrix [[j**i for i in 0..4] for j in 1..5] antisymmetric?: % -> Boolean - ++ \spad{antisymmetric?(m)} returns true if the matrix m is square and - ++ antisymmetric (i.e. \spad{m[i,j] = -m[j,i]} for all i and j) + ++antisymmetric?(m) returns true if the matrix m is square and + ++ antisymmetric (that is, \spad{m[i,j] = -m[j,i]} for all i and j) ++ and false otherwise. ++ ++X antisymmetric? matrix [[j**i for i in 0..4] for j in 1..5] @@ -18723,37 +18790,37 @@ MatrixCategory(R,Row,Col): Category == Definition where --% Creation zero: (NonNegativeInteger,NonNegativeInteger) -> % - ++ \spad{zero(m,n)} returns an m-by-n zero matrix. + ++zero(m,n) returns an m-by-n zero matrix. ++ ++X z:Matrix(INT):=zero(3,3) matrix: List List R -> % - ++ \spad{matrix(l)} converts the list of lists l to a matrix, where the + ++matrix(l) converts the list of lists l to a matrix, where the ++ list of lists is viewed as a list of the rows of the matrix. ++ ++X matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]] matrix: (NonNegativeInteger,NonNegativeInteger,(Integer,Integer)->R) -> % - ++ \spad{matrix(n,m,f)} constructs an \spad{n * m} matrix with + ++matrix(n,m,f) constructs an \spad{n * m} matrix with ++ the \spad{(i,j)} entry equal to \spad{f(i,j)} ++ ++X f(i:INT,j:INT):INT == i+j ++X matrix(3,4,f) scalarMatrix: (NonNegativeInteger,R) -> % - ++ \spad{scalarMatrix(n,r)} returns an n-by-n matrix with r's on the + ++scalarMatrix(n,r) returns an n-by-n matrix with r's on the ++ diagonal and zeroes elsewhere. ++ ++X z:Matrix(INT):=scalarMatrix(3,5) diagonalMatrix: List R -> % - ++ \spad{diagonalMatrix(l)} returns a diagonal matrix with the elements + ++diagonalMatrix(l) returns a diagonal matrix with the elements ++ of l on the diagonal. ++ ++X diagonalMatrix [1,2,3] diagonalMatrix: List % -> % - ++ \spad{diagonalMatrix([m1,...,mk])} creates a block diagonal matrix + ++diagonalMatrix([m1,...,mk]) creates a block diagonal matrix ++ M with block matrices m1,...,mk down the diagonal, ++ with 0 block matrices elsewhere. ++ More precisly: if \spad{ri := nrows mi}, \spad{ci := ncols mi}, @@ -18766,25 +18833,25 @@ MatrixCategory(R,Row,Col): Category == Definition where ++X diagonalMatrix [matrix [[1,2],[3,4]], matrix [[4,5],[6,7]]] coerce: Col -> % - ++ \spad{coerce(col)} converts the column col to a column matrix. + ++coerce(col) converts the column col to a column matrix. ++ ++X coerce([1,2,3])@Matrix(INT) transpose: Row -> % - ++ \spad{transpose(r)} converts the row r to a row matrix. + ++transpose(r) converts the row r to a row matrix. ++ ++X transpose([1,2,3])@Matrix(INT) --% Creation of new matrices from old transpose: % -> % - ++ \spad{transpose(m)} returns the transpose of the matrix m. + ++transpose(m) returns the transpose of the matrix m. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X transpose m squareTop: % -> % - ++ \spad{squareTop(m)} returns an n-by-n matrix consisting of the first + ++squareTop(m) returns an n-by-n matrix consisting of the first ++ n rows of the m-by-n matrix m. Error: if ++ \spad{m < n}. ++ @@ -18792,7 +18859,7 @@ MatrixCategory(R,Row,Col): Category == Definition where ++X squareTop m horizConcat: (%,%) -> % - ++ \spad{horizConcat(x,y)} horizontally concatenates two matrices with + ++horizConcat(x,y) horizontally concatenates two matrices with ++ an equal number of rows. The entries of y appear to the right ++ of the entries of x. Error: if the matrices ++ do not have the same number of rows. @@ -18801,7 +18868,7 @@ MatrixCategory(R,Row,Col): Category == Definition where ++X horizConcat(m,m) vertConcat: (%,%) -> % - ++ \spad{vertConcat(x,y)} vertically concatenates two matrices with an + ++vertConcat(x,y) vertically concatenates two matrices with an ++ equal number of columns. The entries of y appear below ++ of the entries of x. Error: if the matrices ++ do not have the same number of columns. @@ -18812,14 +18879,14 @@ MatrixCategory(R,Row,Col): Category == Definition where --% Part extractions/assignments listOfLists: % -> List List R - ++ \spad{listOfLists(m)} returns the rows of the matrix m as a list + ++listOfLists(m) returns the rows of the matrix m as a list ++ of lists. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X listOfLists m elt: (%,List Integer,List Integer) -> % - ++ \spad{elt(x,rowList,colList)} returns an m-by-n matrix consisting + ++elt(x,rowList,colList) returns an m-by-n matrix consisting ++ of elements of x, where \spad{m = # rowList} and \spad{n = # colList} ++ If \spad{rowList = [i<1>,i<2>,...,i]} and \spad{colList = ++ [j<1>,j<2>,...,j]}, then the \spad{(k,l)}th entry of @@ -18829,7 +18896,7 @@ MatrixCategory(R,Row,Col): Category == Definition where ++X elt(m,3,3) setelt: (%,List Integer,List Integer, %) -> % - ++ \spad{setelt(x,rowList,colList,y)} destructively alters the matrix x. + ++setelt(x,rowList,colList,y) destructively alters the matrix x. ++ If y is \spad{m}-by-\spad{n}, \spad{rowList = [i<1>,i<2>,...,i]} ++ and \spad{colList = [j<1>,j<2>,...,j]}, then \spad{x(i,j)} ++ is set to \spad{y(k,l)} for \spad{k = 1,...,m} and \spad{l = 1,...,n} @@ -18838,21 +18905,21 @@ MatrixCategory(R,Row,Col): Category == Definition where ++X setelt(m,3,3,10) swapRows_!: (%,Integer,Integer) -> % - ++ \spad{swapRows!(m,i,j)} interchanges the \spad{i}th and \spad{j}th + ++swapRows!(m,i,j) interchanges the \spad{i}th and \spad{j}th ++ rows of m. This destructively alters the matrix. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X swapRows!(m,2,4) swapColumns_!: (%,Integer,Integer) -> % - ++ \spad{swapColumns!(m,i,j)} interchanges the \spad{i}th and \spad{j}th + ++swapColumns!(m,i,j) interchanges the \spad{i}th and \spad{j}th ++ columns of m. This destructively alters the matrix. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X swapColumns!(m,2,4) subMatrix: (%,Integer,Integer,Integer,Integer) -> % - ++ \spad{subMatrix(x,i1,i2,j1,j2)} extracts the submatrix + ++subMatrix(x,i1,i2,j1,j2) extracts the submatrix ++ \spad{[x(i,j)]} where the index i ranges from \spad{i1} to \spad{i2} ++ and the index j ranges from \spad{j1} to \spad{j2}. ++ @@ -18860,7 +18927,7 @@ MatrixCategory(R,Row,Col): Category == Definition where ++X subMatrix(m,1,3,2,4) setsubMatrix_!: (%,Integer,Integer,%) -> % - ++ \spad{setsubMatrix(x,i1,j1,y)} destructively alters the + ++setsubMatrix!(x,i1,j1,y) destructively alters the ++ matrix x. Here \spad{x(i,j)} is set to \spad{y(i-i1+1,j-j1+1)} for ++ \spad{i = i1,...,i1-1+nrows y} and \spad{j = j1,...,j1-1+ncols y}. ++ @@ -18871,54 +18938,54 @@ MatrixCategory(R,Row,Col): Category == Definition where --% Arithmetic "+": (%,%) -> % - ++ \spad{x + y} is the sum of the matrices x and y. + ++\spad{x + y} is the sum of the matrices x and y. ++ Error: if the dimensions are incompatible. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X m+m "-": (%,%) -> % - ++ \spad{x - y} is the difference of the matrices x and y. + ++\spad{x - y} is the difference of the matrices x and y. ++ Error: if the dimensions are incompatible. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X m-m "-": % -> % - ++ \spad{-x} returns the negative of the matrix x. + ++\spad{-x} returns the negative of the matrix x. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X -m "*": (%,%) -> % - ++ \spad{x * y} is the product of the matrices x and y. + ++\spad{x * y} is the product of the matrices x and y. ++ Error: if the dimensions are incompatible. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X m*m "*": (R,%) -> % - ++ \spad{r*x} is the left scalar multiple of the scalar r and the + ++\spad{r*x} is the left scalar multiple of the scalar r and the ++ matrix x. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X 1/3*m "*": (%,R) -> % - ++ \spad{x * r} is the right scalar multiple of the scalar r and the + ++\spad{x * r} is the right scalar multiple of the scalar r and the ++ matrix x. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X m*1/3 "*": (Integer,%) -> % - ++ \spad{n * x} is an integer multiple. + ++\spad{n * x} is an integer multiple. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] ++X 3*m "*": (%,Col) -> Col - ++ \spad{x * c} is the product of the matrix x and the column vector c. + ++\spad{x * c} is the product of the matrix x and the column vector c. ++ Error: if the dimensions are incompatible. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] @@ -18926,7 +18993,7 @@ MatrixCategory(R,Row,Col): Category == Definition where ++X m*c "*": (Row,%) -> Row - ++ \spad{r * x} is the product of the row vector r and the matrix x. + ++\spad{r * x} is the product of the row vector r and the matrix x. ++ Error: if the dimensions are incompatible. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] @@ -18934,7 +19001,7 @@ MatrixCategory(R,Row,Col): Category == Definition where ++X r*m "**": (%,NonNegativeInteger) -> % - ++ \spad{x ** n} computes a non-negative integral power of the matrix x. + ++\spad{x ** n} computes a non-negative integral power of the matrix x. ++ Error: if the matrix is not square. ++ ++X m:=matrix [[j**i for i in 0..4] for j in 1..5] @@ -18942,7 +19009,7 @@ MatrixCategory(R,Row,Col): Category == Definition where if R has IntegralDomain then "exquo": (%,R) -> Union(%,"failed") - ++ \spad{exquo(m,r)} computes the exact quotient of the elements + ++\spad{exquo(m,r)} computes the exact quotient of the elements ++ of m by r, returning \axiom{"failed"} if this is not possible. ++ ++X m:=matrix [[2**i for i in 2..4] for j in 1..5] @@ -18950,7 +19017,7 @@ MatrixCategory(R,Row,Col): Category == Definition where if R has Field then "/": (%,R) -> % - ++ \spad{m/r} divides the elements of m by r. Error: if \spad{r = 0}. + ++\spad{m/r} divides the elements of m by r. Error: if \spad{r = 0}. ++ ++X m:=matrix [[2**i for i in 2..4] for j in 1..5] ++X m/4 @@ -18959,63 +19026,63 @@ MatrixCategory(R,Row,Col): Category == Definition where if R has EuclideanDomain then rowEchelon: % -> % - ++ \spad{rowEchelon(m)} returns the row echelon form of the matrix m. + ++\spad{rowEchelon(m)} returns the row echelon form of the matrix m. ++ ++X rowEchelon matrix [[j**i for i in 0..4] for j in 1..5] columnSpace: % -> List Col - ++ \spad{columnSpace(m)} returns a sublist of columns of the matrix m + ++\spad{columnSpace(m)} returns a sublist of columns of the matrix m ++ forming a basis of its column space ++ ++X columnSpace matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]] if R has IntegralDomain then rank: % -> NonNegativeInteger - ++ \spad{rank(m)} returns the rank of the matrix m. + ++\spad{rank(m)} returns the rank of the matrix m. ++ ++X rank matrix [[1,2,3],[4,5,6],[7,8,9]] nullity: % -> NonNegativeInteger - ++ \spad{nullity(m)} returns the nullity of the matrix m. This is + ++\spad{nullity(m)} returns the nullity of the matrix m. This is ++ the dimension of the null space of the matrix m. ++ ++X nullity matrix [[1,2,3],[4,5,6],[7,8,9]] nullSpace: % -> List Col - ++ \spad{nullSpace(m)} returns a basis for the null space of + ++\spad{nullSpace(m)} returns a basis for the null space of ++ the matrix m. ++ ++X nullSpace matrix [[1,2,3],[4,5,6],[7,8,9]] if R has commutative("*") then determinant: % -> R - ++ \spad{determinant(m)} returns the determinant of the matrix m. + ++\spad{determinant(m)} returns the determinant of the matrix m. ++ Error: if the matrix is not square. ++ ++X determinant matrix [[j**i for i in 0..4] for j in 1..5] minordet: % -> R - ++ \spad{minordet(m)} computes the determinant of the matrix m using + ++\spad{minordet(m)} computes the determinant of the matrix m using ++ minors. Error: if the matrix is not square. ++ ++X minordet matrix [[j**i for i in 0..4] for j in 1..5] if R has CommutativeRing then pfaffian: % -> R - ++ \spad{pfaffian(m)} returns the Pfaffian of the matrix m. + ++\spad{pfaffian(m)} returns the Pfaffian of the matrix m. ++ Error if the matrix is not antisymmetric ++ ++X pfaffian [[0,1,0,0],[-1,0,0,0],[0,0,0,1],[0,0,-1,0]] if R has Field then inverse: % -> Union(%,"failed") - ++ \spad{inverse(m)} returns the inverse of the matrix m. + ++\spad{inverse(m)} returns the inverse of the matrix m. ++ If the matrix is not invertible, "failed" is returned. ++ Error: if the matrix is not square. ++ ++X inverse matrix [[j**i for i in 0..4] for j in 1..5] "**": (%,Integer) -> % - ++ \spad{m**n} computes an integral power of the matrix m. + ++\spad{m**n} computes an integral power of the matrix m. ++ Error: if matrix is not square or if the matrix ++ is square but not invertible. ++ @@ -26994,7 +27061,7 @@ FiniteSetAggregate(S:SetCategory): Category == Finite complement: % -> % ++ complement(u) returns the complement of the set u, - ++ i.e. the set of all values not in u. + ++ that is, the set of all values not in u. universe: () -> % ++ universe()$D returns the universal set for finite set aggregate D. if S has OrderedSet then @@ -27809,12 +27876,13 @@ These exports come from \refto{StreamAggregate}(S:Type): ++ LazyStreamAggregate is the category of streams with lazy ++ evaluation. It is understood that the function 'empty?' will ++ cause lazy evaluation if necessary to determine if there are -++ entries. Functions which call 'empty?', e.g. 'first' and 'rest', +++ entries. Functions which call 'empty?', for example 'first' and 'rest', ++ will also cause lazy evaluation if necessary. LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with + remove: (S -> Boolean,%) -> % - ++ remove(f,st) returns a stream consisting of those elements of stream + ++remove(f,st) returns a stream consisting of those elements of stream ++ st which do not satisfy the predicate f. ++ Note that \spad{remove(f,st) = [x for x in st | not f(x)]}. ++ @@ -27823,7 +27891,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with ++X remove(f,m) select: (S -> Boolean,%) -> % - ++ select(f,st) returns a stream consisting of those elements of stream + ++select(f,st) returns a stream consisting of those elements of stream ++ st satisfying the predicate f. ++ Note that \spad{select(f,st) = [x for x in st | f(x)]}. ++ @@ -27831,14 +27899,14 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with ++X select(x+->prime? x,m) explicitEntries?: % -> Boolean - ++ explicitEntries?(s) returns true if the stream s has + ++explicitEntries?(s) returns true if the stream s has ++ explicitly computed entries, and false otherwise. ++ ++X m:=[i for i in 0..] ++X explicitEntries? m explicitlyEmpty?: % -> Boolean - ++ explicitlyEmpty?(s) returns true if the stream is an + ++explicitlyEmpty?(s) returns true if the stream is an ++ (explicitly) empty stream. ++ Note that this is a null test which will not cause lazy evaluation. ++ @@ -27846,7 +27914,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with ++X explicitlyEmpty? m lazy?: % -> Boolean - ++ lazy?(s) returns true if the first node of the stream s + ++lazy?(s) returns true if the first node of the stream s ++ is a lazy evaluation mechanism which could produce an ++ additional entry to s. ++ @@ -27854,13 +27922,14 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with ++X lazy? m lazyEvaluate: % -> % - ++ lazyEvaluate(s) causes one lazy evaluation of stream s. + ++lazyEvaluate(s) causes one lazy evaluation of stream s. ++ Caution: the first node must be a lazy evaluation mechanism ++ (satisfies \spad{lazy?(s) = true}) as there is no error check. ++ Note that a call to this function may ++ or may not produce an explicit first entry + frst: % -> S - ++ frst(s) returns the first element of stream s. + ++frst(s) returns the first element of stream s. ++ Caution: this function should only be called after a \spad{empty?} ++ test has been made since there no error check. ++ @@ -27868,15 +27937,15 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with ++X frst m rst: % -> % - ++ rst(s) returns a pointer to the next node of stream s. - ++ Caution: this function should only be called after a \spad{empty?} + ++rst(s) returns a pointer to the next node of stream s. + ++ Cautrion: this function should only be called after a \spad{empty?} ++ test has been made since there no error check. ++ ++X m:=[i for i in 0..] ++X rst m numberOfComputedEntries: % -> NonNegativeInteger - ++ numberOfComputedEntries(st) returns the number of explicitly + ++numberOfComputedEntries(st) returns the number of explicitly ++ computed entries of stream st which exist immediately prior to the ++ time this function is called. ++ @@ -27884,7 +27953,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with ++X numberOfComputedEntries m extend: (%,Integer) -> % - ++ extend(st,n) causes entries to be computed, if necessary, + ++extend(st,n) causes entries to be computed, if necessary, ++ so that 'st' will have at least 'n' explicit entries or so ++ that all entries of 'st' will be computed if 'st' is finite ++ with length <= n. @@ -27895,7 +27964,7 @@ LazyStreamAggregate(S:Type): Category == StreamAggregate(S) with ++X numberOfComputedEntries m complete: % -> % - ++ complete(st) causes all entries of 'st' to be computed. + ++complete(st) causes all entries of 'st' to be computed. ++ this function should only be called on streams which are ++ known to be finite. ++ @@ -35288,24 +35357,29 @@ and RecKE=Record(key: Key,entry: Entry): ++ Date Created: August 87 through August 88 ++ Date Last Updated: April 1991 ++ Description: -++ A table aggregate is a model of a table, i.e. a discrete many-to-one +++ A table aggregate is a model of a table, that is, a discrete many-to-one ++ mapping from keys to entries. TableAggregate(Key:SetCategory, Entry:SetCategory): Category == Join(KeyedDictionary(Key,Entry),IndexedAggregate(Key,Entry)) with + setelt: (%,Key,Entry) -> Entry -- setelt_! later ++ setelt(t,k,e) (also written \axiom{t.k := e}) is equivalent ++ to \axiom{(insert([k,e],t); e)}. + table: () -> % - ++ table()$T creates an empty table of type T. + ++table()$T creates an empty table of type T. ++ ++E Data:=Record(age:Integer,gender:String) ++E a1:AssociationList(String,Data):=table() ++E a1."tim":=[55,"male"]$Data + table: List Record(key:Key,entry:Entry) -> % ++ table([x,y,...,z]) creates a table consisting of entries ++ \axiom{x,y,...,z}. + -- to become table: Record(key:Key,entry:Entry)* -> % + map: ((Entry, Entry) -> Entry, %, %) -> % ++ map(fn,t1,t2) creates a new table t from given tables t1 and t2 with ++ elements fn(x,y) where x and y are corresponding elements from t1 @@ -35799,58 +35873,80 @@ These exports come from \refto{OneDimensionalArrayAggregate}(R:Type): )abbrev category VECTCAT VectorCategory ++ Description: ++ \spadtype{VectorCategory} represents the type of vector like objects, -++ i.e. finite sequences indexed by some finite segment of the +++ that is, finite sequences indexed by some finite segment of the ++ integers. The operations available on vectors depend on the structure ++ of the underlying components. Many operations from the component domain ++ are defined for vectors componentwise. It can by assumed that extraction or ++ updating components can be done in constant time. VectorCategory(R:Type): Category == OneDimensionalArrayAggregate R with + if R has AbelianSemiGroup then + _+ : (%, %) -> % ++ x + y returns the component-wise sum of the vectors x and y. ++ Error: if x and y are not of the same length. + if R has AbelianMonoid then + zero: NonNegativeInteger -> % ++ zero(n) creates a zero vector of length n. + if R has AbelianGroup then + _- : % -> % ++ -x negates all components of the vector x. + _- : (%, %) -> % ++ x - y returns the component-wise difference of the vectors x and y. ++ Error: if x and y are not of the same length. + _* : (Integer, %) -> % ++ n * y multiplies each component of the vector y by the integer n. + if R has Monoid then + _* : (R, %) -> % ++ r * y multiplies the element r times each component of the vector y. + _* : (%, R) -> % ++ y * r multiplies each component of the vector y by the element r. + if R has Ring then + dot: (%, %) -> R ++ dot(x,y) computes the inner product of the two vectors x and y. ++ Error: if x and y are not of the same length. + outerProduct: (%, %) -> Matrix R ++ outerProduct(u,v) constructs the matrix whose (i,j)'th element is ++ u(i)*v(j). + cross: (%, %) -> % - ++ vectorProduct(u,v) constructs the cross product of u and v. + ++ cross(u,v) constructs the cross product of u and v. ++ Error: if u and v are not of length 3. + if R has RadicalCategory and R has Ring then + length: % -> R - ++ length(v) computes the sqrt(dot(v,v)), i.e. the magnitude + ++ length(v) computes the sqrt(dot(v,v)), that is, the magnitude + magnitude: % -> R - ++ magnitude(v) computes the sqrt(dot(v,v)), i.e. the length + ++ magnitude(v) computes the sqrt(dot(v,v)), that is, the length add + if R has AbelianSemiGroup then + u + v == (n := #u) ^= #v => error "Vectors must be of the same length" map(_+ , u, v) if R has AbelianMonoid then + zero n == new(n, 0) if R has AbelianGroup then + - u == map(x +-> -x, u) n:Integer * u:% == map(x +-> n * x, u) @@ -35858,11 +35954,13 @@ VectorCategory(R:Type): Category == OneDimensionalArrayAggregate R with u - v == u + (-v) if R has Monoid then + u:% * r:R == map(x +-> x * r, u) r:R * u:% == map(x +-> r * x, u) if R has Ring then + dot(u, v) == #u ^= #v => error "Vectors must be of the same length" _+/[qelt(u, i) * qelt(v, i) for i in minIndex u .. maxIndex u] @@ -35878,6 +35976,7 @@ VectorCategory(R:Type): Category == OneDimensionalArrayAggregate R with qelt(u, 1)*qelt(v, 2) - qelt(u, 2)*qelt(v, 1) ] if R has RadicalCategory and R has Ring then + length p == sqrt(dot(p,p)) @@ -39740,19 +39839,23 @@ RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where --% Predicates square? : % -> Boolean - ++ \spad{square?(m)} returns true if m is a square matrix (i.e. if m + ++ \spad{square?(m)} returns true if m is a square matrix (that is, if m ++ has the same number of rows as columns) and false otherwise. + diagonal?: % -> Boolean ++ \spad{diagonal?(m)} returns true if the matrix m is square and - ++ diagonal (i.e. all entries of m not on the diagonal are zero) and + ++ diagonal (that is, all entries of m not on the diagonal are zero) and ++ false otherwise. + symmetric?: % -> Boolean ++ \spad{symmetric?(m)} returns true if the matrix m is square and - ++ symmetric (i.e. \spad{m[i,j] = m[j,i]} for all \spad{i} and j) and + ++ symmetric (that is, \spad{m[i,j] = m[j,i]} for all \spad{i} and j) and ++ false otherwise. + antisymmetric?: % -> Boolean ++ \spad{antisymmetric?(m)} returns true if the matrix m is square and - ++ antisymmetric (i.e. \spad{m[i,j] = -m[j,i]} for all \spad{i} and j) + ++ antisymmetric. That is, + ++ \spad{m[i,j] = -m[j,i]} for all \spad{i} and j ++ and false otherwise. --% Size inquiries @@ -39760,17 +39863,22 @@ RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where minRowIndex : % -> Integer ++ \spad{minRowIndex(m)} returns the index of the 'first' row of the ++ matrix m. + maxRowIndex : % -> Integer ++ \spad{maxRowIndex(m)} returns the index of the 'last' row of the ++ matrix m. + minColIndex : % -> Integer ++ \spad{minColIndex(m)} returns the index of the 'first' column of the ++ matrix m. + maxColIndex : % -> Integer ++ \spad{maxColIndex(m)} returns the index of the 'last' column of the ++ matrix m. + nrows : % -> NonNegativeInteger ++ \spad{nrows(m)} returns the number of rows in the matrix m. + ncols : % -> NonNegativeInteger ++ \spad{ncols(m)} returns the number of columns in the matrix m. @@ -39779,23 +39887,28 @@ RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where listOfLists: % -> List List R ++ \spad{listOfLists(m)} returns the rows of the matrix m as a list ++ of lists. + elt: (%,Integer,Integer) -> R ++ \spad{elt(m,i,j)} returns the element in the \spad{i}th row and ++ \spad{j}th column of the matrix m. ++ Error: if indices are outside the proper ++ ranges. + qelt: (%,Integer,Integer) -> R ++ \spad{qelt(m,i,j)} returns the element in the \spad{i}th row and ++ \spad{j}th column of ++ the matrix m. Note that there is NO error check to determine ++ if indices are in the proper ranges. + elt: (%,Integer,Integer,R) -> R ++ \spad{elt(m,i,j,r)} returns the element in the \spad{i}th row and ++ \spad{j}th column of the matrix m, if m has an \spad{i}th row and a ++ \spad{j}th column, and returns r otherwise. + row: (%,Integer) -> Row ++ \spad{row(m,i)} returns the \spad{i}th row of the matrix m. ++ Error: if the index is outside the proper range. + column: (%,Integer) -> Col ++ \spad{column(m,j)} returns the \spad{j}th column of the matrix m. ++ Error: if the index outside the proper range. @@ -39804,6 +39917,7 @@ RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where map: (R -> R,%) -> % ++ \spad{map(f,a)} returns b, where \spad{b(i,j) = a(i,j)} for all i, j. + map:((R,R) -> R,%,%) -> % ++ \spad{map(f,a,b)} returns c, where c is such that ++ \spad{c(i,j) = f(a(i,j),b(i,j))} for all \spad{i}, j. @@ -39811,24 +39925,32 @@ RectangularMatrixCategory(m,n,R,Row,Col): Category == Definition where --% Arithmetic if R has IntegralDomain then + "exquo": (%,R) -> Union(%,"failed") ++ \spad{exquo(m,r)} computes the exact quotient of the elements ++ of m by r, returning \axiom{"failed"} if this is not possible. + if R has Field then + "/": (%,R) -> % ++ \spad{m/r} divides the elements of m by r. Error: if \spad{r = 0}. --% Linear algebra if R has EuclideanDomain then + rowEchelon: % -> % ++ \spad{rowEchelon(m)} returns the row echelon form of the matrix m. + if R has IntegralDomain then + rank: % -> NonNegativeInteger ++ \spad{rank(m)} returns the rank of the matrix m. + nullity: % -> NonNegativeInteger ++ \spad{nullity(m)} returns the nullity of the matrix m. This is ++ the dimension of the null space of the matrix m. + nullSpace: % -> List Col ++ \spad{nullSpace(m)}+ returns a basis for the null space of ++ the matrix m. @@ -44281,47 +44403,71 @@ These exports come from \refto{OrderedAbelianMonoidSup}(): \begin{chunk}{category DIRPCAT DirectProductCategory} )abbrev category DIRPCAT DirectProductCategory --- all direct product category domains must be compiled --- without subsumption, set SourceLevelSubset to EQUAL ---)bo $noSubsumption := true ++ Description: ++ This category represents a finite cartesian product of a given type. ++ Many categorical properties are preserved under this construction. +-- all direct product category domains must be compiled +-- without subsumption, set SourceLevelSubset to EQUAL +--)bo $noSubsumption := true DirectProductCategory(dim:NonNegativeInteger, R:Type): Category == Join(IndexedAggregate(Integer, R), CoercibleTo Vector R) with + finiteAggregate ++ attribute to indicate an aggregate of finite size + directProduct: Vector R -> % ++ directProduct(v) converts the vector v to become ++ a direct product. Error: if the length of v is ++ different from dim. + if R has SetCategory then FullyRetractableTo R + if R has Ring then + BiModule(R, R) + DifferentialExtension R + FullyLinearlyExplicitRingOver R + unitVector: PositiveInteger -> % ++ unitVector(n) produces a vector with 1 in position n and ++ zero elsewhere. + dot: (%, %) -> R ++ dot(x,y) computes the inner product of the vectors x and y. + if R has AbelianSemiGroup then AbelianSemiGroup + if R has CancellationAbelianMonoid then CancellationAbelianMonoid + if R has Monoid then - Monoid + + Monoid + _* : (R, %) -> % ++ r * y multiplies the element r times each component of the ++ vector y. + _* : (%, R) -> % - ++ y*r multiplies each component of the vector y by the element r. + ++ y * r multiplies each component of the vector y + ++ by the element r. + if R has Finite then Finite + if R has CommutativeRing then + Algebra R + CommutativeRing + if R has unitsKnown then unitsKnown + if R has OrderedRing then OrderedRing + if R has OrderedAbelianMonoidSup then OrderedAbelianMonoidSup + if R has Field then VectorSpace R add if R has Ring then @@ -44950,74 +45096,93 @@ These exports come from \refto{NonAssociativeAlgebra}(R:CommutativeRing): FiniteRankNonAssociativeAlgebra(R:CommutativeRing): Category == NonAssociativeAlgebra R with + someBasis : () -> Vector % ++ someBasis() returns some \spad{R}-module basis. + rank : () -> PositiveInteger ++ rank() returns the rank of the algebra as \spad{R}-module. + conditionsForIdempotents: Vector % -> List Polynomial R ++ conditionsForIdempotents([v1,...,vn]) determines a complete list ++ of polynomial equations for the coefficients of idempotents ++ with respect to the \spad{R}-module basis \spad{v1},...,\spad{vn}. + structuralConstants: Vector % -> Vector Matrix R ++ structuralConstants([v1,v2,...,vm]) calculates the structural ++ constants \spad{[(gammaijk) for k in 1..m]} defined by ++ \spad{vi * vj = gammaij1 * v1 + ... + gammaijm * vm}, ++ where \spad{[v1,...,vm]} is an \spad{R}-module basis ++ of a subalgebra. + leftRegularRepresentation: (% , Vector %) -> Matrix R ++ leftRegularRepresentation(a,[v1,...,vn]) returns the matrix of ++ the linear map defined by left multiplication by \spad{a} ++ with respect to the \spad{R}-module basis \spad{[v1,...,vn]}. + rightRegularRepresentation: (% , Vector %) -> Matrix R ++ rightRegularRepresentation(a,[v1,...,vn]) returns the matrix of ++ the linear map defined by right multiplication by \spad{a} ++ with respect to the \spad{R}-module basis \spad{[v1,...,vn]}. + leftTrace: % -> R ++ leftTrace(a) returns the trace of the left regular representation ++ of \spad{a}. + rightTrace: % -> R ++ rightTrace(a) returns the trace of the right regular representation ++ of \spad{a}. + leftNorm: % -> R ++ leftNorm(a) returns the determinant of the left regular ++ representation of \spad{a}. + rightNorm: % -> R ++ rightNorm(a) returns the determinant of the right regular ++ representation of \spad{a}. + coordinates: (%, Vector %) -> Vector R ++ coordinates(a,[v1,...,vn]) returns the coordinates of \spad{a} ++ with respect to the \spad{R}-module basis \spad{v1},...,\spad{vn}. + coordinates: (Vector %, Vector %) -> Matrix R ++ coordinates([a1,...,am],[v1,...,vn]) returns a matrix whose ++ i-th row is formed by the coordinates of \spad{ai} ++ with respect to the \spad{R}-module basis \spad{v1},...,\spad{vn}. + represents: (Vector R, Vector %) -> % ++ represents([a1,...,am],[v1,...,vm]) returns the linear ++ combination \spad{a1*vm + ... + an*vm}. + leftDiscriminant: Vector % -> R ++ leftDiscriminant([v1,...,vn]) returns the determinant of the ++ \spad{n}-by-\spad{n} matrix whose element at the \spad{i}-th row ++ and \spad{j}-th column is given by the left trace of the product ++ \spad{vi*vj}. Note that this is the same as ++ \spad{determinant(leftTraceMatrix([v1,...,vn]))}. + rightDiscriminant: Vector % -> R ++ rightDiscriminant([v1,...,vn]) returns the determinant of the ++ \spad{n}-by-\spad{n} matrix whose element at the \spad{i}-th row ++ and \spad{j}-th column is given by the right trace of the product ++ \spad{vi*vj}. Note that this is the same as ++ \spad{determinant(rightTraceMatrix([v1,...,vn]))}. + leftTraceMatrix: Vector % -> Matrix R ++ leftTraceMatrix([v1,...,vn]) is the \spad{n}-by-\spad{n} matrix ++ whose element at the \spad{i}-th row and \spad{j}-th column is given ++ by the left trace of the product \spad{vi*vj}. + rightTraceMatrix: Vector % -> Matrix R ++ rightTraceMatrix([v1,...,vn]) is the \spad{n}-by-\spad{n} matrix ++ whose element at the \spad{i}-th row and \spad{j}-th column is given ++ by the right trace of the product \spad{vi*vj}. + leftCharacteristicPolynomial: % -> SparseUnivariatePolynomial R ++ leftCharacteristicPolynomial(a) returns the characteristic ++ polynomial of the left regular representation of \spad{a} ++ with respect to any basis. + rightCharacteristicPolynomial: % -> SparseUnivariatePolynomial R ++ rightCharacteristicPolynomial(a) returns the characteristic ++ polynomial of the right regular representation of \spad{a} @@ -45030,60 +45195,73 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing): commutative?:()-> Boolean ++ commutative?() tests if multiplication in the algebra ++ is commutative. + antiCommutative?:()-> Boolean ++ antiCommutative?() tests if \spad{a*a = 0} ++ for all \spad{a} in the algebra. ++ Note that this implies \spad{a*b + b*a = 0} for all ++ \spad{a} and \spad{b}. + associative?:()-> Boolean ++ associative?() tests if multiplication in algebra ++ is associative. + antiAssociative?:()-> Boolean ++ antiAssociative?() tests if multiplication in algebra - ++ is anti-associative, i.e. \spad{(a*b)*c + a*(b*c) = 0} + ++ is anti-associative, that is, \spad{(a*b)*c + a*(b*c) = 0} ++ for all \spad{a},b,c in the algebra. + leftAlternative?: ()-> Boolean ++ leftAlternative?() tests if \spad{2*associator(a,a,b) = 0} ++ for all \spad{a}, b in the algebra. ++ Note that we only can test this; in general we don't know ++ whether \spad{2*a=0} implies \spad{a=0}. + rightAlternative?: ()-> Boolean ++ rightAlternative?() tests if \spad{2*associator(a,b,b) = 0} ++ for all \spad{a}, b in the algebra. ++ Note that we only can test this; in general we don't know ++ whether \spad{2*a=0} implies \spad{a=0}. + flexible?: ()-> Boolean ++ flexible?() tests if \spad{2*associator(a,b,a) = 0} ++ for all \spad{a}, b in the algebra. ++ Note that we only can test this; in general we don't know ++ whether \spad{2*a=0} implies \spad{a=0}. + alternative?: ()-> Boolean ++ alternative?() tests if ++ \spad{2*associator(a,a,b) = 0 = 2*associator(a,b,b)} ++ for all \spad{a}, b in the algebra. ++ Note that we only can test this; in general we don't know ++ whether \spad{2*a=0} implies \spad{a=0}. + powerAssociative?:()-> Boolean ++ powerAssociative?() tests if all subalgebras ++ generated by a single element are associative. + jacobiIdentity?:() -> Boolean ++ jacobiIdentity?() tests if \spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} ++ for all \spad{a},b,c in the algebra. For example, this holds ++ for crossed products of 3-dimensional vectors. + lieAdmissible?: () -> Boolean ++ lieAdmissible?() tests if the algebra defined by the commutators - ++ is a Lie algebra, i.e. satisfies the Jacobi identity. + ++ is a Lie algebra, that is, satisfies the Jacobi identity. ++ The property of anticommutativity follows from definition. + jordanAdmissible?: () -> Boolean ++ jordanAdmissible?() tests if 2 is invertible in the ++ coefficient domain and the multiplication defined by ++ \spad{(1/2)(a*b+b*a)} determines a - ++ Jordan algebra, i.e. satisfies the Jordan identity. + ++ Jordan algebra, that is, satisfies the Jordan identity. ++ The property of \spadatt{commutative("*")} ++ follows from by definition. + noncommutativeJordanAlgebra?: () -> Boolean ++ noncommutativeJordanAlgebra?() tests if the algebra ++ is flexible and Jordan admissible. + jordanAlgebra?:() -> Boolean ++ jordanAlgebra?() tests if the algebra is commutative, ++ characteristic is not 2, and \spad{(a*b)*a**2 - a*(b*a**2) = 0} @@ -45091,6 +45269,7 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing): ++ Example: ++ for every associative algebra \spad{(A,+,@)} we can construct a ++ Jordan algebra \spad{(A,+,*)}, where \spad{a*b := (a@b+b@a)/2}. + lieAlgebra?:() -> Boolean ++ lieAlgebra?() tests if the algebra is anticommutative ++ and \spad{(a*b)*c + (b*c)*a + (c*a)*b = 0} @@ -45100,58 +45279,72 @@ FiniteRankNonAssociativeAlgebra(R:CommutativeRing): ++ Lie algebra \spad{(A,+,*)}, where \spad{a*b := a@b-b@a}. if R has IntegralDomain then + -- we not neccessarily have a unit, hence we don't inherit -- the next 3 functions anc hence copy them from MonadWithUnit: + recip: % -> Union(%,"failed") ++ recip(a) returns an element, which is both a left and a right ++ inverse of \spad{a}, ++ or \spad{"failed"} if there is no unit element, if such an ++ element doesn't exist or cannot be determined (see unitsKnown). + leftRecip: % -> Union(%,"failed") ++ leftRecip(a) returns an element, which is a left inverse of ++ \spad{a}, or \spad{"failed"} if there is no unit element, if such ++ an element doesn't exist or cannot be determined (see unitsKnown). + rightRecip: % -> Union(%,"failed") ++ rightRecip(a) returns an element, which is a right inverse of ++ \spad{a}, ++ or \spad{"failed"} if there is no unit element, if such an ++ element doesn't exist or cannot be determined (see unitsKnown). + associatorDependence:() -> List Vector R - ++ associatorDependence() looks for the associator identities, i.e. - ++ finds a basis of the solutions of the linear combinations of the + ++ associatorDependence() looks for the associator identities, that + ++ is, finds a basis of the solutions of the linear combinations of the ++ six permutations of \spad{associator(a,b,c)} which yield 0, ++ for all \spad{a},b,c in the algebra. ++ The order of the permutations is \spad{123 231 312 132 321 213}. + leftMinimalPolynomial : % -> SparseUnivariatePolynomial R ++ leftMinimalPolynomial(a) returns the polynomial determined by the ++ smallest non-trivial linear combination of left powers of ++ \spad{a}. Note that the polynomial never has a constant term as in ++ general the algebra has no unit. + rightMinimalPolynomial : % -> SparseUnivariatePolynomial R ++ rightMinimalPolynomial(a) returns the polynomial determined by the ++ smallest non-trivial linear ++ combination of right powers of \spad{a}. ++ Note that the polynomial never has a constant term as in general ++ the algebra has no unit. + leftUnits:() -> Union(Record(particular: %, basis: List %), "failed") ++ leftUnits() returns the affine space of all left units of the ++ algebra, or \spad{"failed"} if there is none. + rightUnits:() -> Union(Record(particular: %, basis: List %), "failed") ++ rightUnits() returns the affine space of all right units of the ++ algebra, or \spad{"failed"} if there is none. + leftUnit:() -> Union(%, "failed") ++ leftUnit() returns a left unit of the algebra ++ (not necessarily unique), or \spad{"failed"} if there is none. + rightUnit:() -> Union(%, "failed") ++ rightUnit() returns a right unit of the algebra ++ (not necessarily unique), or \spad{"failed"} if there is none. + unit:() -> Union(%, "failed") ++ unit() returns a unit of the algebra (necessarily unique), ++ or \spad{"failed"} if there is none. + -- we not necessarily have a unit, hence we can't say anything -- about characteristic -- if R has CharacteristicZero then CharacteristicZero -- if R has CharacteristicNonZero then CharacteristicNonZero + unitsKnown ++ unitsKnown means that \spadfun{recip} truly yields reciprocal ++ or \spad{"failed"} if not a unit, @@ -58093,71 +58286,81 @@ These exports come from \refto{RadicalCategory}(): ++ Model for algebraically closed fields. AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with + rootOf: Polynomial $ -> $ - ++ rootOf(p) returns y such that \spad{p(y) = 0}. + ++rootOf(p) returns y such that \spad{p(y) = 0}. ++ Error: if p has more than one variable y. ++ ++X a:Polynomial(Integer):=-3*x^3+2*x+13 ++X rootOf(a) + rootOf: SparseUnivariatePolynomial $ -> $ - ++ rootOf(p) returns y such that \spad{p(y) = 0}. + ++rootOf(p) returns y such that \spad{p(y) = 0}. ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 ++X rootOf(a) + rootOf: (SparseUnivariatePolynomial $, Symbol) -> $ - ++ rootOf(p, y) returns y such that \spad{p(y) = 0}. + ++rootOf(p, y) returns y such that \spad{p(y) = 0}. ++ The object returned displays as \spad{'y}. ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 ++X rootOf(a,x) + rootsOf: Polynomial $ -> List $ - ++ rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. + ++rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. ++ Note that the returned symbols y1,...,yn are bound in the ++ interpreter to respective root values. ++ Error: if p has more than one variable y. ++ ++X a:Polynomial(Integer):=-3*x^3+2*x+13 ++X rootsOf(a) + rootsOf: SparseUnivariatePolynomial $ -> List $ - ++ rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. + ++rootsOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. ++ Note that the returned symbols y1,...,yn are bound in the interpreter ++ to respective root values. ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 ++X rootsOf(a) + rootsOf: (SparseUnivariatePolynomial $, Symbol) -> List $ - ++ rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}; + ++rootsOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}; ++ The returned roots display as \spad{'y1},...,\spad{'yn}. ++ Note that the returned symbols y1,...,yn are bound in the interpreter ++ to respective root values. ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 ++X rootsOf(a,x) + zeroOf: Polynomial $ -> $ - ++ zeroOf(p) returns y such that \spad{p(y) = 0}. + ++zeroOf(p) returns y such that \spad{p(y) = 0}. ++ If possible, y is expressed in terms of radicals. ++ Otherwise it is an implicit algebraic quantity. ++ Error: if p has more than one variable y. ++ ++X a:Polynomial(Integer):=-3*x^2+2*x-13 ++X zeroOf(a) + zeroOf: SparseUnivariatePolynomial $ -> $ - ++ zeroOf(p) returns y such that \spad{p(y) = 0}; + ++zeroOf(p) returns y such that \spad{p(y) = 0}; ++ if possible, y is expressed in terms of radicals. ++ Otherwise it is an implicit algebraic quantity. ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 ++X zeroOf(a) + zeroOf: (SparseUnivariatePolynomial $, Symbol) -> $ - ++ zeroOf(p, y) returns y such that \spad{p(y) = 0}; + ++zeroOf(p, y) returns y such that \spad{p(y) = 0}; ++ if possible, y is expressed in terms of radicals. ++ Otherwise it is an implicit algebraic quantity which ++ displays as \spad{'y}. ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 ++X zeroOf(a,x) + zerosOf: Polynomial $ -> List $ - ++ zerosOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. + ++zerosOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. ++ The yi's are expressed in radicals if possible. ++ Otherwise they are implicit algebraic quantities. ++ The returned symbols y1,...,yn are bound in the interpreter @@ -58166,8 +58369,9 @@ AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with ++ ++X a:Polynomial(Integer):=-3*x^2+2*x-13 ++X zerosOf(a) + zerosOf: SparseUnivariatePolynomial $ -> List $ - ++ zerosOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. + ++zerosOf(p) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. ++ The yi's are expressed in radicals if possible, and otherwise ++ as implicit algebraic quantities. ++ The returned symbols y1,...,yn are bound in the interpreter @@ -58175,8 +58379,9 @@ AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 ++X zerosOf(a) + zerosOf: (SparseUnivariatePolynomial $, Symbol) -> List $ - ++ zerosOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. + ++zerosOf(p, y) returns \spad{[y1,...,yn]} such that \spad{p(yi) = 0}. ++ The yi's are expressed in radicals if possible, and otherwise ++ as implicit algebraic quantities ++ which display as \spad{'yi}. @@ -58185,7 +58390,9 @@ AlgebraicallyClosedField(): Category == Join(Field,RadicalCategory) with ++ ++X a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13 ++X zerosOf(a,x) + add + SUP ==> SparseUnivariatePolynomial $ assign : (Symbol, $) -> $ @@ -72952,7 +73159,7 @@ These exports come from \refto{FiniteFieldCategory}(): ++ The additive group of K becomes a module over the ring of ++ polynomials over F via the operation ++ \spadfun{linearAssociatedExp}(a:K,f:SparseUnivariatePolynomial F) -++ which is linear over F, i.e. for elements a from K, +++ which is linear over F, that is, for elements a from K, ++ c,d from F and f,g univariate polynomials over F ++ we have \spadfun{linearAssociatedExp}(a,cf+dg) equals c times ++ \spadfun{linearAssociatedExp}(a,f) plus d times @@ -72971,82 +73178,103 @@ FiniteAlgebraicExtensionField(F : Field) : Category == _ Join(ExtensionField F, RetractableTo F) with -- should be unified with algebras -- Join(ExtensionField F, FramedAlgebra F, RetractableTo F) with + basis : () -> Vector $ ++ basis() returns a fixed basis of \$ as \spad{F}-vectorspace. + basis : PositiveInteger -> Vector $ ++ basis(n) returns a fixed basis of a subfield of \$ as ++ \spad{F}-vectorspace. + coordinates : $ -> Vector F ++ coordinates(a) returns the coordinates of \spad{a} with respect ++ to the fixed \spad{F}-vectorspace basis. + coordinates : Vector $ -> Matrix F ++ coordinates([v1,...,vm]) returns the coordinates of the ++ vi's with to the fixed basis. The coordinates of vi are ++ contained in the ith row of the matrix returned by this ++ function. + represents: Vector F -> $ ++ represents([a1,..,an]) returns \spad{a1*v1 + ... + an*vn}, where ++ v1,...,vn are the elements of the fixed basis. + minimalPolynomial: $ -> SparseUnivariatePolynomial F ++ minimalPolynomial(a) returns the minimal polynomial of an ++ element \spad{a} over the ground field F. + definingPolynomial: () -> SparseUnivariatePolynomial F ++ definingPolynomial() returns the polynomial used to define ++ the field extension. + extensionDegree : () -> PositiveInteger ++ extensionDegree() returns the degree of field extension. + degree : $ -> PositiveInteger ++ degree(a) returns the degree of the minimal polynomial of an ++ element \spad{a} over the ground field F. + norm: $ -> F ++ norm(a) computes the norm of \spad{a} with respect to the ++ field considered as an algebra with 1 over the ground field F. + trace: $ -> F ++ trace(a) computes the trace of \spad{a} with respect to ++ the field considered as an algebra with 1 over the ground field F. + if F has Finite then + FiniteFieldCategory + minimalPolynomial: ($,PositiveInteger) -> SparseUnivariatePolynomial $ ++ minimalPolynomial(x,n) computes the minimal polynomial of x over ++ the field of extension degree n over the ground field F. + norm: ($,PositiveInteger) -> $ ++ norm(a,d) computes the norm of \spad{a} with respect to the field ++ of extension degree d over the ground field of size. ++ Error: if d does not divide the extension degree of \spad{a}. ++ Note that norm(a,d) = reduce(*,[a**(q**(d*i)) for i in 0..n/d]) + trace: ($,PositiveInteger) -> $ ++ trace(a,d) computes the trace of \spad{a} with respect to the ++ field of extension degree d over the ground field of size q. ++ Error: if d does not divide the extension degree of \spad{a}. ++ Note that ++ \spad{trace(a,d)=reduce(+,[a**(q**(d*i)) for i in 0..n/d])}. + createNormalElement: () -> $ ++ createNormalElement() computes a normal element over the ground ++ field F, that is, ++ \spad{a**(q**i), 0 <= i < extensionDegree()} is an F-basis, ++ where \spad{q = size()\$F}. ++ Reference: Such an element exists Lidl/Niederreiter: Theorem 2.35. + normalElement: () -> $ ++ normalElement() returns a element, normal over the ground field F, - ++ i.e. \spad{a**(q**i), 0 <= i < extensionDegree()} is an F-basis, + ++ thus \spad{a**(q**i), 0 <= i < extensionDegree()} is an F-basis, ++ where \spad{q = size()\$F}. ++ At the first call, the element is computed by ++ \spadfunFrom{createNormalElement}{FiniteAlgebraicExtensionField} ++ then cached in a global variable. ++ On subsequent calls, the element is retrieved by referencing the ++ global variable. + normal?: $ -> Boolean ++ normal?(a) tests whether the element \spad{a} is normal over the - ++ ground field F, i.e. + ++ ground field F, that is, ++ \spad{a**(q**i), 0 <= i <= extensionDegree()-1} is an F-basis, ++ where \spad{q = size()\$F}. ++ Implementation according to Lidl/Niederreiter: Theorem 2.39. + generator: () -> $ ++ generator() returns a root of the defining polynomial. ++ This element generates the field as an algebra over the ground ++ field. + linearAssociatedExp:($,SparseUnivariatePolynomial F) -> $ - ++ linearAssociatedExp(a,f) is linear over F, i.e. + ++ linearAssociatedExp(a,f) is linear over F, that is, ++ for elements a from \$, c,d form F and ++ f,g univariate polynomials over F we have ++ \spadfun{linearAssociatedExp}(a,cf+dg) equals c times @@ -73057,12 +73285,15 @@ FiniteAlgebraicExtensionField(F : Field) : Category == _ ++ \spadfun{linearAssociatedExp}(a,monomial(1,k)\$SUP(F)) is ++ defined to be \spadfun{Frobenius}(a,k) which is a**(q**k), ++ where q=size()\$F. + linearAssociatedOrder: $ -> SparseUnivariatePolynomial F ++ linearAssociatedOrder(a) retruns the monic polynomial g of ++ least degree, such that \spadfun{linearAssociatedExp}(a,g) is 0. + linearAssociatedLog: $ -> SparseUnivariatePolynomial F ++ linearAssociatedLog(a) returns a polynomial g, such that ++ \spadfun{linearAssociatedExp}(normalElement(),g) equals a. + linearAssociatedLog: ($,$) -> _ Union(SparseUnivariatePolynomial F,"failed") ++ linearAssociatedLog(b,a) returns a polynomial g, such @@ -76194,30 +76425,34 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where REC ==> Record(num:$, den:UP, derivden:UP, gd:UP) Definition ==> MonogenicAlgebra(RF, UPUP) with + numberOfComponents : () -> NonNegativeInteger - ++ numberOfComponents() returns the number of absolutely irreducible + ++numberOfComponents() returns the number of absolutely irreducible ++ components. ++ ++X P0 := UnivariatePolynomial(x, Integer) ++X P1 := UnivariatePolynomial(y, Fraction P0) ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20) ++X numberOfComponents()$R + genus : () -> NonNegativeInteger - ++ genus() returns the genus of one absolutely irreducible component + ++genus() returns the genus of one absolutely irreducible component ++ ++X P0 := UnivariatePolynomial(x, Integer) ++X P1 := UnivariatePolynomial(y, Fraction P0) ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20) ++X genus()$R + absolutelyIrreducible? : () -> Boolean - ++ absolutelyIrreducible?() tests if the curve absolutely irreducible? + ++absolutelyIrreducible?() tests if the curve absolutely irreducible? ++ ++X P0 := UnivariatePolynomial(x, Integer) ++X P1 := UnivariatePolynomial(y, Fraction P0) ++X R2 := RadicalFunctionField(INT, P0, P1, 2 * x**2, 4) ++X absolutelyIrreducible?()$R2 + rationalPoint? : (F, F) -> Boolean - ++ rationalPoint?(a, b) tests if \spad{(x=a,y=b)} is on the curve. + ++rationalPoint?(a, b) tests if \spad{(x=a,y=b)} is on the curve. ++ ++X P0 := UnivariatePolynomial(x, Integer) ++X P1 := UnivariatePolynomial(y, Fraction P0) @@ -76225,8 +76460,9 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where ++X rationalPoint?(0,0)$R ++X R2 := RadicalFunctionField(INT, P0, P1, 2 * x**2, 4) ++X rationalPoint?(0,0)$R2 + branchPointAtInfinity? : () -> Boolean - ++ branchPointAtInfinity?() tests if there is a branch point + ++branchPointAtInfinity?() tests if there is a branch point ++ at infinity. ++ ++X P0 := UnivariatePolynomial(x, Integer) @@ -76235,52 +76471,68 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where ++X branchPointAtInfinity?()$R ++X R2 := RadicalFunctionField(INT, P0, P1, 2 * x**2, 4) ++X branchPointAtInfinity?()$R + branchPoint? : F -> Boolean - ++ branchPoint?(a) tests whether \spad{x = a} is a branch point. + ++branchPoint?(a) tests whether \spad{x = a} is a branch point. + branchPoint? : UP -> Boolean - ++ branchPoint?(p) tests whether \spad{p(x) = 0} is a branch point. + ++branchPoint?(p) tests whether \spad{p(x) = 0} is a branch point. + singularAtInfinity? : () -> Boolean - ++ singularAtInfinity?() tests if there is a singularity at infinity. + ++singularAtInfinity?() tests if there is a singularity at infinity. + singular? : F -> Boolean - ++ singular?(a) tests whether \spad{x = a} is singular. + ++singular?(a) tests whether \spad{x = a} is singular. + singular? : UP -> Boolean - ++ singular?(p) tests whether \spad{p(x) = 0} is singular. + ++singular?(p) tests whether \spad{p(x) = 0} is singular. + ramifiedAtInfinity? : () -> Boolean - ++ ramifiedAtInfinity?() tests if infinity is ramified. + ++ramifiedAtInfinity?() tests if infinity is ramified. + ramified? : F -> Boolean - ++ ramified?(a) tests whether \spad{x = a} is ramified. + ++ramified?(a) tests whether \spad{x = a} is ramified. + ramified? : UP -> Boolean - ++ ramified?(p) tests whether \spad{p(x) = 0} is ramified. + ++ramified?(p) tests whether \spad{p(x) = 0} is ramified. + integralBasis : () -> Vector $ - ++ integralBasis() returns the integral basis for the curve. + ++integralBasis() returns the integral basis for the curve. ++ ++X P0 := UnivariatePolynomial(x, Integer) ++X P1 := UnivariatePolynomial(y, Fraction P0) ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20) ++X integralBasis()$R + integralBasisAtInfinity: () -> Vector $ - ++ integralBasisAtInfinity() returns the local integral basis + ++integralBasisAtInfinity() returns the local integral basis ++ at infinity ++ ++X P0 := UnivariatePolynomial(x, Integer) ++X P1 := UnivariatePolynomial(y, Fraction P0) ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20) ++X integralBasisAtInfinity()$R + integralAtInfinity? : $ -> Boolean - ++ integralAtInfinity?() tests if f is locally integral at infinity. + ++integralAtInfinity?() tests if f is locally integral at infinity. + integral? : $ -> Boolean - ++ integral?() tests if f is integral over \spad{k[x]}. + ++integral?() tests if f is integral over \spad{k[x]}. + complementaryBasis : Vector $ -> Vector $ - ++ complementaryBasis(b1,...,bn) returns the complementary basis + ++complementaryBasis(b1,...,bn) returns the complementary basis ++ \spad{(b1',...,bn')} of \spad{(b1,...,bn)}. + normalizeAtInfinity : Vector $ -> Vector $ - ++ normalizeAtInfinity(v) makes v normal at infinity. + ++normalizeAtInfinity(v) makes v normal at infinity. + reduceBasisAtInfinity : Vector $ -> Vector $ - ++ reduceBasisAtInfinity(b1,...,bn) returns \spad{(x**i * bj)} + ++reduceBasisAtInfinity(b1,...,bn) returns \spad{(x**i * bj)} ++ for all i,j such that \spad{x**i*bj} is locally integral ++ at infinity. + integralMatrix : () -> Matrix RF - ++ integralMatrix() returns M such that + ++integralMatrix() returns M such that ++ \spad{(w1,...,wn) = M (1, y, ..., y**(n-1))}, ++ where \spad{(w1,...,wn)} is the integral basis of ++ \spadfunFrom{integralBasis}{FunctionFieldCategory}. @@ -76289,8 +76541,9 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where ++X P1 := UnivariatePolynomial(y, Fraction P0) ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20) ++X integralMatrix()$R + inverseIntegralMatrix : () -> Matrix RF - ++ inverseIntegralMatrix() returns M such that + ++inverseIntegralMatrix() returns M such that ++ \spad{M (w1,...,wn) = (1, y, ..., y**(n-1))} ++ where \spad{(w1,...,wn)} is the integral basis of ++ \spadfunFrom{integralBasis}{FunctionFieldCategory}. @@ -76299,8 +76552,9 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where ++X P1 := UnivariatePolynomial(y, Fraction P0) ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20) ++X inverseIntegralMatrix()$R + integralMatrixAtInfinity : () -> Matrix RF - ++ integralMatrixAtInfinity() returns M such that + ++integralMatrixAtInfinity() returns M such that ++ \spad{(v1,...,vn) = M (1, y, ..., y**(n-1))} ++ where \spad{(v1,...,vn)} is the local integral basis at infinity ++ returned by \spad{infIntBasis()}. @@ -76309,8 +76563,9 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where ++X P1 := UnivariatePolynomial(y, Fraction P0) ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20) ++X integralMatrixAtInfinity()$R + inverseIntegralMatrixAtInfinity: () -> Matrix RF - ++ inverseIntegralMatrixAtInfinity() returns M such + ++inverseIntegralMatrixAtInfinity() returns M such ++ that \spad{M (v1,...,vn) = (1, y, ..., y**(n-1))} ++ where \spad{(v1,...,vn)} is the local integral basis at infinity ++ returned by \spad{infIntBasis()}. @@ -76319,66 +76574,84 @@ FunctionFieldCategory(F, UP, UPUP): Category == Definition where ++X P1 := UnivariatePolynomial(y, Fraction P0) ++X R := RadicalFunctionField(INT, P0, P1, 1 - x**20, 20) ++X inverseIntegralMatrixAtInfinity()$R + yCoordinates : $ -> Record(num:Vector(UP), den:UP) - ++ yCoordinates(f) returns \spad{[[A1,...,An], D]} such that + ++yCoordinates(f) returns \spad{[[A1,...,An], D]} such that ++ \spad{f = (A1 + A2 y +...+ An y**(n-1)) / D}. + represents : (Vector UP, UP) -> $ - ++ represents([A0,...,A(n-1)],D) returns + ++represents([A0,...,A(n-1)],D) returns ++ \spad{(A0 + A1 y +...+ A(n-1)*y**(n-1))/D}. + integralCoordinates : $ -> Record(num:Vector(UP), den:UP) - ++ integralCoordinates(f) returns \spad{[[A1,...,An], D]} such that + ++integralCoordinates(f) returns \spad{[[A1,...,An], D]} such that ++ \spad{f = (A1 w1 +...+ An wn) / D} where \spad{(w1,...,wn)} is the ++ integral basis returned by \spad{integralBasis()}. + integralRepresents : (Vector UP, UP) -> $ - ++ integralRepresents([A1,...,An], D) returns + ++integralRepresents([A1,...,An], D) returns ++ \spad{(A1 w1+...+An wn)/D} ++ where \spad{(w1,...,wn)} is the integral ++ basis of \spad{integralBasis()}. + integralDerivationMatrix:(UP -> UP) -> Record(num:Matrix(UP),den:UP) - ++ integralDerivationMatrix(d) extends the derivation d from UP to $ + ++integralDerivationMatrix(d) extends the derivation d from UP to $ ++ and returns (M, Q) such that the i^th row of M divided by Q form ++ the coordinates of \spad{d(wi)} with respect to \spad{(w1,...,wn)} ++ where \spad{(w1,...,wn)} is the integral basis returned ++ by integralBasis(). + integral? : ($, F) -> Boolean - ++ integral?(f, a) tests whether f is locally integral at \spad{x = a}. + ++integral?(f, a) tests whether f is locally integral at \spad{x = a}. + integral? : ($, UP) -> Boolean - ++ integral?(f, p) tests whether f is locally integral at + ++integral?(f, p) tests whether f is locally integral at ++ \spad{p(x) = 0} + differentiate : ($, UP -> UP) -> $ - ++ differentiate(x, d) extends the derivation d from UP to $ and + ++differentiate(x, d) extends the derivation d from UP to $ and ++ applies it to x. + represents : (Vector UP, UP) -> $ - ++ represents([A0,...,A(n-1)],D) returns + ++represents([A0,...,A(n-1)],D) returns ++ \spad{(A0 + A1 y +...+ A(n-1)*y**(n-1))/D}. + primitivePart : $ -> $ - ++ primitivePart(f) removes the content of the denominator and + ++primitivePart(f) removes the content of the denominator and ++ the common content of the numerator of f. + elt : ($, F, F) -> F - ++ elt(f,a,b) or f(a, b) returns the value of f + ++elt(f,a,b) or f(a, b) returns the value of f ++ at the point \spad{(x = a, y = b)} ++ if it is not singular. + elliptic : () -> Union(UP, "failed") - ++ elliptic() returns \spad{p(x)} if the curve is the elliptic + ++elliptic() returns \spad{p(x)} if the curve is the elliptic ++ defined by \spad{y**2 = p(x)}, "failed" otherwise. + hyperelliptic : () -> Union(UP, "failed") - ++ hyperelliptic() returns \spad{p(x)} if the curve is the + ++hyperelliptic() returns \spad{p(x)} if the curve is the ++ hyperelliptic ++ defined by \spad{y**2 = p(x)}, "failed" otherwise. + algSplitSimple : ($, UP -> UP) -> REC - ++ algSplitSimple(f, D) returns \spad{[h,d,d',g]} such that + ++algSplitSimple(f, D) returns \spad{[h,d,d',g]} such that ++ \spad{f=h/d}, ++ \spad{h} is integral at all the normal places w.r.t. \spad{D}, ++ \spad{d' = Dd}, \spad{g = gcd(d, discriminant())} and \spad{D} ++ is the derivation to use. \spad{f} must have at most simple finite ++ poles. + if F has Field then + nonSingularModel: SY -> List Polynomial F - ++ nonSingularModel(u) returns the equations in u1,...,un of + ++nonSingularModel(u) returns the equations in u1,...,un of ++ an affine non-singular model for the curve. + if F has Finite then + rationalPoints: () -> List List F - ++ rationalPoints() returns the list of all the affine + ++rationalPoints() returns the list of all the affine ++rational points. add import InnerCommonDenominator(UP, RF, Vector UP, Vector RF) diff --git a/books/ps/v104matrixmanipulation.eps b/books/ps/v104matrixmanipulation.eps new file mode 100644 index 0000000..d9c73c4 --- /dev/null +++ b/books/ps/v104matrixmanipulation.eps @@ -0,0 +1,278 @@ +%!PS-Adobe-3.0 EPSF-3.0 +%%Creator: graphviz version 2.26.3 (20100126.1600) +%%Title: pic +%%Pages: 1 +%%BoundingBox: 36 36 118 152 +%%EndComments +save +%%BeginProlog +/DotDict 200 dict def +DotDict begin + +/setupLatin1 { +mark +/EncodingVector 256 array def + EncodingVector 0 + +ISOLatin1Encoding 0 255 getinterval putinterval +EncodingVector 45 /hyphen put + +% Set up ISO Latin 1 character encoding +/starnetISO { + dup dup findfont dup length dict begin + { 1 index /FID ne { def }{ pop pop } ifelse + } forall + /Encoding EncodingVector def + currentdict end definefont +} def +/Times-Roman starnetISO def +/Times-Italic starnetISO def +/Times-Bold starnetISO def +/Times-BoldItalic starnetISO def +/Helvetica starnetISO def +/Helvetica-Oblique starnetISO def +/Helvetica-Bold starnetISO def +/Helvetica-BoldOblique starnetISO def +/Courier starnetISO def +/Courier-Oblique starnetISO def +/Courier-Bold starnetISO def +/Courier-BoldOblique starnetISO def +cleartomark +} bind def + +%%BeginResource: procset graphviz 0 0 +/coord-font-family /Times-Roman def +/default-font-family /Times-Roman def +/coordfont coord-font-family findfont 8 scalefont def + +/InvScaleFactor 1.0 def +/set_scale { + dup 1 exch div /InvScaleFactor exch def + scale +} bind def + +% styles +/solid { [] 0 setdash } bind def +/dashed { [9 InvScaleFactor mul dup ] 0 setdash } bind def +/dotted { [1 InvScaleFactor mul 6 InvScaleFactor mul] 0 setdash } bind def +/invis {/fill {newpath} def /stroke {newpath} def /show {pop newpath} def} bind def +/bold { 2 setlinewidth } bind def +/filled { } bind def +/unfilled { } bind def +/rounded { } bind def +/diagonals { } bind def + +% hooks for setting color +/nodecolor { sethsbcolor } bind def +/edgecolor { sethsbcolor } bind def +/graphcolor { sethsbcolor } bind def +/nopcolor {pop pop pop} bind def + +/beginpage { % i j npages + /npages exch def + /j exch def + /i exch def + /str 10 string def + npages 1 gt { + gsave + coordfont setfont + 0 0 moveto + (\() show i str cvs show (,) show j str cvs show (\)) show + grestore + } if +} bind def + +/set_font { + findfont exch + scalefont setfont +} def + +% draw text fitted to its expected width +/alignedtext { % width text + /text exch def + /width exch def + gsave + width 0 gt { + [] 0 setdash + text stringwidth pop width exch sub text length div 0 text ashow + } if + grestore +} def + +/boxprim { % xcorner ycorner xsize ysize + 4 2 roll + moveto + 2 copy + exch 0 rlineto + 0 exch rlineto + pop neg 0 rlineto + closepath +} bind def + +/ellipse_path { + /ry exch def + /rx exch def + /y exch def + /x exch def + matrix currentmatrix + newpath + x y translate + rx ry scale + 0 0 1 0 360 arc + setmatrix +} bind def + +/endpage { showpage } bind def +/showpage { } def + +/layercolorseq + [ % layer color sequence - darkest to lightest + [0 0 0] + [.2 .8 .8] + [.4 .8 .8] + [.6 .8 .8] + [.8 .8 .8] + ] +def + +/layerlen layercolorseq length def + +/setlayer {/maxlayer exch def /curlayer exch def + layercolorseq curlayer 1 sub layerlen mod get + aload pop sethsbcolor + /nodecolor {nopcolor} def + /edgecolor {nopcolor} def + /graphcolor {nopcolor} def +} bind def + +/onlayer { curlayer ne {invis} if } def + +/onlayers { + /myupper exch def + /mylower exch def + curlayer mylower lt + curlayer myupper gt + or + {invis} if +} def + +/curlayer 0 def + +%%EndResource +%%EndProlog +%%BeginSetup +14 default-font-family set_font +1 setmiterlimit +% /arrowlength 10 def +% /arrowwidth 5 def + +% make sure pdfmark is harmless for PS-interpreters other than Distiller +/pdfmark where {pop} {userdict /pdfmark /cleartomark load put} ifelse +% make '<<' and '>>' safe on PS Level 1 devices +/languagelevel where {pop languagelevel}{1} ifelse +2 lt { + userdict (<<) cvn ([) cvn load put + userdict (>>) cvn ([) cvn load put +} if + +%%EndSetup +setupLatin1 +%%Page: 1 1 +%%PageBoundingBox: 36 36 118 152 +%%PageOrientation: Portrait +0 0 1 beginpage +gsave +36 36 82 116 boxprim clip newpath +1 1 set_scale 0 rotate 40 41 translate +0.16355 0.45339 0.92549 graphcolor +newpath -4 -5 moveto +-4 112 lineto +79 112 lineto +79 -5 lineto +closepath fill +1 setlinewidth +0.16355 0.45339 0.92549 graphcolor +newpath -4 -5 moveto +-4 112 lineto +79 112 lineto +79 -5 lineto +closepath stroke +% MAMA +gsave +[ /Rect [ 7 72 67 108 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.4.pdf#nameddest=MAMA) >> + /Subtype /Link +/ANN pdfmark +0.93939 0.73333 1 nodecolor +newpath 67 108 moveto +7 108 lineto +7 72 lineto +67 72 lineto +closepath fill +1 setlinewidth +filled +0.93939 0.73333 1 nodecolor +newpath 67 108 moveto +7 108 lineto +7 72 lineto +67 72 lineto +closepath stroke +0 0 0 nodecolor +14 /Times-Roman set_font +15 86.4 moveto 44 (MAMA) alignedtext +grestore +% MATCAT +gsave +[ /Rect [ 0 0 74 36 ] + /Border [ 0 0 0 ] + /Action << /Subtype /URI /URI (bookvol10.2.pdf#nameddest=MATCAT) >> + /Subtype /Link +/ANN pdfmark +0.60606 0.73333 1 nodecolor +newpath 74 36 moveto +0 36 lineto +0 0 lineto +74 0 lineto +closepath fill +1 setlinewidth +filled +0.60606 0.73333 1 nodecolor +newpath 74 36 moveto +0 36 lineto +0 0 lineto +74 0 lineto +closepath stroke +0 0 0 nodecolor +14 /Times-Roman set_font +8 14.4 moveto 58 (MATCAT) alignedtext +grestore +% MAMA->MATCAT +gsave +1 setlinewidth +0 0 0 edgecolor +newpath 37 71.83 moveto +37 64.13 37 54.97 37 46.42 curveto +stroke +0 0 0 edgecolor +newpath 40.5 46.41 moveto +37 36.41 lineto +33.5 46.41 lineto +closepath fill +1 setlinewidth +solid +0 0 0 edgecolor +newpath 40.5 46.41 moveto +37 36.41 lineto +33.5 46.41 lineto +closepath stroke +grestore +endpage +showpage +grestore +%%PageTrailer +%%EndPage: 1 +%%Trailer +end +restore +%%EOF diff --git a/buglist b/buglist index b2ecb84..96ebf10 100644 --- a/buglist +++ b/buglist @@ -5,12 +5,19 @@ todo 330: wish 1011: meh 5: errors 10016: -warnings 20572: +warnings 20573: macros 30234: typos 40363: dup 50006: nonextend 60077: +========================================================================= +warnings 20572: + +>compiling SGROUP.spad to SGROUP.nrlib + +--->-->SemiGroup&(constructor): Missing left brace +"the class of all multiplicative semigroups, that is, a set with an associative operation \\spadop{*}. \\blankline Axioms\\br \\tab{5}\\spad{associative(\"*\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ (x*y)*z = x*(y*z)} \\blankline Conditional attributes\\br \\tab{5}\\spad{commutative(\"*\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ x*y = \\spad{y*x} }" ========================================================================= bug 7236: @@ -965,15 +972,6 @@ typos 40348: ========================================================================= -typos 40345: - ->compiling REAL.spad to REAL.nrlib - ---->bookvol10.2.pamphlet-->RealConstant(constructor): Missing left brace -"The category of real numeric domains, \\spadignore{i.e.} convertible to floats." - - -========================================================================= typos 40344: >compiling RMODULE.spad to RMODULE.nrlib @@ -990,61 +988,6 @@ typos 40343: ========================================================================= -typos 40342: - ->compiling SGROUP.spad to SGROUP.nrlib - ---->-->SemiGroup&((** (% % (PositiveInteger)))): Missing left brace -"\\spad{x**n} returns the repeated product of \\spad{x} \\spad{n} times, \\spadignore{i.e.} exponentiation." - ---->-->SemiGroup&((^ (% % (PositiveInteger)))): Missing left brace -"\\spad{x^n} returns the repeated product of \\spad{x} \\spad{n} times, \\spadignore{i.e.} exponentiation." - ---->-->SemiGroup&(constructor): Missing left brace ---->-->SemiGroup&(constructor): Missing left brace -"the class of all multiplicative semigroups, \\spadignore{i.e.} a set with an associative operation \\spadop{*}. \\blankline Axioms\\br \\tab{5}\\spad{associative(\"*\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ (x*y)*z = x*(y*z)} \\blankline Conditional attributes\\br \\tab{5}\\spad{commutative(\"*\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ x*y = \\spad{y*x} }" - ---->bookvol10.2.pamphlet-->SemiGroup((** (% % (PositiveInteger)))): Missing left brace -"\\spad{x**n} returns the repeated product of \\spad{x} \\spad{n} times, \\spadignore{i.e.} exponentiation." - ---->bookvol10.2.pamphlet-->SemiGroup((^ (% % (PositiveInteger)))): Missing left brace -"\\spad{x^n} returns the repeated product of \\spad{x} \\spad{n} times, \\spadignore{i.e.} exponentiation." - ---->bookvol10.2.pamphlet-->SemiGroup(constructor): Missing left brace ---->bookvol10.2.pamphlet-->SemiGroup(constructor): Missing left brace -"the class of all multiplicative semigroups, \\spadignore{i.e.} a set with an associative operation \\spadop{*}. \\blankline Axioms\\br \\tab{5}\\spad{associative(\"*\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ (x*y)*z = x*(y*z)} \\blankline Conditional attributes\\br \\tab{5}\\spad{commutative(\"*\":(\\%,\\%)->\\%)}\\tab{5}\\spad{ x*y = \\spad{y*x} }" - - -========================================================================= -typos 40341: - ->compiling SPACEC.spad to SPACEC.nrlib - ---->bookvol10.2.pamphlet-->ThreeSpaceCategory((curve ((L POINT) %))): Missing left brace -"\\spad{curve(s)} checks to see if the \\spadtype{ThreeSpace}, \\spad{s,} is composed of a single curve defined by a list of points and if so, returns the curve, \\spadignore{i.e.} list of points. An error is signaled otherwise." - ---->bookvol10.2.pamphlet-->ThreeSpaceCategory((curve? (B %))): Missing left brace -"\\spad{curve?(s)} queries whether the \\spadtype{ThreeSpace}, \\spad{s,} is a curve, \\spadignore{i.e.} has one component, a list of list of points, and returns \\spad{true} if it is, or \\spad{false} otherwise." - ---->bookvol10.2.pamphlet-->ThreeSpaceCategory((closedCurve? (B %))): Missing left brace -"\\spad{closedCurve?(s)} returns \\spad{true} if the \\spadtype{ThreeSpace} \\spad{s} contains a single closed curve component, \\spadignore{i.e.} the first element of the curve is also the last element, or \\spad{false} otherwise." - ---->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L (L R))) (L PROP) PROP))): Missing close parenthesis on first line: mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] ], -"mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] \\spad{],} \\indented{7}{[props], prop)} adds a surface component to the \\spadtype{ThreeSpace} \\spad{s,} which is defined over a rectangular domain of size \\spad{WxH} where \\spad{W} is the number of lists of points from the domain \\spad{PointDomain(R)} and \\spad{H} is the number of elements in each of those lists; lprops is the list of the subspace component properties for each curve list, and prop is the subspace component property by which the points are defined." - ---->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L POINT)) B B))): Missing left brace ---->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L POINT)) B B))): Missing left brace -"\\spad{mesh(s,[[p0],[p1],...,[pn]], close1, close2)} adds a surface component to the \\spadtype{ThreeSpace}, which is defined over a list of curves, in which each of these curves is a list of points. The boolean arguments \\spad{close1} and \\spad{close2} indicate how the surface is to be closed. Argument \\spad{close1} equal \\spad{true} means that each individual list (a curve) is to be closed, \\spadignore{i.e.} the last point of the list is to be connected to the first point. Argument \\spad{close2} equal \\spad{true} means that the boundary at one end of the surface is to be connected to the boundary at the other end, \\spadignore{i.e.} the boundaries are defined as the first list of points (curve) and the last list of points (curve)." - ---->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L (L R))) B B))): Missing close parenthesis on first line: mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] ], ---->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L (L R))) B B))): Mismatch: left pren matches right brace -"mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] \\spad{],} \\indented{5}{close1, close2)} adds a surface component to the \\spadtype{ThreeSpace} \\spad{s,} which is defined over a rectangular domain of size \\spad{WxH} where \\spad{W} is the number of lists of points from the domain \\spad{PointDomain(R)} and \\spad{H} is the number of elements in each of those lists; the booleans \\spad{close1} and \\spad{close2} indicate how the surface is to be closed: if \\spad{close1} is \\spad{true} this means that each individual list (a curve) is to be closed (\\spadignore{i.e.} the last point of the list is to be connected to the first point); if \\spad{close2} is true, this means that the boundary at one end of the surface is to be connected to the boundary at the other end (the boundaries are defined as the first list of points (curve) and the last list of points (curve))." - ---->bookvol10.2.pamphlet-->ThreeSpaceCategory((lp ((L POINT) %))): Missing left brace -"\\spad{lp(s)} returns the list of points component which the \\spadtype{ThreeSpace}, \\spad{s,} contains; these points are used by reference, \\spadignore{i.e.} the component holds indices referring to the points rather than the points themselves. This allows for sharing of the points." - - -========================================================================= typos 40340: @@ -1711,17 +1654,6 @@ typos 40299: ========================================================================= -typos 40296: - ->compiling FPC.spad to FPC.nrlib - ---->-->FieldOfPrimeCharacteristic&(constructor): Missing left brace -"FieldOfPrimeCharacteristic is the category of fields of prime characteristic, \\spadignore{e.g.} finite fields, algebraic closures of fields of prime characteristic, transcendental extensions of of fields of prime characteristic." - ---->bookvol10.2.pamphlet-->FieldOfPrimeCharacteristic(constructor): Missing left brace -"FieldOfPrimeCharacteristic is the category of fields of prime characteristic, \\spadignore{e.g.} finite fields, algebraic closures of fields of prime characteristic, transcendental extensions of of fields of prime characteristic." - -========================================================================= typos 40295: >compiling FMONOID.spad to FMONOID.nrlib @@ -1772,77 +1704,6 @@ typos 40293: "\\spad{reverse(l)} reverses the list of monomials forming \\spad{l.} This has some effect if the monoid is non-abelian, \\spadignore{i.e.} \\spad{reverse(a1\\^e1 \\spad{...} an\\^en) = an\\^en \\spad{...} a1\\^e1} which is different." ========================================================================= -typos 40292: - ->compiling LZSTAGG.spad to LZSTAGG.nrlib - ---->-->LazyStreamAggregate&((remove (% (Mapping (Boolean) S) %))): Improper first word in comments: -"\\indented{1}{remove(f,st) returns a stream consisting of those elements of stream} \\indented{1}{st which do not satisfy the predicate \\spad{f.}} \\indented{1}{Note that \\spad{remove(f,st) = \\spad{[x} for \\spad{x} in st | not f(x)]}.} \\blankline \\spad{X} m:=[i for \\spad{i} in 1..] \\spad{X} f(i:PositiveInteger):Boolean \\spad{==} even? \\spad{i} \\spad{X} remove(f,m)" - ---->-->LazyStreamAggregate&((select (% (Mapping (Boolean) S) %))): Improper first word in comments: -"\\indented{1}{select(f,st) returns a stream consisting of those elements of stream} \\indented{1}{st satisfying the predicate \\spad{f.}} \\indented{1}{Note that \\spad{select(f,st) = \\spad{[x} for \\spad{x} in st | f(x)]}.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} select(x+->prime? x,m)" - ---->-->LazyStreamAggregate&((explicitEntries? ((Boolean) %))): Improper first word in comments: -"\\indented{1}{explicitEntries?(s) returns \\spad{true} if the stream \\spad{s} has} \\indented{1}{explicitly computed entries, and \\spad{false} otherwise.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} explicitEntries? \\spad{m}" - ---->-->LazyStreamAggregate&((explicitlyEmpty? ((Boolean) %))): Improper first word in comments: -"\\indented{1}{explicitlyEmpty?(s) returns \\spad{true} if the stream is an} \\indented{1}{(explicitly) empty stream.} \\indented{1}{Note that this is a null test which will not cause lazy evaluation.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} explicitlyEmpty? \\spad{m}" - ---->-->LazyStreamAggregate&((lazy? ((Boolean) %))): Improper first word in comments: -"\\indented{1}{lazy?(s) returns \\spad{true} if the first node of the stream \\spad{s}} \\indented{1}{is a lazy evaluation mechanism which could produce an} \\indented{1}{additional entry to \\spad{s.}} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} lazy? \\spad{m}" - ---->-->LazyStreamAggregate&((frst (S %))): Improper first word in comments: -"\\indented{1}{frst(s) returns the first element of stream \\spad{s.}} \\indented{1}{Caution: this function should only be called after a \\spad{empty?}} \\indented{1}{test has been made since there no error check.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} frst \\spad{m}" - ---->-->LazyStreamAggregate&((rst (% %))): Improper first word in comments: -"\\indented{1}{rst(s) returns a pointer to the next node of stream \\spad{s.}} \\indented{1}{Caution: this function should only be called after a \\spad{empty?}} \\indented{1}{test has been made since there no error check.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} \\spad{rst} \\spad{m}" - ---->-->LazyStreamAggregate&((numberOfComputedEntries ((NonNegativeInteger) %))): Improper first word in comments: -"\\indented{1}{numberOfComputedEntries(st) returns the number of explicitly} \\indented{1}{computed entries of stream st which exist immediately prior to the} \\indented{1}{time this function is called.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} numberOfComputedEntries \\spad{m}" - ---->-->LazyStreamAggregate&((extend (% % (Integer)))): Improper first word in comments: -"\\indented{1}{extend(st,n) causes entries to be computed, if necessary,} \\indented{1}{so that 'st' will have at least \\spad{'n'} explicit entries or so} \\indented{1}{that all entries of 'st' will be computed if 'st' is finite} \\indented{1}{with length \\spad{<=} \\spad{n.}} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} numberOfComputedEntries \\spad{m} \\spad{X} extend(m,20) \\spad{X} numberOfComputedEntries \\spad{m}" - ---->-->LazyStreamAggregate&((complete (% %))): Improper first word in comments: -"\\indented{1}{complete(st) causes all entries of 'st' to be computed.} \\indented{1}{this function should only be called on streams which are} \\indented{1}{known to be finite.} \\blankline \\spad{X} m:=[i for \\spad{i} in 1..] \\spad{X} n:=filterUntil(i+->i>100,m) \\spad{X} numberOfComputedEntries \\spad{n} \\spad{X} complete \\spad{n} \\spad{X} numberOfComputedEntries \\spad{n}" - ---->-->LazyStreamAggregate&(constructor): Missing left brace -"LazyStreamAggregate is the category of streams with lazy evaluation. It is understood that the function 'empty?' will cause lazy evaluation if necessary to determine if there are entries. Functions which call 'empty?', \\spadignore{e.g.} 'first' and 'rest', will also cause lazy evaluation if necessary." - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((remove (% (Mapping (Boolean) S) %))): Improper first word in comments: -"\\indented{1}{remove(f,st) returns a stream consisting of those elements of stream} \\indented{1}{st which do not satisfy the predicate \\spad{f.}} \\indented{1}{Note that \\spad{remove(f,st) = \\spad{[x} for \\spad{x} in st | not f(x)]}.} \\blankline \\spad{X} m:=[i for \\spad{i} in 1..] \\spad{X} f(i:PositiveInteger):Boolean \\spad{==} even? \\spad{i} \\spad{X} remove(f,m)" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((select (% (Mapping (Boolean) S) %))): Improper first word in comments: -"\\indented{1}{select(f,st) returns a stream consisting of those elements of stream} \\indented{1}{st satisfying the predicate \\spad{f.}} \\indented{1}{Note that \\spad{select(f,st) = \\spad{[x} for \\spad{x} in st | f(x)]}.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} select(x+->prime? x,m)" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((explicitEntries? ((Boolean) %))): Improper first word in comments: -"\\indented{1}{explicitEntries?(s) returns \\spad{true} if the stream \\spad{s} has} \\indented{1}{explicitly computed entries, and \\spad{false} otherwise.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} explicitEntries? \\spad{m}" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((explicitlyEmpty? ((Boolean) %))): Improper first word in comments: -"\\indented{1}{explicitlyEmpty?(s) returns \\spad{true} if the stream is an} \\indented{1}{(explicitly) empty stream.} \\indented{1}{Note that this is a null test which will not cause lazy evaluation.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} explicitlyEmpty? \\spad{m}" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((lazy? ((Boolean) %))): Improper first word in comments: -"\\indented{1}{lazy?(s) returns \\spad{true} if the first node of the stream \\spad{s}} \\indented{1}{is a lazy evaluation mechanism which could produce an} \\indented{1}{additional entry to \\spad{s.}} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} lazy? \\spad{m}" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((frst (S %))): Improper first word in comments: -"\\indented{1}{frst(s) returns the first element of stream \\spad{s.}} \\indented{1}{Caution: this function should only be called after a \\spad{empty?}} \\indented{1}{test has been made since there no error check.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} frst \\spad{m}" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((rst (% %))): Improper first word in comments: -"\\indented{1}{rst(s) returns a pointer to the next node of stream \\spad{s.}} \\indented{1}{Caution: this function should only be called after a \\spad{empty?}} \\indented{1}{test has been made since there no error check.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} \\spad{rst} \\spad{m}" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((numberOfComputedEntries ((NonNegativeInteger) %))): Improper first word in comments: -"\\indented{1}{numberOfComputedEntries(st) returns the number of explicitly} \\indented{1}{computed entries of stream st which exist immediately prior to the} \\indented{1}{time this function is called.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} numberOfComputedEntries \\spad{m}" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((extend (% % (Integer)))): Improper first word in comments: -"\\indented{1}{extend(st,n) causes entries to be computed, if necessary,} \\indented{1}{so that 'st' will have at least \\spad{'n'} explicit entries or so} \\indented{1}{that all entries of 'st' will be computed if 'st' is finite} \\indented{1}{with length \\spad{<=} \\spad{n.}} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} numberOfComputedEntries \\spad{m} \\spad{X} extend(m,20) \\spad{X} numberOfComputedEntries \\spad{m}" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate((complete (% %))): Improper first word in comments: -"\\indented{1}{complete(st) causes all entries of 'st' to be computed.} \\indented{1}{this function should only be called on streams which are} \\indented{1}{known to be finite.} \\blankline \\spad{X} m:=[i for \\spad{i} in 1..] \\spad{X} n:=filterUntil(i+->i>100,m) \\spad{X} numberOfComputedEntries \\spad{n} \\spad{X} complete \\spad{n} \\spad{X} numberOfComputedEntries \\spad{n}" - ---->bookvol10.2.pamphlet-->LazyStreamAggregate(constructor): Missing left brace -"LazyStreamAggregate is the category of streams with lazy evaluation. It is understood that the function 'empty?' will cause lazy evaluation if necessary to determine if there are entries. Functions which call 'empty?', \\spadignore{e.g.} 'first' and 'rest', will also cause lazy evaluation if necessary." - -========================================================================= typos 40291: >compiling MAGMA.spad to MAGMA.nrlib @@ -2101,316 +1962,6 @@ typos 40275: "\\indented{1}{shrinkable(b) sets the shrinkable attribute of flexible arrays to \\spad{b}} \\indented{1}{and returns the previous value} \\blankline \\spad{X} T1:=IndexedFlexibleArray(Integer,20) \\spad{X} \\spad{shrinkable(false)$T1}" ========================================================================= -typos 40274: - ->compiling LFCAT.spad to LFCAT.nrlib - ---->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((Ei ($ $))): Missing left brace -"\\spad{Ei(x)} returns the exponential integral of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{exp(x)/x dx}." - ---->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((Si ($ $))): Missing left brace -"\\spad{Si(x)} returns the sine integral of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{sin(x) / \\spad{x} dx}." - ---->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((Ci ($ $))): Missing left brace -"\\spad{Ci(x)} returns the cosine integral of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{cos(x) / \\spad{x} dx}." - ---->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((li ($ $))): Missing left brace -"\\spad{li(x)} returns the logarithmic integral of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{dx / log(x)}." - ---->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((dilog ($ $))): Missing left brace -"\\spad{dilog(x)} returns the dilogarithm of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{log(x) / \\spad{(1} - \\spad{x)} dx}." - ---->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((erf ($ $))): Missing left brace -"\\spad{erf(x)} returns the error function of \\spad{x,} \\spadignore{i.e.} \\spad{2 / sqrt(\\%pi)} times the integral of \\spad{exp(-x**2) dx}." - ---->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((fresnelS ($ $))): Improper initial operator in comments: is -"fresnelS is the Fresnel integral \\spad{S,} defined by S(x) = integrate(sin(t^2),t=0..x)" - ---->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((fresnelC ($ $))): Improper initial operator in comments: is -"fresnelC is the Fresnel integral \\spad{C,} defined by C(x) = integrate(cos(t^2),t=0..x)" - -========================================================================= -typos 40273: - ->compiling MATCAT.spad to MATCAT.nrlib - ---->-->MatrixCategory&((square? ((Boolean) %))): Improper first word in comments: -"\\indented{1}{\\spad{square?(m)} returns \\spad{true} if \\spad{m} is a square matrix} \\indented{1}{(if \\spad{m} has the same number of rows as columns) and \\spad{false} otherwise.} \\blankline \\spad{X} square matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->-->MatrixCategory&((diagonal? ((Boolean) %))): Improper first word in comments: ---->-->MatrixCategory&((diagonal? ((Boolean) %))): Mismatch: left pren matches right brace -"\\indented{1}{\\spad{diagonal?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{diagonal (\\spadignore{i.e.} all entries of \\spad{m} not on the diagonal are zero) and} \\indented{1}{false otherwise.} \\blankline \\spad{X} diagonal? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->-->MatrixCategory&((symmetric? ((Boolean) %))): Improper first word in comments: ---->-->MatrixCategory&((symmetric? ((Boolean) %))): Mismatch: left pren matches right brace -"\\indented{1}{\\spad{symmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{symmetric (\\spadignore{i.e.} \\spad{m[i,j] = m[j,i]} for all \\spad{i} and \\spad{j)} and false} \\indented{1}{otherwise.} \\blankline \\spad{X} symmetric? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->-->MatrixCategory&((antisymmetric? ((Boolean) %))): Improper first word in comments: ---->-->MatrixCategory&((antisymmetric? ((Boolean) %))): Mismatch: left pren matches right brace -"\\indented{1}{\\spad{antisymmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{antisymmetric (\\spadignore{i.e.} \\spad{m[i,j] = -m[j,i]} for all \\spad{i} and \\spad{j)}} \\indented{1}{and \\spad{false} otherwise.} \\blankline \\spad{X} antisymmetric? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->-->MatrixCategory&((zero (% (NonNegativeInteger) (NonNegativeInteger)))): Improper first word in comments: -"\\indented{1}{\\spad{zero(m,n)} returns an m-by-n zero matrix.} \\blankline \\spad{X} z:Matrix(INT):=zero(3,3)" - ---->-->MatrixCategory&((matrix (% (List (List R))))): Improper first word in comments: -"\\indented{1}{\\spad{matrix(l)} converts the list of lists \\spad{l} to a matrix, where the} \\indented{1}{list of lists is viewed as a list of the rows of the matrix.} \\blankline \\spad{X} matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]]" ---------(matrix (% (NonNegativeInteger) (NonNegativeInteger) (Mapping R (Integer) (Integer))))--------- ---->-->MatrixCategory&((matrix (% (NonNegativeInteger) (NonNegativeInteger) (Mapping R (Integer) (Integer))))): Improper first word in comments: -"\\indented{1}{\\spad{matrix(n,m,f)} constructs an \\spad{n * \\spad{m}} matrix with} \\indented{1}{the \\spad{(i,j)} entry equal to \\spad{f(i,j)}} \\blankline \\spad{X} f(i:INT,j:INT):INT \\spad{==} i+j \\spad{X} matrix(3,4,f)" - ---->-->MatrixCategory&((scalarMatrix (% (NonNegativeInteger) R))): Improper first word in comments: -"\\indented{1}{\\spad{scalarMatrix(n,r)} returns an n-by-n matrix with \\spad{r's} on the} \\indented{1}{diagonal and zeroes elsewhere.} \\blankline \\spad{X} z:Matrix(INT):=scalarMatrix(3,5)" - ---->-->MatrixCategory&((diagonalMatrix (% (List R)))): Improper first word in comments: -"\\indented{1}{\\spad{diagonalMatrix(l)} returns a diagonal matrix with the elements} \\indented{1}{of \\spad{l} on the diagonal.} \\blankline \\spad{X} diagonalMatrix [1,2,3]" - ---->-->MatrixCategory&((diagonalMatrix (% (List %)))): Improper first word in comments: -"\\indented{1}{\\spad{diagonalMatrix([m1,...,mk])} creates a block diagonal matrix} \\indented{1}{M with block matrices m1,...,mk down the diagonal,} \\indented{1}{with 0 block matrices elsewhere.} \\indented{1}{More precisly: if \\spad{ri \\spad{:=} nrows mi}, \\spad{ci \\spad{:=} ncols mi},} \\indented{1}{then \\spad{m} is an (r1+..+rk) by (c1+..+ck) - matrix\\space{2}with entries} \\indented{1}{\\spad{m.i.j = ml.(i-r1-..-r(l-1)).(j-n1-..-n(l-1))}, if} \\indented{1}{\\spad{(r1+..+r(l-1)) < \\spad{i} \\spad{<=} r1+..+rl} and} \\indented{1}{\\spad{(c1+..+c(l-1)) < \\spad{i} \\spad{<=} c1+..+cl},} \\indented{1}{\\spad{m.i.j} = 0\\space{2}otherwise.} \\blankline \\spad{X} diagonalMatrix [matrix [[1,2],[3,4]], matrix [[4,5],[6,7]]]" - ---->-->MatrixCategory&((coerce (% Col))): Improper first word in comments: -"\\indented{1}{\\spad{coerce(col)} converts the column col to a column matrix.} \\blankline \\spad{X} coerce([1,2,3])@Matrix(INT)" - ---->-->MatrixCategory&((transpose (% Row))): Improper first word in comments: -"\\indented{1}{\\spad{transpose(r)} converts the row \\spad{r} to a row matrix.} \\blankline \\spad{X} transpose([1,2,3])@Matrix(INT)" - ---->-->MatrixCategory&((transpose (% %))): Improper first word in comments: -"\\indented{1}{\\spad{transpose(m)} returns the transpose of the matrix \\spad{m.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} transpose \\spad{m}" - ---->-->MatrixCategory&((squareTop (% %))): Improper first word in comments: -"\\indented{1}{\\spad{squareTop(m)} returns an n-by-n matrix consisting of the first} \\indented{1}{n rows of the m-by-n matrix \\spad{m.} Error: if} \\indented{1}{\\spad{m < n}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..2] for \\spad{j} in 1..5] \\spad{X} squareTop \\spad{m}" - ---->-->MatrixCategory&((horizConcat (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{horizConcat(x,y)} horizontally concatenates two matrices with} \\indented{1}{an equal number of rows. The entries of \\spad{y} appear to the right} \\indented{1}{of the entries of x.\\space{2}Error: if the matrices} \\indented{1}{do not have the same number of rows.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} horizConcat(m,m)" - ---->-->MatrixCategory&((vertConcat (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{vertConcat(x,y)} vertically concatenates two matrices with an} \\indented{1}{equal number of columns. The entries of \\spad{y} appear below} \\indented{1}{of the entries of x.\\space{2}Error: if the matrices} \\indented{1}{do not have the same number of columns.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} vertConcat(m,m)" - ---->-->MatrixCategory&((listOfLists ((List (List R)) %))): Improper first word in comments: -"\\indented{1}{\\spad{listOfLists(m)} returns the rows of the matrix \\spad{m} as a list} \\indented{1}{of lists.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} listOfLists \\spad{m}" - ---->-->MatrixCategory&((elt (% % (List (Integer)) (List (Integer))))): Improper first word in comments: -"\\indented{1}{\\spad{elt(x,rowList,colList)} returns an m-by-n matrix consisting} \\indented{1}{of elements of \\spad{x,} where \\spad{m = \\# rowList} and \\spad{n = \\# colList}} \\indented{1}{If \\spad{rowList = [i<1>,i<2>,...,i]} and \\spad{colList \\spad{=}} \\indented{1}{[j<1>,j<2>,...,j]}, then the \\spad{(k,l)}th entry of} \\indented{1}{\\spad{elt(x,rowList,colList)} is \\spad{x(i,j)}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} elt(m,3,3)" - ---->-->MatrixCategory&((setelt (% % (List (Integer)) (List (Integer)) %))): Improper first word in comments: -"\\indented{1}{\\spad{setelt(x,rowList,colList,y)} destructively alters the matrix \\spad{x.}} \\indented{1}{If \\spad{y} is \\spad{m}-by-\\spad{n}, \\spad{rowList = [i<1>,i<2>,...,i]}} \\indented{1}{and \\spad{colList = [j<1>,j<2>,...,j]}, then \\spad{x(i,j)}} \\indented{1}{is set to \\spad{y(k,l)} for \\spad{k = 1,...,m} and \\spad{l = 1,...,n}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} setelt(m,3,3,10)" - ---->-->MatrixCategory&((swapRows! (% % (Integer) (Integer)))): Improper first word in comments: -"\\indented{1}{\\spad{swapRows!(m,i,j)} interchanges the \\spad{i}th and \\spad{j}th} \\indented{1}{rows of \\spad{m.} This destructively alters the matrix.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} swapRows!(m,2,4)" - ---->-->MatrixCategory&((swapColumns! (% % (Integer) (Integer)))): Improper first word in comments: -"\\indented{1}{\\spad{swapColumns!(m,i,j)} interchanges the \\spad{i}th and \\spad{j}th} \\indented{1}{columns of \\spad{m.} This destructively alters the matrix.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} swapColumns!(m,2,4)" - ---->-->MatrixCategory&((subMatrix (% % (Integer) (Integer) (Integer) (Integer)))): Improper first word in comments: -"\\indented{1}{\\spad{subMatrix(x,i1,i2,j1,j2)} extracts the submatrix} \\indented{1}{\\spad{[x(i,j)]} where the index \\spad{i} ranges from \\spad{i1} to \\spad{i2}} \\indented{1}{and the index \\spad{j} ranges from \\spad{j1} to \\spad{j2}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} subMatrix(m,1,3,2,4)" - ---->-->MatrixCategory&((setsubMatrix! (% % (Integer) (Integer) %))): Improper first word in comments: -"\\indented{1}{\\spad{setsubMatrix(x,i1,j1,y)} destructively alters the} \\indented{1}{matrix \\spad{x.} Here \\spad{x(i,j)} is set to \\spad{y(i-i1+1,j-j1+1)} for} \\indented{1}{\\spad{i = i1,...,i1-1+nrows \\spad{y}} and \\spad{j = j1,...,j1-1+ncols y}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} setsubMatrix!(m,2,2,matrix [[3,3],[3,3]])" - ---->-->MatrixCategory&((+ (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{x + \\spad{y}} is the sum of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m+m}" - ---->-->MatrixCategory&((- (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{x - \\spad{y}} is the difference of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m-m}" - ---->-->MatrixCategory&((- (% %))): Improper first word in comments: -"\\indented{1}{\\spad{-x} returns the negative of the matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{-m}" - ---->-->MatrixCategory&((* (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{x * \\spad{y}} is the product of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m*m}" - ---->-->MatrixCategory&((* (% R %))): Improper first word in comments: -"\\indented{1}{\\spad{r*x} is the left scalar multiple of the scalar \\spad{r} and the} \\indented{1}{matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} 1/3*m" - ---->-->MatrixCategory&((* (% % R))): Improper first word in comments: -"\\indented{1}{\\spad{x * \\spad{r}} is the right scalar multiple of the scalar \\spad{r} and the} \\indented{1}{matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m*1/3}" - ---->-->MatrixCategory&((* (% (Integer) %))): Improper first word in comments: -"\\indented{1}{\\spad{n * \\spad{x}} is an integer multiple.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} 3*m" - ---->-->MatrixCategory&((* (Col % Col))): Improper first word in comments: -"\\indented{1}{\\spad{x * \\spad{c}} is the product of the matrix \\spad{x} and the column vector \\spad{c.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} c:=coerce([1,2,3,4,5])@Matrix(INT) \\spad{X} \\spad{m*c}" - ---->-->MatrixCategory&((* (Row Row %))): Improper first word in comments: -"\\indented{1}{\\spad{r * \\spad{x}} is the product of the row vector \\spad{r} and the matrix \\spad{x.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} r:=transpose([1,2,3,4,5])@Matrix(INT) \\spad{X} \\spad{r*m}" - ---->-->MatrixCategory&((** (% % (NonNegativeInteger)))): Improper first word in comments: -"\\indented{1}{\\spad{x \\spad{**} \\spad{n}} computes a non-negative integral power of the matrix \\spad{x.}} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m**3}" - ---->-->MatrixCategory&((exquo ((Union % failed) % R))): Improper first word in comments: -"\\indented{1}{\\spad{exquo(m,r)} computes the exact quotient of the elements} \\indented{1}{of \\spad{m} by \\spad{r,} returning \\axiom{\"failed\"} if this is not possible.} \\blankline \\spad{X} m:=matrix [[2**i for \\spad{i} in 2..4] for \\spad{j} in 1..5] \\spad{X} exquo(m,2)" - ---->-->MatrixCategory&((/ (% % R))): Improper first word in comments: -"\\indented{1}{\\spad{m/r} divides the elements of \\spad{m} by \\spad{r.} Error: if \\spad{r = 0}.} \\blankline \\spad{X} m:=matrix [[2**i for \\spad{i} in 2..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m/4}" - ---->-->MatrixCategory&((rowEchelon (% %))): Improper first word in comments: -"\\indented{1}{\\spad{rowEchelon(m)} returns the row echelon form of the matrix \\spad{m.}} \\blankline \\spad{X} rowEchelon matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->-->MatrixCategory&((columnSpace ((List Col) %))): Improper first word in comments: -"\\indented{1}{\\spad{columnSpace(m)} returns a sublist of columns of the matrix \\spad{m}} \\indented{1}{forming a basis of its column space} \\blankline \\spad{X} columnSpace matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]]" - ---->-->MatrixCategory&((rank ((NonNegativeInteger) %))): Improper first word in comments: -"\\indented{1}{\\spad{rank(m)} returns the rank of the matrix \\spad{m.}} \\blankline \\spad{X} rank matrix [[1,2,3],[4,5,6],[7,8,9]]" - ---->-->MatrixCategory&((nullity ((NonNegativeInteger) %))): Improper first word in comments: -"\\indented{1}{\\spad{nullity(m)} returns the nullity of the matrix \\spad{m.} This is} \\indented{1}{the dimension of the null space of the matrix \\spad{m.}} \\blankline \\spad{X} nullity matrix [[1,2,3],[4,5,6],[7,8,9]]" - ---->-->MatrixCategory&((nullSpace ((List Col) %))): Improper first word in comments: -"\\indented{1}{\\spad{nullSpace(m)} returns a basis for the null space of} \\indented{1}{the matrix \\spad{m.}} \\blankline \\spad{X} nullSpace matrix [[1,2,3],[4,5,6],[7,8,9]]" - ---->-->MatrixCategory&((determinant (R %))): Improper first word in comments: -"\\indented{1}{\\spad{determinant(m)} returns the determinant of the matrix \\spad{m.}} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} determinant matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->-->MatrixCategory&((minordet (R %))): Improper first word in comments: -"\\indented{1}{\\spad{minordet(m)} computes the determinant of the matrix \\spad{m} using} \\indented{1}{minors. Error: if the matrix is not square.} \\blankline \\spad{X} minordet matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->-->MatrixCategory&((pfaffian (R %))): Improper first word in comments: -"\\indented{1}{\\spad{pfaffian(m)} returns the Pfaffian of the matrix \\spad{m.}} \\indented{1}{Error if the matrix is not antisymmetric} \\blankline \\spad{X} pfaffian [[0,1,0,0],[-1,0,0,0],[0,0,0,1],[0,0,-1,0]]" - ---->-->MatrixCategory&((inverse ((Union % failed) %))): Improper first word in comments: -"\\indented{1}{\\spad{inverse(m)} returns the inverse of the matrix \\spad{m.}} \\indented{1}{If the matrix is not invertible, \"failed\" is returned.} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} inverse matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->-->MatrixCategory&((** (% % (Integer)))): Improper first word in comments: -"\\indented{1}{\\spad{m**n} computes an integral power of the matrix \\spad{m.}} \\indented{1}{Error: if matrix is not square or if the matrix} \\indented{1}{is square but not invertible.} \\blankline \\spad{X} (matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]) \\spad{**} 2" - ---->bookvol10.2.pamphlet-->MatrixCategory((square? ((Boolean) %))): Improper first word in comments: -"\\indented{1}{\\spad{square?(m)} returns \\spad{true} if \\spad{m} is a square matrix} \\indented{1}{(if \\spad{m} has the same number of rows as columns) and \\spad{false} otherwise.} \\blankline \\spad{X} square matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->bookvol10.2.pamphlet-->MatrixCategory((diagonal? ((Boolean) %))): Improper first word in comments: ---->bookvol10.2.pamphlet-->MatrixCategory((diagonal? ((Boolean) %))): Mismatch: left pren matches right brace -"\\indented{1}{\\spad{diagonal?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{diagonal (\\spadignore{i.e.} all entries of \\spad{m} not on the diagonal are zero) and} \\indented{1}{false otherwise.} \\blankline \\spad{X} diagonal? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->bookvol10.2.pamphlet-->MatrixCategory((symmetric? ((Boolean) %))): Improper first word in comments: ---->bookvol10.2.pamphlet-->MatrixCategory((symmetric? ((Boolean) %))): Mismatch: left pren matches right brace -"\\indented{1}{\\spad{symmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{symmetric (\\spadignore{i.e.} \\spad{m[i,j] = m[j,i]} for all \\spad{i} and \\spad{j)} and false} \\indented{1}{otherwise.} \\blankline \\spad{X} symmetric? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->bookvol10.2.pamphlet-->MatrixCategory((antisymmetric? ((Boolean) %))): Improper first word in comments: ---->bookvol10.2.pamphlet-->MatrixCategory((antisymmetric? ((Boolean) %))): Mismatch: left pren matches right brace -"\\indented{1}{\\spad{antisymmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{antisymmetric (\\spadignore{i.e.} \\spad{m[i,j] = -m[j,i]} for all \\spad{i} and \\spad{j)}} \\indented{1}{and \\spad{false} otherwise.} \\blankline \\spad{X} antisymmetric? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->bookvol10.2.pamphlet-->MatrixCategory((zero (% (NonNegativeInteger) (NonNegativeInteger)))): Improper first word in comments: -"\\indented{1}{\\spad{zero(m,n)} returns an m-by-n zero matrix.} \\blankline \\spad{X} z:Matrix(INT):=zero(3,3)" - ---->bookvol10.2.pamphlet-->MatrixCategory((matrix (% (List (List R))))): Improper first word in comments: -"\\indented{1}{\\spad{matrix(l)} converts the list of lists \\spad{l} to a matrix, where the} \\indented{1}{list of lists is viewed as a list of the rows of the matrix.} \\blankline \\spad{X} matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]]" - ---->bookvol10.2.pamphlet-->MatrixCategory((matrix (% (NonNegativeInteger) (NonNegativeInteger) (Mapping R (Integer) (Integer))))): Improper first word in comments: -"\\indented{1}{\\spad{matrix(n,m,f)} constructs an \\spad{n * \\spad{m}} matrix with} \\indented{1}{the \\spad{(i,j)} entry equal to \\spad{f(i,j)}} \\blankline \\spad{X} f(i:INT,j:INT):INT \\spad{==} i+j \\spad{X} matrix(3,4,f)" - ---->bookvol10.2.pamphlet-->MatrixCategory((scalarMatrix (% (NonNegativeInteger) R))): Improper first word in comments: -"\\indented{1}{\\spad{scalarMatrix(n,r)} returns an n-by-n matrix with \\spad{r's} on the} \\indented{1}{diagonal and zeroes elsewhere.} \\blankline \\spad{X} z:Matrix(INT):=scalarMatrix(3,5)" - ---->bookvol10.2.pamphlet-->MatrixCategory((diagonalMatrix (% (List R)))): Improper first word in comments: -"\\indented{1}{\\spad{diagonalMatrix(l)} returns a diagonal matrix with the elements} \\indented{1}{of \\spad{l} on the diagonal.} \\blankline \\spad{X} diagonalMatrix [1,2,3]" - ---->bookvol10.2.pamphlet-->MatrixCategory((diagonalMatrix (% (List %)))): Improper first word in comments: -"\\indented{1}{\\spad{diagonalMatrix([m1,...,mk])} creates a block diagonal matrix} \\indented{1}{M with block matrices m1,...,mk down the diagonal,} \\indented{1}{with 0 block matrices elsewhere.} \\indented{1}{More precisly: if \\spad{ri \\spad{:=} nrows mi}, \\spad{ci \\spad{:=} ncols mi},} \\indented{1}{then \\spad{m} is an (r1+..+rk) by (c1+..+ck) - matrix\\space{2}with entries} \\indented{1}{\\spad{m.i.j = ml.(i-r1-..-r(l-1)).(j-n1-..-n(l-1))}, if} \\indented{1}{\\spad{(r1+..+r(l-1)) < \\spad{i} \\spad{<=} r1+..+rl} and} \\indented{1}{\\spad{(c1+..+c(l-1)) < \\spad{i} \\spad{<=} c1+..+cl},} \\indented{1}{\\spad{m.i.j} = 0\\space{2}otherwise.} \\blankline \\spad{X} diagonalMatrix [matrix [[1,2],[3,4]], matrix [[4,5],[6,7]]]" - ---->bookvol10.2.pamphlet-->MatrixCategory((coerce (% Col))): Improper first word in comments: -"\\indented{1}{\\spad{coerce(col)} converts the column col to a column matrix.} \\blankline \\spad{X} coerce([1,2,3])@Matrix(INT)" - ---->bookvol10.2.pamphlet-->MatrixCategory((transpose (% Row))): Improper first word in comments: -"\\indented{1}{\\spad{transpose(r)} converts the row \\spad{r} to a row matrix.} \\blankline \\spad{X} transpose([1,2,3])@Matrix(INT)" - ---->bookvol10.2.pamphlet-->MatrixCategory((transpose (% %))): Improper first word in comments: -"\\indented{1}{\\spad{transpose(m)} returns the transpose of the matrix \\spad{m.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} transpose \\spad{m}" - ---->bookvol10.2.pamphlet-->MatrixCategory((squareTop (% %))): Improper first word in comments: -"\\indented{1}{\\spad{squareTop(m)} returns an n-by-n matrix consisting of the first} \\indented{1}{n rows of the m-by-n matrix \\spad{m.} Error: if} \\indented{1}{\\spad{m < n}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..2] for \\spad{j} in 1..5] \\spad{X} squareTop \\spad{m}" - ---->bookvol10.2.pamphlet-->MatrixCategory((horizConcat (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{horizConcat(x,y)} horizontally concatenates two matrices with} \\indented{1}{an equal number of rows. The entries of \\spad{y} appear to the right} \\indented{1}{of the entries of x.\\space{2}Error: if the matrices} \\indented{1}{do not have the same number of rows.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} horizConcat(m,m)" - ---->bookvol10.2.pamphlet-->MatrixCategory((vertConcat (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{vertConcat(x,y)} vertically concatenates two matrices with an} \\indented{1}{equal number of columns. The entries of \\spad{y} appear below} \\indented{1}{of the entries of x.\\space{2}Error: if the matrices} \\indented{1}{do not have the same number of columns.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} vertConcat(m,m)" - ---->bookvol10.2.pamphlet-->MatrixCategory((listOfLists ((List (List R)) %))): Improper first word in comments: -"\\indented{1}{\\spad{listOfLists(m)} returns the rows of the matrix \\spad{m} as a list} \\indented{1}{of lists.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} listOfLists \\spad{m}" - ---->bookvol10.2.pamphlet-->MatrixCategory((elt (% % (List (Integer)) (List (Integer))))): Improper first word in comments: -"\\indented{1}{\\spad{elt(x,rowList,colList)} returns an m-by-n matrix consisting} \\indented{1}{of elements of \\spad{x,} where \\spad{m = \\# rowList} and \\spad{n = \\# colList}} \\indented{1}{If \\spad{rowList = [i<1>,i<2>,...,i]} and \\spad{colList \\spad{=}} \\indented{1}{[j<1>,j<2>,...,j]}, then the \\spad{(k,l)}th entry of} \\indented{1}{\\spad{elt(x,rowList,colList)} is \\spad{x(i,j)}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} elt(m,3,3)" - ---->bookvol10.2.pamphlet-->MatrixCategory((setelt (% % (List (Integer)) (List (Integer)) %))): Improper first word in comments: -"\\indented{1}{\\spad{setelt(x,rowList,colList,y)} destructively alters the matrix \\spad{x.}} \\indented{1}{If \\spad{y} is \\spad{m}-by-\\spad{n}, \\spad{rowList = [i<1>,i<2>,...,i]}} \\indented{1}{and \\spad{colList = [j<1>,j<2>,...,j]}, then \\spad{x(i,j)}} \\indented{1}{is set to \\spad{y(k,l)} for \\spad{k = 1,...,m} and \\spad{l = 1,...,n}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} setelt(m,3,3,10)" - ---->bookvol10.2.pamphlet-->MatrixCategory((swapRows! (% % (Integer) (Integer)))): Improper first word in comments: -"\\indented{1}{\\spad{swapRows!(m,i,j)} interchanges the \\spad{i}th and \\spad{j}th} \\indented{1}{rows of \\spad{m.} This destructively alters the matrix.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} swapRows!(m,2,4)" - ---->bookvol10.2.pamphlet-->MatrixCategory((swapColumns! (% % (Integer) (Integer)))): Improper first word in comments: -"\\indented{1}{\\spad{swapColumns!(m,i,j)} interchanges the \\spad{i}th and \\spad{j}th} \\indented{1}{columns of \\spad{m.} This destructively alters the matrix.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} swapColumns!(m,2,4)" - ---->bookvol10.2.pamphlet-->MatrixCategory((subMatrix (% % (Integer) (Integer) (Integer) (Integer)))): Improper first word in comments: -"\\indented{1}{\\spad{subMatrix(x,i1,i2,j1,j2)} extracts the submatrix} \\indented{1}{\\spad{[x(i,j)]} where the index \\spad{i} ranges from \\spad{i1} to \\spad{i2}} \\indented{1}{and the index \\spad{j} ranges from \\spad{j1} to \\spad{j2}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} subMatrix(m,1,3,2,4)" - ---->bookvol10.2.pamphlet-->MatrixCategory((setsubMatrix! (% % (Integer) (Integer) %))): Improper first word in comments: -"\\indented{1}{\\spad{setsubMatrix(x,i1,j1,y)} destructively alters the} \\indented{1}{matrix \\spad{x.} Here \\spad{x(i,j)} is set to \\spad{y(i-i1+1,j-j1+1)} for} \\indented{1}{\\spad{i = i1,...,i1-1+nrows \\spad{y}} and \\spad{j = j1,...,j1-1+ncols y}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} setsubMatrix!(m,2,2,matrix [[3,3],[3,3]])" - ---->bookvol10.2.pamphlet-->MatrixCategory((+ (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{x + \\spad{y}} is the sum of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m+m}" - ---->bookvol10.2.pamphlet-->MatrixCategory((- (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{x - \\spad{y}} is the difference of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m-m}" - ---->bookvol10.2.pamphlet-->MatrixCategory((- (% %))): Improper first word in comments: -"\\indented{1}{\\spad{-x} returns the negative of the matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{-m}" - ---->bookvol10.2.pamphlet-->MatrixCategory((* (% % %))): Improper first word in comments: -"\\indented{1}{\\spad{x * \\spad{y}} is the product of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m*m}" - ---->bookvol10.2.pamphlet-->MatrixCategory((* (% R %))): Improper first word in comments: -"\\indented{1}{\\spad{r*x} is the left scalar multiple of the scalar \\spad{r} and the} \\indented{1}{matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} 1/3*m" - ---->bookvol10.2.pamphlet-->MatrixCategory((* (% % R))): Improper first word in comments: -"\\indented{1}{\\spad{x * \\spad{r}} is the right scalar multiple of the scalar \\spad{r} and the} \\indented{1}{matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m*1/3}" - ---->bookvol10.2.pamphlet-->MatrixCategory((* (% (Integer) %))): Improper first word in comments: -"\\indented{1}{\\spad{n * \\spad{x}} is an integer multiple.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} 3*m" - ---->bookvol10.2.pamphlet-->MatrixCategory((* (Col % Col))): Improper first word in comments: -"\\indented{1}{\\spad{x * \\spad{c}} is the product of the matrix \\spad{x} and the column vector \\spad{c.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} c:=coerce([1,2,3,4,5])@Matrix(INT) \\spad{X} \\spad{m*c}" - ---->bookvol10.2.pamphlet-->MatrixCategory((* (Row Row %))): Improper first word in comments: -"\\indented{1}{\\spad{r * \\spad{x}} is the product of the row vector \\spad{r} and the matrix \\spad{x.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} r:=transpose([1,2,3,4,5])@Matrix(INT) \\spad{X} \\spad{r*m}" - ---->bookvol10.2.pamphlet-->MatrixCategory((** (% % (NonNegativeInteger)))): Improper first word in comments: -"\\indented{1}{\\spad{x \\spad{**} \\spad{n}} computes a non-negative integral power of the matrix \\spad{x.}} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m**3}" - ---->bookvol10.2.pamphlet-->MatrixCategory((exquo ((Union % failed) % R))): Improper first word in comments: -"\\indented{1}{\\spad{exquo(m,r)} computes the exact quotient of the elements} \\indented{1}{of \\spad{m} by \\spad{r,} returning \\axiom{\"failed\"} if this is not possible.} \\blankline \\spad{X} m:=matrix [[2**i for \\spad{i} in 2..4] for \\spad{j} in 1..5] \\spad{X} exquo(m,2)" - ---->bookvol10.2.pamphlet-->MatrixCategory((/ (% % R))): Improper first word in comments: -"\\indented{1}{\\spad{m/r} divides the elements of \\spad{m} by \\spad{r.} Error: if \\spad{r = 0}.} \\blankline \\spad{X} m:=matrix [[2**i for \\spad{i} in 2..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m/4}" - ---->bookvol10.2.pamphlet-->MatrixCategory((rowEchelon (% %))): Improper first word in comments: -"\\indented{1}{\\spad{rowEchelon(m)} returns the row echelon form of the matrix \\spad{m.}} \\blankline \\spad{X} rowEchelon matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->bookvol10.2.pamphlet-->MatrixCategory((columnSpace ((List Col) %))): Improper first word in comments: -"\\indented{1}{\\spad{columnSpace(m)} returns a sublist of columns of the matrix \\spad{m}} \\indented{1}{forming a basis of its column space} \\blankline \\spad{X} columnSpace matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]]" - ---->bookvol10.2.pamphlet-->MatrixCategory((rank ((NonNegativeInteger) %))): Improper first word in comments: -"\\indented{1}{\\spad{rank(m)} returns the rank of the matrix \\spad{m.}} \\blankline \\spad{X} rank matrix [[1,2,3],[4,5,6],[7,8,9]]" - ---->bookvol10.2.pamphlet-->MatrixCategory((nullity ((NonNegativeInteger) %))): Improper first word in comments: -"\\indented{1}{\\spad{nullity(m)} returns the nullity of the matrix \\spad{m.} This is} \\indented{1}{the dimension of the null space of the matrix \\spad{m.}} \\blankline \\spad{X} nullity matrix [[1,2,3],[4,5,6],[7,8,9]]" - ---->bookvol10.2.pamphlet-->MatrixCategory((nullSpace ((List Col) %))): Improper first word in comments: -"\\indented{1}{\\spad{nullSpace(m)} returns a basis for the null space of} \\indented{1}{the matrix \\spad{m.}} \\blankline \\spad{X} nullSpace matrix [[1,2,3],[4,5,6],[7,8,9]]" - ---->bookvol10.2.pamphlet-->MatrixCategory((determinant (R %))): Improper first word in comments: -"\\indented{1}{\\spad{determinant(m)} returns the determinant of the matrix \\spad{m.}} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} determinant matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->bookvol10.2.pamphlet-->MatrixCategory((minordet (R %))): Improper first word in comments: -"\\indented{1}{\\spad{minordet(m)} computes the determinant of the matrix \\spad{m} using} \\indented{1}{minors. Error: if the matrix is not square.} \\blankline \\spad{X} minordet matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->bookvol10.2.pamphlet-->MatrixCategory((pfaffian (R %))): Improper first word in comments: -"\\indented{1}{\\spad{pfaffian(m)} returns the Pfaffian of the matrix \\spad{m.}} \\indented{1}{Error if the matrix is not antisymmetric} \\blankline \\spad{X} pfaffian [[0,1,0,0],[-1,0,0,0],[0,0,0,1],[0,0,-1,0]]" - ---->bookvol10.2.pamphlet-->MatrixCategory((inverse ((Union % failed) %))): Improper first word in comments: -"\\indented{1}{\\spad{inverse(m)} returns the inverse of the matrix \\spad{m.}} \\indented{1}{If the matrix is not invertible, \"failed\" is returned.} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} inverse matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" - ---->bookvol10.2.pamphlet-->MatrixCategory((** (% % (Integer)))): Improper first word in comments: -"\\indented{1}{\\spad{m**n} computes an integral power of the matrix \\spad{m.}} \\indented{1}{Error: if matrix is not square or if the matrix} \\indented{1}{is square but not invertible.} \\blankline \\spad{X} (matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]) \\spad{**} 2" - -========================================================================= typos 40272: >compiling POLYVEC.spad to POLYVEC.nrlib @@ -2521,34 +2072,6 @@ typos 40269: "\\indented{1}{length(x) returns the number of elements in tuple \\spad{x}} \\blankline \\spad{X} t1:PrimitiveArray(Integer):= \\spad{[i} for \\spad{i} in 1..10] \\spad{X} t2:=coerce(t1)$Tuple(Integer) \\spad{X} length(t2)" ========================================================================= -typos 40268: - ->compiling VECTCAT.spad to VECTCAT.nrlib - ---->-->VectorCategory&((cross (% % %))): Improper first word in comments: vectorProduct -"vectorProduct(u,v) constructs the cross product of \\spad{u} and \\spad{v.} Error: if \\spad{u} and \\spad{v} are not of length 3." - ---->-->VectorCategory&((length (R %))): Missing left brace -"\\spad{length(v)} computes the sqrt(dot(v,v)), \\spadignore{i.e.} the magnitude" - ---->-->VectorCategory&((magnitude (R %))): Missing left brace -"\\spad{magnitude(v)} computes the sqrt(dot(v,v)), \\spadignore{i.e.} the length" - ---->-->VectorCategory&(constructor): Missing left brace -"\\spadtype{VectorCategory} represents the type of vector like objects, \\spadignore{i.e.} finite sequences indexed by some finite segment of the integers. The operations available on vectors depend on the structure of the underlying components. Many operations from the component domain are defined for vectors componentwise. It can by assumed that extraction or updating components can be done in constant time." - ---->bookvol10.2.pamphlet-->VectorCategory((cross (% % %))): Improper first word in comments: vectorProduct -"vectorProduct(u,v) constructs the cross product of \\spad{u} and \\spad{v.} Error: if \\spad{u} and \\spad{v} are not of length 3." - ---->bookvol10.2.pamphlet-->VectorCategory((length (R %))): Missing left brace -"\\spad{length(v)} computes the sqrt(dot(v,v)), \\spadignore{i.e.} the magnitude" - ---->bookvol10.2.pamphlet-->VectorCategory((magnitude (R %))): Missing left brace -"\\spad{magnitude(v)} computes the sqrt(dot(v,v)), \\spadignore{i.e.} the length" - ---->bookvol10.2.pamphlet-->VectorCategory(constructor): Missing left brace - -========================================================================= typos 40267: >compiling DFMAT.spad to DFMAT.nrlib @@ -2684,45 +2207,6 @@ typos 40259: ========================================================================= -typos 40257: - ->compiling DIRPCAT.spad to DIRPCAT.nrlib - ---->-->DirectProductCategory&(): Spurious comments: \spad{y*r} multiplies each component of the vector \spad{y} by the element \spad{r.} - ---------constructor--------- ---->bookvol10.2.pamphlet-->DirectProductCategory(): Spurious comments: \spad{y*r} multiplies each component of the vector \spad{y} by the element \spad{r.} - -========================================================================= -typos 40253: - ->compiling FAXF.spad to FAXF.nrlib - ---->-->FiniteAlgebraicExtensionField&((normalElement ($))): Missing left brace -"\\spad{normalElement()} returns a element, normal over the ground field \\spad{F,} \\spadignore{i.e.} \\spad{a**(q**i), 0 \\spad{<=} \\spad{i} < extensionDegree()} is an F-basis, where \\spad{q = size()\\$F}. At the first call, the element is computed by \\spadfunFrom{createNormalElement}{FiniteAlgebraicExtensionField} then cached in a global variable. On subsequent calls, the element is retrieved by referencing the global variable." - ---->-->FiniteAlgebraicExtensionField&((normal? ((Boolean) $))): Missing left brace -"\\spad{normal?(a)} tests whether the element \\spad{a} is normal over the ground field \\spad{F,} \\spadignore{i.e.} \\spad{a**(q**i), 0 \\spad{<=} \\spad{i} \\spad{<=} extensionDegree()-1} is an F-basis, where \\spad{q = size()\\$F}. Implementation according to Lidl/Niederreiter: Theorem 2.39." - ---->-->FiniteAlgebraicExtensionField&((linearAssociatedExp ($ $ (SparseUnivariatePolynomial F)))): Missing left brace -"\\spad{linearAssociatedExp(a,f)} is linear over \\spad{F,} \\spadignore{i.e.} for elements a from \\spad{\\$,} \\spad{c,d} form \\spad{F} and \\spad{f,g} univariate polynomials over \\spad{F} we have \\spadfun{linearAssociatedExp}(a,cf+dg) equals \\spad{c} times \\spadfun{linearAssociatedExp}(a,f) plus \\spad{d} times \\spadfun{linearAssociatedExp}(a,g). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from F[X]: \\spadfun{linearAssociatedExp}(a,monomial(1,k)\\$SUP(F)) is defined to be \\spadfun{Frobenius}(a,k) which is a**(q**k), where q=size()\\$F." - ---->-->FiniteAlgebraicExtensionField&(constructor): Missing left brace -"FiniteAlgebraicExtensionField \\spad{F} is the category of fields which are finite algebraic extensions of the field \\spad{F.} If \\spad{F} is finite then any finite algebraic extension of \\spad{F} is finite, too. Let \\spad{K} be a finite algebraic extension of the finite field \\spad{F.} The exponentiation of elements of \\spad{K} defines a Z-module structure on the multiplicative group of \\spad{K.} The additive group of \\spad{K} becomes a module over the ring of polynomials over \\spad{F} via the operation \\spadfun{linearAssociatedExp}(a:K,f:SparseUnivariatePolynomial \\spad{F)} which is linear over \\spad{F,} \\spadignore{i.e.} for elements a from \\spad{K,} \\spad{c,d} from \\spad{F} and \\spad{f,g} univariate polynomials over \\spad{F} we have \\spadfun{linearAssociatedExp}(a,cf+dg) equals \\spad{c} times \\spadfun{linearAssociatedExp}(a,f) plus \\spad{d} times \\spadfun{linearAssociatedExp}(a,g). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from F[X]: \\spadfun{linearAssociatedExp}(a,monomial(1,k)\\$SUP(F)) is defined to be \\spadfun{Frobenius}(a,k) which is a**(q**k) where q=size()\\$F. The operations order and discreteLog associated with the multiplicative exponentiation have additive analogues associated to the operation \\spadfun{linearAssociatedExp}. These are the functions \\spadfun{linearAssociatedOrder} and \\spadfun{linearAssociatedLog}, respectively." - ---->bookvol10.2.pamphlet-->FiniteAlgebraicExtensionField((normalElement ($))): Missing left brace -"\\spad{normalElement()} returns a element, normal over the ground field \\spad{F,} \\spadignore{i.e.} \\spad{a**(q**i), 0 \\spad{<=} \\spad{i} < extensionDegree()} is an F-basis, where \\spad{q = size()\\$F}. At the first call, the element is computed by \\spadfunFrom{createNormalElement}{FiniteAlgebraicExtensionField} then cached in a global variable. On subsequent calls, the element is retrieved by referencing the global variable." - ---->bookvol10.2.pamphlet-->FiniteAlgebraicExtensionField((normal? ((Boolean) $))): Missing left brace -"\\spad{normal?(a)} tests whether the element \\spad{a} is normal over the ground field \\spad{F,} \\spadignore{i.e.} \\spad{a**(q**i), 0 \\spad{<=} \\spad{i} \\spad{<=} extensionDegree()-1} is an F-basis, where \\spad{q = size()\\$F}. Implementation according to Lidl/Niederreiter: Theorem 2.39." - ---->bookvol10.2.pamphlet-->FiniteAlgebraicExtensionField((linearAssociatedExp ($ $ (SparseUnivariatePolynomial F)))): Missing left brace -"\\spad{linearAssociatedExp(a,f)} is linear over \\spad{F,} \\spadignore{i.e.} for elements a from \\spad{\\$,} \\spad{c,d} form \\spad{F} and \\spad{f,g} univariate polynomials over \\spad{F} we have \\spadfun{linearAssociatedExp}(a,cf+dg) equals \\spad{c} times \\spadfun{linearAssociatedExp}(a,f) plus \\spad{d} times \\spadfun{linearAssociatedExp}(a,g). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from F[X]: \\spadfun{linearAssociatedExp}(a,monomial(1,k)\\$SUP(F)) is defined to be \\spadfun{Frobenius}(a,k) which is a**(q**k), where q=size()\\$F." - ---->bookvol10.2.pamphlet-->FiniteAlgebraicExtensionField(constructor): Missing left brace -"FiniteAlgebraicExtensionField \\spad{F} is the category of fields which are finite algebraic extensions of the field \\spad{F.} If \\spad{F} is finite then any finite algebraic extension of \\spad{F} is finite, too. Let \\spad{K} be a finite algebraic extension of the finite field \\spad{F.} The exponentiation of elements of \\spad{K} defines a Z-module structure on the multiplicative group of \\spad{K.} The additive group of \\spad{K} becomes a module over the ring of polynomials over \\spad{F} via the operation \\spadfun{linearAssociatedExp}(a:K,f:SparseUnivariatePolynomial \\spad{F)} which is linear over \\spad{F,} \\spadignore{i.e.} for elements a from \\spad{K,} \\spad{c,d} from \\spad{F} and \\spad{f,g} univariate polynomials over \\spad{F} we have \\spadfun{linearAssociatedExp}(a,cf+dg) equals \\spad{c} times \\spadfun{linearAssociatedExp}(a,f) plus \\spad{d} times \\spadfun{linearAssociatedExp}(a,g). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from F[X]: \\spadfun{linearAssociatedExp}(a,monomial(1,k)\\$SUP(F)) is defined to be \\spadfun{Frobenius}(a,k) which is a**(q**k) where q=size()\\$F. The operations order and discreteLog associated with the multiplicative exponentiation have additive analogues associated to the operation \\spadfun{linearAssociatedExp}. These are the functions \\spadfun{linearAssociatedOrder} and \\spadfun{linearAssociatedLog}, respectively." - -========================================================================= typos 40252: >compiling FFPOLY2.spad to FFPOLY2.nrlib @@ -2919,35 +2403,6 @@ typos 40223: "This is just an interface between several packages and domains. The goal is to compute lexicographical Groebner bases of sets of polynomial with type \\spadtype{Polynomial \\spad{R}} by the FGLM algorithm if this is possible (\\spadignore{i.e.} if the input system generates a zero-dimensional ideal)." ========================================================================= -typos 40222: - ->compiling FINAALG.spad to FINAALG.nrlib - ---->-->FiniteRankNonAssociativeAlgebra&((antiAssociative? ((Boolean)))): Missing left brace -"\\spad{antiAssociative?()} tests if multiplication in algebra is anti-associative, \\spadignore{i.e.} \\spad{(a*b)*c + a*(b*c) = 0} for all \\spad{a},b,c in the algebra." - ---->-->FiniteRankNonAssociativeAlgebra&((lieAdmissible? ((Boolean)))): Missing left brace -"\\spad{lieAdmissible?()} tests if the algebra defined by the commutators is a Lie algebra, \\spadignore{i.e.} satisfies the Jacobi identity. The property of anticommutativity follows from definition." - ---->-->FiniteRankNonAssociativeAlgebra&((jordanAdmissible? ((Boolean)))): Missing left brace -"\\spad{jordanAdmissible?()} tests if 2 is invertible in the coefficient domain and the multiplication defined by \\spad{(1/2)(a*b+b*a)} determines a Jordan algebra, \\spadignore{i.e.} satisfies the Jordan identity. The property of \\spadatt{commutative(\"*\")} follows from by definition." - ---->-->FiniteRankNonAssociativeAlgebra&((associatorDependence ((List (Vector R))))): Missing left brace -"\\spad{associatorDependence()} looks for the associator identities, \\spadignore{i.e.} finds a basis of the solutions of the linear combinations of the six permutations of \\spad{associator(a,b,c)} which yield 0, for all \\spad{a},b,c in the algebra. The order of the permutations is \\spad{123 231 312 132 321 213}." - ---->bookvol10.2.pamphlet-->FiniteRankNonAssociativeAlgebra((antiAssociative? ((Boolean)))): Missing left brace -"\\spad{antiAssociative?()} tests if multiplication in algebra is anti-associative, \\spadignore{i.e.} \\spad{(a*b)*c + a*(b*c) = 0} for all \\spad{a},b,c in the algebra." - ---->bookvol10.2.pamphlet-->FiniteRankNonAssociativeAlgebra((lieAdmissible? ((Boolean)))): Missing left brace -"\\spad{lieAdmissible?()} tests if the algebra defined by the commutators is a Lie algebra, \\spadignore{i.e.} satisfies the Jacobi identity. The property of anticommutativity follows from definition." - ---->bookvol10.2.pamphlet-->FiniteRankNonAssociativeAlgebra((jordanAdmissible? ((Boolean)))): Missing left brace -"\\spad{jordanAdmissible?()} tests if 2 is invertible in the coefficient domain and the multiplication defined by \\spad{(1/2)(a*b+b*a)} determines a Jordan algebra, \\spadignore{i.e.} satisfies the Jordan identity. The property of \\spadatt{commutative(\"*\")} follows from by definition." - ---->bookvol10.2.pamphlet-->FiniteRankNonAssociativeAlgebra((associatorDependence ((List (Vector R))))): Missing left brace -"\\spad{associatorDependence()} looks for the associator identities, \\spadignore{i.e.} finds a basis of the solutions of the linear combinations of the six permutations of \\spad{associator(a,b,c)} which yield 0, for all \\spad{a},b,c in the algebra. The order of the permutations is \\spad{123 231 312 132 321 213}." - -========================================================================= typos 40221: >compiling FFF.spad to FFF.nrlib @@ -3269,35 +2724,6 @@ typos 40184: --->bookvol10.4.pamphlet-->RationalInterpolation((interpolate ((Fraction (Polynomial F)) (List F) (List F) (NonNegativeInteger) (NonNegativeInteger)))): Not documented!!!! ========================================================================= -typos 40183: - ->compiling RMATCAT.spad to RMATCAT.nrlib - ---->-->RectangularMatrixCategory&((square? ((Boolean) %))): Mismatch: left pren matches right brace -"\\spad{square?(m)} returns \\spad{true} if \\spad{m} is a square matrix (\\spadignore{i.e.} if \\spad{m} has the same number of rows as columns) and \\spad{false} otherwise." - ---->-->RectangularMatrixCategory&((diagonal? ((Boolean) %))): Mismatch: left pren matches right brace -"\\spad{diagonal?(m)} returns \\spad{true} if the matrix \\spad{m} is square and diagonal (\\spadignore{i.e.} all entries of \\spad{m} not on the diagonal are zero) and \\spad{false} otherwise." - ---->-->RectangularMatrixCategory&((symmetric? ((Boolean) %))): Mismatch: left pren matches right brace -"\\spad{symmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and symmetric (\\spadignore{i.e.} \\spad{m[i,j] = m[j,i]} for all \\spad{i} and \\spad{j)} and \\spad{false} otherwise." - ---->-->RectangularMatrixCategory&((antisymmetric? ((Boolean) %))): Mismatch: left pren matches right brace -"\\spad{antisymmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and antisymmetric (\\spadignore{i.e.} \\spad{m[i,j] = -m[j,i]} for all \\spad{i} and \\spad{j)} and \\spad{false} otherwise." - ---->bookvol10.2.pamphlet-->RectangularMatrixCategory((square? ((Boolean) %))): Mismatch: left pren matches right brace -"\\spad{square?(m)} returns \\spad{true} if \\spad{m} is a square matrix (\\spadignore{i.e.} if \\spad{m} has the same number of rows as columns) and \\spad{false} otherwise." - ---->bookvol10.2.pamphlet-->RectangularMatrixCategory((diagonal? ((Boolean) %))): Mismatch: left pren matches right brace -"\\spad{diagonal?(m)} returns \\spad{true} if the matrix \\spad{m} is square and diagonal (\\spadignore{i.e.} all entries of \\spad{m} not on the diagonal are zero) and \\spad{false} otherwise." - ---->bookvol10.2.pamphlet-->RectangularMatrixCategory((symmetric? ((Boolean) %))): Mismatch: left pren matches right brace -"\\spad{symmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and symmetric (\\spadignore{i.e.} \\spad{m[i,j] = m[j,i]} for all \\spad{i} and \\spad{j)} and \\spad{false} otherwise." - ---->bookvol10.2.pamphlet-->RectangularMatrixCategory((antisymmetric? ((Boolean) %))): Mismatch: left pren matches right brace -"\\spad{antisymmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and antisymmetric (\\spadignore{i.e.} \\spad{m[i,j] = -m[j,i]} for all \\spad{i} and \\spad{j)} and \\spad{false} otherwise." - -========================================================================= typos 40182: >compiling SCPKG.spad to SCPKG.nrlib @@ -3559,17 +2985,6 @@ typos 40156: "\\spad{integralBasis(p)} returns a record \\spad{[basis,basisDen,basisInv]} containing information regarding the local integral closure of \\spad{R} at the prime \\spad{p} in the quotient field of \\spad{F,} where \\spad{F} is a framed algebra with R-module basis \\spad{w1,w2,...,wn}. If \\spad{basis} is the matrix \\spad{(aij, \\spad{i} = 1..n, \\spad{j} = 1..n)}, then the \\spad{i}th element of the local integral basis is \\spad{vi = (1/basisDen) * sum(aij * \\spad{wj,} \\spad{j} = 1..n)}, \\spadignore{i.e.} the \\spad{i}th row of \\spad{basis} contains the coordinates of the \\spad{i}th basis vector. Similarly, the \\spad{i}th row of the matrix \\spad{basisInv} contains the coordinates of \\spad{wi} with respect to the basis \\spad{v1,...,vn}: if \\spad{basisInv} is the matrix \\spad{(bij, \\spad{i} = 1..n, \\spad{j} = 1..n)}, then \\spad{wi = sum(bij * \\spad{vj,} \\spad{j} = 1..n)}." ========================================================================= -typos 40155: - ->compiling FSAGG.spad to FSAGG.nrlib - ---->-->FiniteSetAggregate&((complement (% %))): Missing left brace -"\\spad{complement(u)} returns the complement of the set u, \\spadignore{i.e.} the set of all values not in u." - ---->bookvol10.2.pamphlet-->FiniteSetAggregate((complement (% %))): Missing left brace -"\\spad{complement(u)} returns the complement of the set u, \\spadignore{i.e.} the set of all values not in u." - -========================================================================= typos 40154: >compiling IBATOOL.spad to IBATOOL.nrlib @@ -3734,23 +3149,6 @@ typos 40143: "\\spad{unrankImproperPartitions1(n,m,k)} computes the \\spad{k}-th improper partition of nonnegative \\spad{n} in at most \\spad{m} nonnegative parts ordered as follows: first, in reverse lexicographically according to their non-zero parts, then according to their positions (\\spadignore{i.e.} lexicographical order using subSet: [3,0,0] < [0,3,0] < [0,0,3] < [2,1,0] < [2,0,1] < [0,2,1] < [1,2,0] < [1,0,2] < [0,1,2] < [1,1,1]. Note that counting of subtrees is done by numberOfImproperPartitionsInternal." ========================================================================= -typos 40142: - ->compiling TBAGG.spad to TBAGG.nrlib - ---->-->TableAggregate&((table (%))): Improper first word in comments: -"\\indented{1}{table()$T creates an empty table of type \\spad{T.}} \\blankline \\spad{E} Data:=Record(age:Integer,gender:String) \\spad{E} a1:AssociationList(String,Data):=table() \\spad{E} a1.\"tim\":=[55,\"male\"]$Data" - ---->-->TableAggregate&(constructor): Missing left brace -"A table aggregate is a model of a table, \\spadignore{i.e.} a discrete many-to-one mapping from keys to entries." - ---->bookvol10.2.pamphlet-->TableAggregate((table (%))): Improper first word in comments: -"\\indented{1}{table()$T creates an empty table of type \\spad{T.}} \\blankline \\spad{E} Data:=Record(age:Integer,gender:String) \\spad{E} a1:AssociationList(String,Data):=table() \\spad{E} a1.\"tim\":=[55,\"male\"]$Data" - ---->bookvol10.2.pamphlet-->TableAggregate(constructor): Missing left brace -"A table aggregate is a model of a table, \\spadignore{i.e.} a discrete many-to-one mapping from keys to entries." - -========================================================================= typos 40141: >compiling WFFINTBS.spad to WFFINTBS.nrlib @@ -3817,83 +3215,6 @@ typos 40139: "\\spad{measure(prob,R)} is a top level ANNA function for identifying the most appropriate numerical routine from those in the routines table provided for solving the numerical PDE problem defined by \\axiom{prob}. \\blankline It calls each \\axiom{domain} listed in \\axiom{R} of \\axiom{category} \\axiomType{PartialDifferentialEquationsSolverCategory} in turn to calculate all measures and returns the best \\spadignore{i.e.} the name of the most appropriate domain and any other relevant information. It predicts the likely most effective NAG numerical Library routine to solve the input set of PDEs by checking various attributes of the system of PDEs and calculating a measure of compatibility of each routine to these attributes." ========================================================================= -typos 40138: - ->compiling ACF.spad to ACF.nrlib - ---->-->AlgebraicallyClosedField&((rootOf ($ (Polynomial $)))): Improper first word in comments: -"\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)" - ---->-->AlgebraicallyClosedField&((rootOf ($ (SparseUnivariatePolynomial $)))): Improper first word in comments: -"\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)" - ---->-->AlgebraicallyClosedField&((rootOf ($ (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: -"\\indented{1}{rootOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{The object returned displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a,x)" - ---->-->AlgebraicallyClosedField&((rootsOf ((List $) (Polynomial $)))): Improper first word in comments: -"\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the} \\indented{1}{interpreter to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)" - ---->-->AlgebraicallyClosedField&((rootsOf ((List $) (SparseUnivariatePolynomial $)))): Improper first word in comments: -"\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)" - ---->-->AlgebraicallyClosedField&((rootsOf ((List $) (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: -"\\indented{1}{rootsOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0};} \\indented{1}{The returned roots display as \\spad{'y1},...,\\spad{'yn}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a,x)" - ---->-->AlgebraicallyClosedField&((zeroOf ($ (Polynomial $)))): Improper first word in comments: -"\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{If possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zeroOf(a)" - ---->-->AlgebraicallyClosedField&((zeroOf ($ (SparseUnivariatePolynomial $)))): Improper first word in comments: -"\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a)" - ---->-->AlgebraicallyClosedField&((zeroOf ($ (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: -"\\indented{1}{zeroOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity which} \\indented{1}{displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a,x)" - ---->-->AlgebraicallyClosedField&((zerosOf ((List $) (Polynomial $)))): Improper first word in comments: -"\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible.} \\indented{1}{Otherwise they are implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zerosOf(a)" - ---->-->AlgebraicallyClosedField&((zerosOf ((List $) (SparseUnivariatePolynomial $)))): Improper first word in comments: -"\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a)" - ---->-->AlgebraicallyClosedField&((zerosOf ((List $) (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: -"\\indented{1}{zerosOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities} \\indented{1}{which display as \\spad{'yi}.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a,x)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootOf ($ (Polynomial $)))): Improper first word in comments: -"\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootOf ($ (SparseUnivariatePolynomial $)))): Improper first word in comments: -"\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootOf ($ (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: -"\\indented{1}{rootOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{The object returned displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a,x)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootsOf ((List $) (Polynomial $)))): Improper first word in comments: -"\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the} \\indented{1}{interpreter to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootsOf ((List $) (SparseUnivariatePolynomial $)))): Improper first word in comments: -"\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootsOf ((List $) (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: -"\\indented{1}{rootsOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0};} \\indented{1}{The returned roots display as \\spad{'y1},...,\\spad{'yn}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a,x)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zeroOf ($ (Polynomial $)))): Improper first word in comments: -"\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{If possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zeroOf(a)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zeroOf ($ (SparseUnivariatePolynomial $)))): Improper first word in comments: -"\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zeroOf ($ (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: -"\\indented{1}{zeroOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity which} \\indented{1}{displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a,x)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zerosOf ((List $) (Polynomial $)))): Improper first word in comments: -"\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible.} \\indented{1}{Otherwise they are implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zerosOf(a)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zerosOf ((List $) (SparseUnivariatePolynomial $)))): Improper first word in comments: -"\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a)" - ---->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zerosOf ((List $) (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: -"\\indented{1}{zerosOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities} \\indented{1}{which display as \\spad{'yi}.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a,x)" - -========================================================================= typos 40137: >compiling ACPLOT.spad to ACPLOT.nrlib @@ -3951,83 +3272,6 @@ typos 40133: "\\spad{setProperties(op, \\spad{l)}} sets the property list of \\spad{op} to \\spad{l.} Argument \\spad{op} is modified \"in place\", \\spadignore{i.e.} no copy is made." ========================================================================= -typos 40130: - ->compiling FFCAT.spad to FFCAT.nrlib - ---->-->FunctionFieldCategory&((numberOfComponents ((NonNegativeInteger)))): Improper first word in comments: -"\\indented{1}{numberOfComponents() returns the number of absolutely irreducible} \\indented{1}{components.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} numberOfComponents()$R" - ---->-->FunctionFieldCategory&((genus ((NonNegativeInteger)))): Improper first word in comments: -"\\indented{1}{genus() returns the genus of one absolutely irreducible component} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} genus()$R" - ---->-->FunctionFieldCategory&((absolutelyIrreducible? ((Boolean)))): Improper first word in comments: -"\\indented{1}{absolutelyIrreducible?() tests if the curve absolutely irreducible?} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} \\spad{absolutelyIrreducible?()$R2}" - ---->-->FunctionFieldCategory&((rationalPoint? ((Boolean) F F))): Improper first word in comments: -"\\indented{1}{rationalPoint?(a, \\spad{b)} tests if \\spad{(x=a,y=b)} is on the curve.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} rationalPoint?(0,0)$R \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} \\spad{rationalPoint?(0,0)$R2}" - ---->-->FunctionFieldCategory&((branchPointAtInfinity? ((Boolean)))): Improper first word in comments: -"\\indented{1}{branchPointAtInfinity?() tests if there is a branch point} \\indented{1}{at infinity.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} branchPointAtInfinity?()$R \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} branchPointAtInfinity?()$R" - ---->-->FunctionFieldCategory&((integralBasis ((Vector $)))): Improper first word in comments: -"\\indented{1}{integralBasis() returns the integral basis for the curve.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralBasis()$R" - ---->-->FunctionFieldCategory&((integralBasisAtInfinity ((Vector $)))): Improper first word in comments: -"\\indented{1}{integralBasisAtInfinity() returns the local integral basis} \\indented{1}{at infinity} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralBasisAtInfinity()$R" - ---->-->FunctionFieldCategory&((integralMatrix ((Matrix RF)))): Improper first word in comments: -"\\indented{1}{integralMatrix() returns \\spad{M} such that} \\indented{1}{\\spad{(w1,...,wn) = \\spad{M} \\spad{(1,} \\spad{y,} ..., y**(n-1))},} \\indented{1}{where \\spad{(w1,...,wn)} is the integral basis of} \\indented{1}{\\spadfunFrom{integralBasis}{FunctionFieldCategory}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralMatrix()$R" - ---->-->FunctionFieldCategory&((inverseIntegralMatrix ((Matrix RF)))): Improper first word in comments: -"\\indented{1}{inverseIntegralMatrix() returns \\spad{M} such that} \\indented{1}{\\spad{M (w1,...,wn) = \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(w1,...,wn)} is the integral basis of} \\indented{1}{\\spadfunFrom{integralBasis}{FunctionFieldCategory}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} inverseIntegralMatrix()$R" - ---->-->FunctionFieldCategory&((integralMatrixAtInfinity ((Matrix RF)))): Improper first word in comments: -"\\indented{1}{integralMatrixAtInfinity() returns \\spad{M} such that} \\indented{1}{\\spad{(v1,...,vn) = \\spad{M} \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(v1,...,vn)} is the local integral basis at infinity} \\indented{1}{returned by \\spad{infIntBasis()}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralMatrixAtInfinity()$R" - ---->-->FunctionFieldCategory&((inverseIntegralMatrixAtInfinity ((Matrix RF)))): Improper first word in comments: -"\\indented{1}{inverseIntegralMatrixAtInfinity() returns \\spad{M} such} \\indented{1}{that \\spad{M (v1,...,vn) = \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(v1,...,vn)} is the local integral basis at infinity} \\indented{1}{returned by \\spad{infIntBasis()}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} inverseIntegralMatrixAtInfinity()$R" - ---->-->FunctionFieldCategory&((rationalPoints ((List (List F))))): Improper first word in comments: -"\\indented{1}{rationalPoints() returns the list of all the affine} rational points." - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((numberOfComponents ((NonNegativeInteger)))): Improper first word in comments: -"\\indented{1}{numberOfComponents() returns the number of absolutely irreducible} \\indented{1}{components.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} numberOfComponents()$R" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((genus ((NonNegativeInteger)))): Improper first word in comments: -"\\indented{1}{genus() returns the genus of one absolutely irreducible component} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} genus()$R" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((absolutelyIrreducible? ((Boolean)))): Improper first word in comments: -"\\indented{1}{absolutelyIrreducible?() tests if the curve absolutely irreducible?} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} \\spad{absolutelyIrreducible?()$R2}" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((rationalPoint? ((Boolean) F F))): Improper first word in comments: -"\\indented{1}{rationalPoint?(a, \\spad{b)} tests if \\spad{(x=a,y=b)} is on the curve.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} rationalPoint?(0,0)$R \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} \\spad{rationalPoint?(0,0)$R2}" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((branchPointAtInfinity? ((Boolean)))): Improper first word in comments: -"\\indented{1}{branchPointAtInfinity?() tests if there is a branch point} \\indented{1}{at infinity.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} branchPointAtInfinity?()$R \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} branchPointAtInfinity?()$R" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((integralBasis ((Vector $)))): Improper first word in comments: -"\\indented{1}{integralBasis() returns the integral basis for the curve.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralBasis()$R" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((integralBasisAtInfinity ((Vector $)))): Improper first word in comments: -"\\indented{1}{integralBasisAtInfinity() returns the local integral basis} \\indented{1}{at infinity} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralBasisAtInfinity()$R" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((integralMatrix ((Matrix RF)))): Improper first word in comments: -"\\indented{1}{integralMatrix() returns \\spad{M} such that} \\indented{1}{\\spad{(w1,...,wn) = \\spad{M} \\spad{(1,} \\spad{y,} ..., y**(n-1))},} \\indented{1}{where \\spad{(w1,...,wn)} is the integral basis of} \\indented{1}{\\spadfunFrom{integralBasis}{FunctionFieldCategory}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralMatrix()$R" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((inverseIntegralMatrix ((Matrix RF)))): Improper first word in comments: -"\\indented{1}{inverseIntegralMatrix() returns \\spad{M} such that} \\indented{1}{\\spad{M (w1,...,wn) = \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(w1,...,wn)} is the integral basis of} \\indented{1}{\\spadfunFrom{integralBasis}{FunctionFieldCategory}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} inverseIntegralMatrix()$R" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((integralMatrixAtInfinity ((Matrix RF)))): Improper first word in comments: -"\\indented{1}{integralMatrixAtInfinity() returns \\spad{M} such that} \\indented{1}{\\spad{(v1,...,vn) = \\spad{M} \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(v1,...,vn)} is the local integral basis at infinity} \\indented{1}{returned by \\spad{infIntBasis()}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralMatrixAtInfinity()$R" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((inverseIntegralMatrixAtInfinity ((Matrix RF)))): Improper first word in comments: -"\\indented{1}{inverseIntegralMatrixAtInfinity() returns \\spad{M} such} \\indented{1}{that \\spad{M (v1,...,vn) = \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(v1,...,vn)} is the local integral basis at infinity} \\indented{1}{returned by \\spad{infIntBasis()}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} inverseIntegralMatrixAtInfinity()$R" - ---->bookvol10.2.pamphlet-->FunctionFieldCategory((rationalPoints ((List (List F))))): Improper first word in comments: -"\\indented{1}{rationalPoints() returns the list of all the affine} rational points." - -========================================================================= typos 40129: >compiling FFCGP.spad to FFCGP.nrlib @@ -40523,4 +39767,741 @@ typos 40346: --->bookvol10.2.pamphlet-->OrderedSet(constructor): Missing left brace "The class of totally ordered sets, that is, sets such that for each pair of elements \\spad{(a,b)} exactly one of the following relations holds \\spad{a} acompiling REAL.spad to REAL.nrlib + +--->bookvol10.2.pamphlet-->RealConstant(constructor): Missing left brace +"The category of real numeric domains, \\spadignore{i.e.} convertible to floats." + +fixed 20130317.07.tpd.patch +========================================================================= +typos 40342: + +>compiling SGROUP.spad to SGROUP.nrlib + +--->-->SemiGroup&((** (% % (PositiveInteger)))): Missing left brace +"\\spad{x**n} returns the repeated product of \\spad{x} \\spad{n} times, \\spadignore{i.e.} exponentiation." + +--->-->SemiGroup&((^ (% % (PositiveInteger)))): Missing left brace +"\\spad{x^n} returns the repeated product of \\spad{x} \\spad{n} times, \\spadignore{i.e.} exponentiation." + +========================================================================= +typos 40341: + +>compiling SPACEC.spad to SPACEC.nrlib + +--->bookvol10.2.pamphlet-->ThreeSpaceCategory((curve ((L POINT) %))): Missing left brace +"\\spad{curve(s)} checks to see if the \\spadtype{ThreeSpace}, \\spad{s,} is composed of a single curve defined by a list of points and if so, returns the curve, \\spadignore{i.e.} list of points. An error is signaled otherwise." + +--->bookvol10.2.pamphlet-->ThreeSpaceCategory((curve? (B %))): Missing left brace +"\\spad{curve?(s)} queries whether the \\spadtype{ThreeSpace}, \\spad{s,} is a curve, \\spadignore{i.e.} has one component, a list of list of points, and returns \\spad{true} if it is, or \\spad{false} otherwise." + +--->bookvol10.2.pamphlet-->ThreeSpaceCategory((closedCurve? (B %))): Missing left brace +"\\spad{closedCurve?(s)} returns \\spad{true} if the \\spadtype{ThreeSpace} \\spad{s} contains a single closed curve component, \\spadignore{i.e.} the first element of the curve is also the last element, or \\spad{false} otherwise." + +--->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L (L R))) (L PROP) PROP))): Missing close parenthesis on first line: mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] ], +"mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] \\spad{],} \\indented{7}{[props], prop)} adds a surface component to the \\spadtype{ThreeSpace} \\spad{s,} which is defined over a rectangular domain of size \\spad{WxH} where \\spad{W} is the number of lists of points from the domain \\spad{PointDomain(R)} and \\spad{H} is the number of elements in each of those lists; lprops is the list of the subspace component properties for each curve list, and prop is the subspace component property by which the points are defined." + +--->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L POINT)) B B))): Missing left brace +--->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L POINT)) B B))): Missing left brace +"\\spad{mesh(s,[[p0],[p1],...,[pn]], close1, close2)} adds a surface component to the \\spadtype{ThreeSpace}, which is defined over a list of curves, in which each of these curves is a list of points. The boolean arguments \\spad{close1} and \\spad{close2} indicate how the surface is to be closed. Argument \\spad{close1} equal \\spad{true} means that each individual list (a curve) is to be closed, \\spadignore{i.e.} the last point of the list is to be connected to the first point. Argument \\spad{close2} equal \\spad{true} means that the boundary at one end of the surface is to be connected to the boundary at the other end, \\spadignore{i.e.} the boundaries are defined as the first list of points (curve) and the last list of points (curve)." + +--->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L (L R))) B B))): Missing close parenthesis on first line: mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] ], +--->bookvol10.2.pamphlet-->ThreeSpaceCategory((mesh (% % (L (L (L R))) B B))): Mismatch: left pren matches right brace +"mesh(s,[ [[r10]...,[r1m]],[[r20]...,[r2m]],...,[[rn0]...,[rnm]] \\spad{],} \\indented{5}{close1, close2)} adds a surface component to the \\spadtype{ThreeSpace} \\spad{s,} which is defined over a rectangular domain of size \\spad{WxH} where \\spad{W} is the number of lists of points from the domain \\spad{PointDomain(R)} and \\spad{H} is the number of elements in each of those lists; the booleans \\spad{close1} and \\spad{close2} indicate how the surface is to be closed: if \\spad{close1} is \\spad{true} this means that each individual list (a curve) is to be closed (\\spadignore{i.e.} the last point of the list is to be connected to the first point); if \\spad{close2} is true, this means that the boundary at one end of the surface is to be connected to the boundary at the other end (the boundaries are defined as the first list of points (curve) and the last list of points (curve))." + +--->bookvol10.2.pamphlet-->ThreeSpaceCategory((lp ((L POINT) %))): Missing left brace +"\\spad{lp(s)} returns the list of points component which the \\spadtype{ThreeSpace}, \\spad{s,} contains; these points are used by reference, \\spadignore{i.e.} the component holds indices referring to the points rather than the points themselves. This allows for sharing of the points." + + +========================================================================= +typos 40292: + +>compiling LZSTAGG.spad to LZSTAGG.nrlib + +--->-->LazyStreamAggregate&((remove (% (Mapping (Boolean) S) %))): Improper first word in comments: +"\\indented{1}{remove(f,st) returns a stream consisting of those elements of stream} \\indented{1}{st which do not satisfy the predicate \\spad{f.}} \\indented{1}{Note that \\spad{remove(f,st) = \\spad{[x} for \\spad{x} in st | not f(x)]}.} \\blankline \\spad{X} m:=[i for \\spad{i} in 1..] \\spad{X} f(i:PositiveInteger):Boolean \\spad{==} even? \\spad{i} \\spad{X} remove(f,m)" + +--->-->LazyStreamAggregate&((select (% (Mapping (Boolean) S) %))): Improper first word in comments: +"\\indented{1}{select(f,st) returns a stream consisting of those elements of stream} \\indented{1}{st satisfying the predicate \\spad{f.}} \\indented{1}{Note that \\spad{select(f,st) = \\spad{[x} for \\spad{x} in st | f(x)]}.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} select(x+->prime? x,m)" + +--->-->LazyStreamAggregate&((explicitEntries? ((Boolean) %))): Improper first word in comments: +"\\indented{1}{explicitEntries?(s) returns \\spad{true} if the stream \\spad{s} has} \\indented{1}{explicitly computed entries, and \\spad{false} otherwise.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} explicitEntries? \\spad{m}" + +--->-->LazyStreamAggregate&((explicitlyEmpty? ((Boolean) %))): Improper first word in comments: +"\\indented{1}{explicitlyEmpty?(s) returns \\spad{true} if the stream is an} \\indented{1}{(explicitly) empty stream.} \\indented{1}{Note that this is a null test which will not cause lazy evaluation.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} explicitlyEmpty? \\spad{m}" + +--->-->LazyStreamAggregate&((lazy? ((Boolean) %))): Improper first word in comments: +"\\indented{1}{lazy?(s) returns \\spad{true} if the first node of the stream \\spad{s}} \\indented{1}{is a lazy evaluation mechanism which could produce an} \\indented{1}{additional entry to \\spad{s.}} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} lazy? \\spad{m}" + +--->-->LazyStreamAggregate&((frst (S %))): Improper first word in comments: +"\\indented{1}{frst(s) returns the first element of stream \\spad{s.}} \\indented{1}{Caution: this function should only be called after a \\spad{empty?}} \\indented{1}{test has been made since there no error check.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} frst \\spad{m}" + +--->-->LazyStreamAggregate&((rst (% %))): Improper first word in comments: +"\\indented{1}{rst(s) returns a pointer to the next node of stream \\spad{s.}} \\indented{1}{Caution: this function should only be called after a \\spad{empty?}} \\indented{1}{test has been made since there no error check.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} \\spad{rst} \\spad{m}" + +--->-->LazyStreamAggregate&((numberOfComputedEntries ((NonNegativeInteger) %))): Improper first word in comments: +"\\indented{1}{numberOfComputedEntries(st) returns the number of explicitly} \\indented{1}{computed entries of stream st which exist immediately prior to the} \\indented{1}{time this function is called.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} numberOfComputedEntries \\spad{m}" + +--->-->LazyStreamAggregate&((extend (% % (Integer)))): Improper first word in comments: +"\\indented{1}{extend(st,n) causes entries to be computed, if necessary,} \\indented{1}{so that 'st' will have at least \\spad{'n'} explicit entries or so} \\indented{1}{that all entries of 'st' will be computed if 'st' is finite} \\indented{1}{with length \\spad{<=} \\spad{n.}} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} numberOfComputedEntries \\spad{m} \\spad{X} extend(m,20) \\spad{X} numberOfComputedEntries \\spad{m}" + +--->-->LazyStreamAggregate&((complete (% %))): Improper first word in comments: +"\\indented{1}{complete(st) causes all entries of 'st' to be computed.} \\indented{1}{this function should only be called on streams which are} \\indented{1}{known to be finite.} \\blankline \\spad{X} m:=[i for \\spad{i} in 1..] \\spad{X} n:=filterUntil(i+->i>100,m) \\spad{X} numberOfComputedEntries \\spad{n} \\spad{X} complete \\spad{n} \\spad{X} numberOfComputedEntries \\spad{n}" + +--->-->LazyStreamAggregate&(constructor): Missing left brace +"LazyStreamAggregate is the category of streams with lazy evaluation. It is understood that the function 'empty?' will cause lazy evaluation if necessary to determine if there are entries. Functions which call 'empty?', \\spadignore{e.g.} 'first' and 'rest', will also cause lazy evaluation if necessary." + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((remove (% (Mapping (Boolean) S) %))): Improper first word in comments: +"\\indented{1}{remove(f,st) returns a stream consisting of those elements of stream} \\indented{1}{st which do not satisfy the predicate \\spad{f.}} \\indented{1}{Note that \\spad{remove(f,st) = \\spad{[x} for \\spad{x} in st | not f(x)]}.} \\blankline \\spad{X} m:=[i for \\spad{i} in 1..] \\spad{X} f(i:PositiveInteger):Boolean \\spad{==} even? \\spad{i} \\spad{X} remove(f,m)" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((select (% (Mapping (Boolean) S) %))): Improper first word in comments: +"\\indented{1}{select(f,st) returns a stream consisting of those elements of stream} \\indented{1}{st satisfying the predicate \\spad{f.}} \\indented{1}{Note that \\spad{select(f,st) = \\spad{[x} for \\spad{x} in st | f(x)]}.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} select(x+->prime? x,m)" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((explicitEntries? ((Boolean) %))): Improper first word in comments: +"\\indented{1}{explicitEntries?(s) returns \\spad{true} if the stream \\spad{s} has} \\indented{1}{explicitly computed entries, and \\spad{false} otherwise.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} explicitEntries? \\spad{m}" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((explicitlyEmpty? ((Boolean) %))): Improper first word in comments: +"\\indented{1}{explicitlyEmpty?(s) returns \\spad{true} if the stream is an} \\indented{1}{(explicitly) empty stream.} \\indented{1}{Note that this is a null test which will not cause lazy evaluation.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} explicitlyEmpty? \\spad{m}" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((lazy? ((Boolean) %))): Improper first word in comments: +"\\indented{1}{lazy?(s) returns \\spad{true} if the first node of the stream \\spad{s}} \\indented{1}{is a lazy evaluation mechanism which could produce an} \\indented{1}{additional entry to \\spad{s.}} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} lazy? \\spad{m}" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((frst (S %))): Improper first word in comments: +"\\indented{1}{frst(s) returns the first element of stream \\spad{s.}} \\indented{1}{Caution: this function should only be called after a \\spad{empty?}} \\indented{1}{test has been made since there no error check.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} frst \\spad{m}" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((rst (% %))): Improper first word in comments: +"\\indented{1}{rst(s) returns a pointer to the next node of stream \\spad{s.}} \\indented{1}{Caution: this function should only be called after a \\spad{empty?}} \\indented{1}{test has been made since there no error check.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} \\spad{rst} \\spad{m}" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((numberOfComputedEntries ((NonNegativeInteger) %))): Improper first word in comments: +"\\indented{1}{numberOfComputedEntries(st) returns the number of explicitly} \\indented{1}{computed entries of stream st which exist immediately prior to the} \\indented{1}{time this function is called.} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} numberOfComputedEntries \\spad{m}" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((extend (% % (Integer)))): Improper first word in comments: +"\\indented{1}{extend(st,n) causes entries to be computed, if necessary,} \\indented{1}{so that 'st' will have at least \\spad{'n'} explicit entries or so} \\indented{1}{that all entries of 'st' will be computed if 'st' is finite} \\indented{1}{with length \\spad{<=} \\spad{n.}} \\blankline \\spad{X} m:=[i for \\spad{i} in 0..] \\spad{X} numberOfComputedEntries \\spad{m} \\spad{X} extend(m,20) \\spad{X} numberOfComputedEntries \\spad{m}" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate((complete (% %))): Improper first word in comments: +"\\indented{1}{complete(st) causes all entries of 'st' to be computed.} \\indented{1}{this function should only be called on streams which are} \\indented{1}{known to be finite.} \\blankline \\spad{X} m:=[i for \\spad{i} in 1..] \\spad{X} n:=filterUntil(i+->i>100,m) \\spad{X} numberOfComputedEntries \\spad{n} \\spad{X} complete \\spad{n} \\spad{X} numberOfComputedEntries \\spad{n}" + +--->bookvol10.2.pamphlet-->LazyStreamAggregate(constructor): Missing left brace +"LazyStreamAggregate is the category of streams with lazy evaluation. It is understood that the function 'empty?' will cause lazy evaluation if necessary to determine if there are entries. Functions which call 'empty?', \\spadignore{e.g.} 'first' and 'rest', will also cause lazy evaluation if necessary." + +========================================================================= +typos 40274: + +>compiling LFCAT.spad to LFCAT.nrlib + +--->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((Ei ($ $))): Missing left brace +"\\spad{Ei(x)} returns the exponential integral of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{exp(x)/x dx}." + +--->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((Si ($ $))): Missing left brace +"\\spad{Si(x)} returns the sine integral of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{sin(x) / \\spad{x} dx}." + +--->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((Ci ($ $))): Missing left brace +"\\spad{Ci(x)} returns the cosine integral of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{cos(x) / \\spad{x} dx}." + +--->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((li ($ $))): Missing left brace +"\\spad{li(x)} returns the logarithmic integral of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{dx / log(x)}." + +--->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((dilog ($ $))): Missing left brace +"\\spad{dilog(x)} returns the dilogarithm of \\spad{x,} \\spadignore{i.e.} the integral of \\spad{log(x) / \\spad{(1} - \\spad{x)} dx}." + +--->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((erf ($ $))): Missing left brace +"\\spad{erf(x)} returns the error function of \\spad{x,} \\spadignore{i.e.} \\spad{2 / sqrt(\\%pi)} times the integral of \\spad{exp(-x**2) dx}." + +--->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((fresnelS ($ $))): Improper initial operator in comments: is +"fresnelS is the Fresnel integral \\spad{S,} defined by S(x) = integrate(sin(t^2),t=0..x)" + +--->bookvol10.2.pamphlet-->LiouvillianFunctionCategory((fresnelC ($ $))): Improper initial operator in comments: is +"fresnelC is the Fresnel integral \\spad{C,} defined by C(x) = integrate(cos(t^2),t=0..x)" + +========================================================================= +typos 40273: + +>compiling MATCAT.spad to MATCAT.nrlib + +--->-->MatrixCategory&((square? ((Boolean) %))): Improper first word in comments: +"\\indented{1}{\\spad{square?(m)} returns \\spad{true} if \\spad{m} is a square matrix} \\indented{1}{(if \\spad{m} has the same number of rows as columns) and \\spad{false} otherwise.} \\blankline \\spad{X} square matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->-->MatrixCategory&((diagonal? ((Boolean) %))): Improper first word in comments: +--->-->MatrixCategory&((diagonal? ((Boolean) %))): Mismatch: left pren matches right brace +"\\indented{1}{\\spad{diagonal?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{diagonal (\\spadignore{i.e.} all entries of \\spad{m} not on the diagonal are zero) and} \\indented{1}{false otherwise.} \\blankline \\spad{X} diagonal? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->-->MatrixCategory&((symmetric? ((Boolean) %))): Improper first word in comments: +--->-->MatrixCategory&((symmetric? ((Boolean) %))): Mismatch: left pren matches right brace +"\\indented{1}{\\spad{symmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{symmetric (\\spadignore{i.e.} \\spad{m[i,j] = m[j,i]} for all \\spad{i} and \\spad{j)} and false} \\indented{1}{otherwise.} \\blankline \\spad{X} symmetric? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->-->MatrixCategory&((antisymmetric? ((Boolean) %))): Improper first word in comments: +--->-->MatrixCategory&((antisymmetric? ((Boolean) %))): Mismatch: left pren matches right brace +"\\indented{1}{\\spad{antisymmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{antisymmetric (\\spadignore{i.e.} \\spad{m[i,j] = -m[j,i]} for all \\spad{i} and \\spad{j)}} \\indented{1}{and \\spad{false} otherwise.} \\blankline \\spad{X} antisymmetric? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->-->MatrixCategory&((zero (% (NonNegativeInteger) (NonNegativeInteger)))): Improper first word in comments: +"\\indented{1}{\\spad{zero(m,n)} returns an m-by-n zero matrix.} \\blankline \\spad{X} z:Matrix(INT):=zero(3,3)" + +--->-->MatrixCategory&((matrix (% (List (List R))))): Improper first word in comments: +"\\indented{1}{\\spad{matrix(l)} converts the list of lists \\spad{l} to a matrix, where the} \\indented{1}{list of lists is viewed as a list of the rows of the matrix.} \\blankline \\spad{X} matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]]" +--------(matrix (% (NonNegativeInteger) (NonNegativeInteger) (Mapping R (Integer) (Integer))))--------- +--->-->MatrixCategory&((matrix (% (NonNegativeInteger) (NonNegativeInteger) (Mapping R (Integer) (Integer))))): Improper first word in comments: +"\\indented{1}{\\spad{matrix(n,m,f)} constructs an \\spad{n * \\spad{m}} matrix with} \\indented{1}{the \\spad{(i,j)} entry equal to \\spad{f(i,j)}} \\blankline \\spad{X} f(i:INT,j:INT):INT \\spad{==} i+j \\spad{X} matrix(3,4,f)" + +--->-->MatrixCategory&((scalarMatrix (% (NonNegativeInteger) R))): Improper first word in comments: +"\\indented{1}{\\spad{scalarMatrix(n,r)} returns an n-by-n matrix with \\spad{r's} on the} \\indented{1}{diagonal and zeroes elsewhere.} \\blankline \\spad{X} z:Matrix(INT):=scalarMatrix(3,5)" + +--->-->MatrixCategory&((diagonalMatrix (% (List R)))): Improper first word in comments: +"\\indented{1}{\\spad{diagonalMatrix(l)} returns a diagonal matrix with the elements} \\indented{1}{of \\spad{l} on the diagonal.} \\blankline \\spad{X} diagonalMatrix [1,2,3]" + +--->-->MatrixCategory&((diagonalMatrix (% (List %)))): Improper first word in comments: +"\\indented{1}{\\spad{diagonalMatrix([m1,...,mk])} creates a block diagonal matrix} \\indented{1}{M with block matrices m1,...,mk down the diagonal,} \\indented{1}{with 0 block matrices elsewhere.} \\indented{1}{More precisly: if \\spad{ri \\spad{:=} nrows mi}, \\spad{ci \\spad{:=} ncols mi},} \\indented{1}{then \\spad{m} is an (r1+..+rk) by (c1+..+ck) - matrix\\space{2}with entries} \\indented{1}{\\spad{m.i.j = ml.(i-r1-..-r(l-1)).(j-n1-..-n(l-1))}, if} \\indented{1}{\\spad{(r1+..+r(l-1)) < \\spad{i} \\spad{<=} r1+..+rl} and} \\indented{1}{\\spad{(c1+..+c(l-1)) < \\spad{i} \\spad{<=} c1+..+cl},} \\indented{1}{\\spad{m.i.j} = 0\\space{2}otherwise.} \\blankline \\spad{X} diagonalMatrix [matrix [[1,2],[3,4]], matrix [[4,5],[6,7]]]" + +--->-->MatrixCategory&((coerce (% Col))): Improper first word in comments: +"\\indented{1}{\\spad{coerce(col)} converts the column col to a column matrix.} \\blankline \\spad{X} coerce([1,2,3])@Matrix(INT)" + +--->-->MatrixCategory&((transpose (% Row))): Improper first word in comments: +"\\indented{1}{\\spad{transpose(r)} converts the row \\spad{r} to a row matrix.} \\blankline \\spad{X} transpose([1,2,3])@Matrix(INT)" + +--->-->MatrixCategory&((transpose (% %))): Improper first word in comments: +"\\indented{1}{\\spad{transpose(m)} returns the transpose of the matrix \\spad{m.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} transpose \\spad{m}" + +--->-->MatrixCategory&((squareTop (% %))): Improper first word in comments: +"\\indented{1}{\\spad{squareTop(m)} returns an n-by-n matrix consisting of the first} \\indented{1}{n rows of the m-by-n matrix \\spad{m.} Error: if} \\indented{1}{\\spad{m < n}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..2] for \\spad{j} in 1..5] \\spad{X} squareTop \\spad{m}" + +--->-->MatrixCategory&((horizConcat (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{horizConcat(x,y)} horizontally concatenates two matrices with} \\indented{1}{an equal number of rows. The entries of \\spad{y} appear to the right} \\indented{1}{of the entries of x.\\space{2}Error: if the matrices} \\indented{1}{do not have the same number of rows.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} horizConcat(m,m)" + +--->-->MatrixCategory&((vertConcat (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{vertConcat(x,y)} vertically concatenates two matrices with an} \\indented{1}{equal number of columns. The entries of \\spad{y} appear below} \\indented{1}{of the entries of x.\\space{2}Error: if the matrices} \\indented{1}{do not have the same number of columns.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} vertConcat(m,m)" + +--->-->MatrixCategory&((listOfLists ((List (List R)) %))): Improper first word in comments: +"\\indented{1}{\\spad{listOfLists(m)} returns the rows of the matrix \\spad{m} as a list} \\indented{1}{of lists.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} listOfLists \\spad{m}" + +--->-->MatrixCategory&((elt (% % (List (Integer)) (List (Integer))))): Improper first word in comments: +"\\indented{1}{\\spad{elt(x,rowList,colList)} returns an m-by-n matrix consisting} \\indented{1}{of elements of \\spad{x,} where \\spad{m = \\# rowList} and \\spad{n = \\# colList}} \\indented{1}{If \\spad{rowList = [i<1>,i<2>,...,i]} and \\spad{colList \\spad{=}} \\indented{1}{[j<1>,j<2>,...,j]}, then the \\spad{(k,l)}th entry of} \\indented{1}{\\spad{elt(x,rowList,colList)} is \\spad{x(i,j)}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} elt(m,3,3)" + +--->-->MatrixCategory&((setelt (% % (List (Integer)) (List (Integer)) %))): Improper first word in comments: +"\\indented{1}{\\spad{setelt(x,rowList,colList,y)} destructively alters the matrix \\spad{x.}} \\indented{1}{If \\spad{y} is \\spad{m}-by-\\spad{n}, \\spad{rowList = [i<1>,i<2>,...,i]}} \\indented{1}{and \\spad{colList = [j<1>,j<2>,...,j]}, then \\spad{x(i,j)}} \\indented{1}{is set to \\spad{y(k,l)} for \\spad{k = 1,...,m} and \\spad{l = 1,...,n}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} setelt(m,3,3,10)" + +--->-->MatrixCategory&((swapRows! (% % (Integer) (Integer)))): Improper first word in comments: +"\\indented{1}{\\spad{swapRows!(m,i,j)} interchanges the \\spad{i}th and \\spad{j}th} \\indented{1}{rows of \\spad{m.} This destructively alters the matrix.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} swapRows!(m,2,4)" + +--->-->MatrixCategory&((swapColumns! (% % (Integer) (Integer)))): Improper first word in comments: +"\\indented{1}{\\spad{swapColumns!(m,i,j)} interchanges the \\spad{i}th and \\spad{j}th} \\indented{1}{columns of \\spad{m.} This destructively alters the matrix.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} swapColumns!(m,2,4)" + +--->-->MatrixCategory&((subMatrix (% % (Integer) (Integer) (Integer) (Integer)))): Improper first word in comments: +"\\indented{1}{\\spad{subMatrix(x,i1,i2,j1,j2)} extracts the submatrix} \\indented{1}{\\spad{[x(i,j)]} where the index \\spad{i} ranges from \\spad{i1} to \\spad{i2}} \\indented{1}{and the index \\spad{j} ranges from \\spad{j1} to \\spad{j2}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} subMatrix(m,1,3,2,4)" + +--->-->MatrixCategory&((setsubMatrix! (% % (Integer) (Integer) %))): Improper first word in comments: +"\\indented{1}{\\spad{setsubMatrix(x,i1,j1,y)} destructively alters the} \\indented{1}{matrix \\spad{x.} Here \\spad{x(i,j)} is set to \\spad{y(i-i1+1,j-j1+1)} for} \\indented{1}{\\spad{i = i1,...,i1-1+nrows \\spad{y}} and \\spad{j = j1,...,j1-1+ncols y}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} setsubMatrix!(m,2,2,matrix [[3,3],[3,3]])" + +--->-->MatrixCategory&((+ (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{x + \\spad{y}} is the sum of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m+m}" + +--->-->MatrixCategory&((- (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{x - \\spad{y}} is the difference of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m-m}" + +--->-->MatrixCategory&((- (% %))): Improper first word in comments: +"\\indented{1}{\\spad{-x} returns the negative of the matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{-m}" + +--->-->MatrixCategory&((* (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{x * \\spad{y}} is the product of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m*m}" + +--->-->MatrixCategory&((* (% R %))): Improper first word in comments: +"\\indented{1}{\\spad{r*x} is the left scalar multiple of the scalar \\spad{r} and the} \\indented{1}{matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} 1/3*m" + +--->-->MatrixCategory&((* (% % R))): Improper first word in comments: +"\\indented{1}{\\spad{x * \\spad{r}} is the right scalar multiple of the scalar \\spad{r} and the} \\indented{1}{matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m*1/3}" + +--->-->MatrixCategory&((* (% (Integer) %))): Improper first word in comments: +"\\indented{1}{\\spad{n * \\spad{x}} is an integer multiple.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} 3*m" + +--->-->MatrixCategory&((* (Col % Col))): Improper first word in comments: +"\\indented{1}{\\spad{x * \\spad{c}} is the product of the matrix \\spad{x} and the column vector \\spad{c.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} c:=coerce([1,2,3,4,5])@Matrix(INT) \\spad{X} \\spad{m*c}" + +--->-->MatrixCategory&((* (Row Row %))): Improper first word in comments: +"\\indented{1}{\\spad{r * \\spad{x}} is the product of the row vector \\spad{r} and the matrix \\spad{x.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} r:=transpose([1,2,3,4,5])@Matrix(INT) \\spad{X} \\spad{r*m}" + +--->-->MatrixCategory&((** (% % (NonNegativeInteger)))): Improper first word in comments: +"\\indented{1}{\\spad{x \\spad{**} \\spad{n}} computes a non-negative integral power of the matrix \\spad{x.}} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m**3}" + +--->-->MatrixCategory&((exquo ((Union % failed) % R))): Improper first word in comments: +"\\indented{1}{\\spad{exquo(m,r)} computes the exact quotient of the elements} \\indented{1}{of \\spad{m} by \\spad{r,} returning \\axiom{\"failed\"} if this is not possible.} \\blankline \\spad{X} m:=matrix [[2**i for \\spad{i} in 2..4] for \\spad{j} in 1..5] \\spad{X} exquo(m,2)" + +--->-->MatrixCategory&((/ (% % R))): Improper first word in comments: +"\\indented{1}{\\spad{m/r} divides the elements of \\spad{m} by \\spad{r.} Error: if \\spad{r = 0}.} \\blankline \\spad{X} m:=matrix [[2**i for \\spad{i} in 2..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m/4}" + +--->-->MatrixCategory&((rowEchelon (% %))): Improper first word in comments: +"\\indented{1}{\\spad{rowEchelon(m)} returns the row echelon form of the matrix \\spad{m.}} \\blankline \\spad{X} rowEchelon matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->-->MatrixCategory&((columnSpace ((List Col) %))): Improper first word in comments: +"\\indented{1}{\\spad{columnSpace(m)} returns a sublist of columns of the matrix \\spad{m}} \\indented{1}{forming a basis of its column space} \\blankline \\spad{X} columnSpace matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]]" + +--->-->MatrixCategory&((rank ((NonNegativeInteger) %))): Improper first word in comments: +"\\indented{1}{\\spad{rank(m)} returns the rank of the matrix \\spad{m.}} \\blankline \\spad{X} rank matrix [[1,2,3],[4,5,6],[7,8,9]]" + +--->-->MatrixCategory&((nullity ((NonNegativeInteger) %))): Improper first word in comments: +"\\indented{1}{\\spad{nullity(m)} returns the nullity of the matrix \\spad{m.} This is} \\indented{1}{the dimension of the null space of the matrix \\spad{m.}} \\blankline \\spad{X} nullity matrix [[1,2,3],[4,5,6],[7,8,9]]" + +--->-->MatrixCategory&((nullSpace ((List Col) %))): Improper first word in comments: +"\\indented{1}{\\spad{nullSpace(m)} returns a basis for the null space of} \\indented{1}{the matrix \\spad{m.}} \\blankline \\spad{X} nullSpace matrix [[1,2,3],[4,5,6],[7,8,9]]" + +--->-->MatrixCategory&((determinant (R %))): Improper first word in comments: +"\\indented{1}{\\spad{determinant(m)} returns the determinant of the matrix \\spad{m.}} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} determinant matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->-->MatrixCategory&((minordet (R %))): Improper first word in comments: +"\\indented{1}{\\spad{minordet(m)} computes the determinant of the matrix \\spad{m} using} \\indented{1}{minors. Error: if the matrix is not square.} \\blankline \\spad{X} minordet matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->-->MatrixCategory&((pfaffian (R %))): Improper first word in comments: +"\\indented{1}{\\spad{pfaffian(m)} returns the Pfaffian of the matrix \\spad{m.}} \\indented{1}{Error if the matrix is not antisymmetric} \\blankline \\spad{X} pfaffian [[0,1,0,0],[-1,0,0,0],[0,0,0,1],[0,0,-1,0]]" + +--->-->MatrixCategory&((inverse ((Union % failed) %))): Improper first word in comments: +"\\indented{1}{\\spad{inverse(m)} returns the inverse of the matrix \\spad{m.}} \\indented{1}{If the matrix is not invertible, \"failed\" is returned.} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} inverse matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->-->MatrixCategory&((** (% % (Integer)))): Improper first word in comments: +"\\indented{1}{\\spad{m**n} computes an integral power of the matrix \\spad{m.}} \\indented{1}{Error: if matrix is not square or if the matrix} \\indented{1}{is square but not invertible.} \\blankline \\spad{X} (matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]) \\spad{**} 2" + +--->bookvol10.2.pamphlet-->MatrixCategory((square? ((Boolean) %))): Improper first word in comments: +"\\indented{1}{\\spad{square?(m)} returns \\spad{true} if \\spad{m} is a square matrix} \\indented{1}{(if \\spad{m} has the same number of rows as columns) and \\spad{false} otherwise.} \\blankline \\spad{X} square matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->bookvol10.2.pamphlet-->MatrixCategory((diagonal? ((Boolean) %))): Improper first word in comments: +--->bookvol10.2.pamphlet-->MatrixCategory((diagonal? ((Boolean) %))): Mismatch: left pren matches right brace +"\\indented{1}{\\spad{diagonal?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{diagonal (\\spadignore{i.e.} all entries of \\spad{m} not on the diagonal are zero) and} \\indented{1}{false otherwise.} \\blankline \\spad{X} diagonal? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->bookvol10.2.pamphlet-->MatrixCategory((symmetric? ((Boolean) %))): Improper first word in comments: +--->bookvol10.2.pamphlet-->MatrixCategory((symmetric? ((Boolean) %))): Mismatch: left pren matches right brace +"\\indented{1}{\\spad{symmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{symmetric (\\spadignore{i.e.} \\spad{m[i,j] = m[j,i]} for all \\spad{i} and \\spad{j)} and false} \\indented{1}{otherwise.} \\blankline \\spad{X} symmetric? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->bookvol10.2.pamphlet-->MatrixCategory((antisymmetric? ((Boolean) %))): Improper first word in comments: +--->bookvol10.2.pamphlet-->MatrixCategory((antisymmetric? ((Boolean) %))): Mismatch: left pren matches right brace +"\\indented{1}{\\spad{antisymmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and} \\indented{1}{antisymmetric (\\spadignore{i.e.} \\spad{m[i,j] = -m[j,i]} for all \\spad{i} and \\spad{j)}} \\indented{1}{and \\spad{false} otherwise.} \\blankline \\spad{X} antisymmetric? matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->bookvol10.2.pamphlet-->MatrixCategory((zero (% (NonNegativeInteger) (NonNegativeInteger)))): Improper first word in comments: +"\\indented{1}{\\spad{zero(m,n)} returns an m-by-n zero matrix.} \\blankline \\spad{X} z:Matrix(INT):=zero(3,3)" + +--->bookvol10.2.pamphlet-->MatrixCategory((matrix (% (List (List R))))): Improper first word in comments: +"\\indented{1}{\\spad{matrix(l)} converts the list of lists \\spad{l} to a matrix, where the} \\indented{1}{list of lists is viewed as a list of the rows of the matrix.} \\blankline \\spad{X} matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]]" + +--->bookvol10.2.pamphlet-->MatrixCategory((matrix (% (NonNegativeInteger) (NonNegativeInteger) (Mapping R (Integer) (Integer))))): Improper first word in comments: +"\\indented{1}{\\spad{matrix(n,m,f)} constructs an \\spad{n * \\spad{m}} matrix with} \\indented{1}{the \\spad{(i,j)} entry equal to \\spad{f(i,j)}} \\blankline \\spad{X} f(i:INT,j:INT):INT \\spad{==} i+j \\spad{X} matrix(3,4,f)" + +--->bookvol10.2.pamphlet-->MatrixCategory((scalarMatrix (% (NonNegativeInteger) R))): Improper first word in comments: +"\\indented{1}{\\spad{scalarMatrix(n,r)} returns an n-by-n matrix with \\spad{r's} on the} \\indented{1}{diagonal and zeroes elsewhere.} \\blankline \\spad{X} z:Matrix(INT):=scalarMatrix(3,5)" + +--->bookvol10.2.pamphlet-->MatrixCategory((diagonalMatrix (% (List R)))): Improper first word in comments: +"\\indented{1}{\\spad{diagonalMatrix(l)} returns a diagonal matrix with the elements} \\indented{1}{of \\spad{l} on the diagonal.} \\blankline \\spad{X} diagonalMatrix [1,2,3]" + +--->bookvol10.2.pamphlet-->MatrixCategory((diagonalMatrix (% (List %)))): Improper first word in comments: +"\\indented{1}{\\spad{diagonalMatrix([m1,...,mk])} creates a block diagonal matrix} \\indented{1}{M with block matrices m1,...,mk down the diagonal,} \\indented{1}{with 0 block matrices elsewhere.} \\indented{1}{More precisly: if \\spad{ri \\spad{:=} nrows mi}, \\spad{ci \\spad{:=} ncols mi},} \\indented{1}{then \\spad{m} is an (r1+..+rk) by (c1+..+ck) - matrix\\space{2}with entries} \\indented{1}{\\spad{m.i.j = ml.(i-r1-..-r(l-1)).(j-n1-..-n(l-1))}, if} \\indented{1}{\\spad{(r1+..+r(l-1)) < \\spad{i} \\spad{<=} r1+..+rl} and} \\indented{1}{\\spad{(c1+..+c(l-1)) < \\spad{i} \\spad{<=} c1+..+cl},} \\indented{1}{\\spad{m.i.j} = 0\\space{2}otherwise.} \\blankline \\spad{X} diagonalMatrix [matrix [[1,2],[3,4]], matrix [[4,5],[6,7]]]" + +--->bookvol10.2.pamphlet-->MatrixCategory((coerce (% Col))): Improper first word in comments: +"\\indented{1}{\\spad{coerce(col)} converts the column col to a column matrix.} \\blankline \\spad{X} coerce([1,2,3])@Matrix(INT)" + +--->bookvol10.2.pamphlet-->MatrixCategory((transpose (% Row))): Improper first word in comments: +"\\indented{1}{\\spad{transpose(r)} converts the row \\spad{r} to a row matrix.} \\blankline \\spad{X} transpose([1,2,3])@Matrix(INT)" + +--->bookvol10.2.pamphlet-->MatrixCategory((transpose (% %))): Improper first word in comments: +"\\indented{1}{\\spad{transpose(m)} returns the transpose of the matrix \\spad{m.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} transpose \\spad{m}" + +--->bookvol10.2.pamphlet-->MatrixCategory((squareTop (% %))): Improper first word in comments: +"\\indented{1}{\\spad{squareTop(m)} returns an n-by-n matrix consisting of the first} \\indented{1}{n rows of the m-by-n matrix \\spad{m.} Error: if} \\indented{1}{\\spad{m < n}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..2] for \\spad{j} in 1..5] \\spad{X} squareTop \\spad{m}" + +--->bookvol10.2.pamphlet-->MatrixCategory((horizConcat (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{horizConcat(x,y)} horizontally concatenates two matrices with} \\indented{1}{an equal number of rows. The entries of \\spad{y} appear to the right} \\indented{1}{of the entries of x.\\space{2}Error: if the matrices} \\indented{1}{do not have the same number of rows.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} horizConcat(m,m)" + +--->bookvol10.2.pamphlet-->MatrixCategory((vertConcat (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{vertConcat(x,y)} vertically concatenates two matrices with an} \\indented{1}{equal number of columns. The entries of \\spad{y} appear below} \\indented{1}{of the entries of x.\\space{2}Error: if the matrices} \\indented{1}{do not have the same number of columns.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} vertConcat(m,m)" + +--->bookvol10.2.pamphlet-->MatrixCategory((listOfLists ((List (List R)) %))): Improper first word in comments: +"\\indented{1}{\\spad{listOfLists(m)} returns the rows of the matrix \\spad{m} as a list} \\indented{1}{of lists.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} listOfLists \\spad{m}" + +--->bookvol10.2.pamphlet-->MatrixCategory((elt (% % (List (Integer)) (List (Integer))))): Improper first word in comments: +"\\indented{1}{\\spad{elt(x,rowList,colList)} returns an m-by-n matrix consisting} \\indented{1}{of elements of \\spad{x,} where \\spad{m = \\# rowList} and \\spad{n = \\# colList}} \\indented{1}{If \\spad{rowList = [i<1>,i<2>,...,i]} and \\spad{colList \\spad{=}} \\indented{1}{[j<1>,j<2>,...,j]}, then the \\spad{(k,l)}th entry of} \\indented{1}{\\spad{elt(x,rowList,colList)} is \\spad{x(i,j)}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} elt(m,3,3)" + +--->bookvol10.2.pamphlet-->MatrixCategory((setelt (% % (List (Integer)) (List (Integer)) %))): Improper first word in comments: +"\\indented{1}{\\spad{setelt(x,rowList,colList,y)} destructively alters the matrix \\spad{x.}} \\indented{1}{If \\spad{y} is \\spad{m}-by-\\spad{n}, \\spad{rowList = [i<1>,i<2>,...,i]}} \\indented{1}{and \\spad{colList = [j<1>,j<2>,...,j]}, then \\spad{x(i,j)}} \\indented{1}{is set to \\spad{y(k,l)} for \\spad{k = 1,...,m} and \\spad{l = 1,...,n}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} setelt(m,3,3,10)" + +--->bookvol10.2.pamphlet-->MatrixCategory((swapRows! (% % (Integer) (Integer)))): Improper first word in comments: +"\\indented{1}{\\spad{swapRows!(m,i,j)} interchanges the \\spad{i}th and \\spad{j}th} \\indented{1}{rows of \\spad{m.} This destructively alters the matrix.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} swapRows!(m,2,4)" + +--->bookvol10.2.pamphlet-->MatrixCategory((swapColumns! (% % (Integer) (Integer)))): Improper first word in comments: +"\\indented{1}{\\spad{swapColumns!(m,i,j)} interchanges the \\spad{i}th and \\spad{j}th} \\indented{1}{columns of \\spad{m.} This destructively alters the matrix.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} swapColumns!(m,2,4)" + +--->bookvol10.2.pamphlet-->MatrixCategory((subMatrix (% % (Integer) (Integer) (Integer) (Integer)))): Improper first word in comments: +"\\indented{1}{\\spad{subMatrix(x,i1,i2,j1,j2)} extracts the submatrix} \\indented{1}{\\spad{[x(i,j)]} where the index \\spad{i} ranges from \\spad{i1} to \\spad{i2}} \\indented{1}{and the index \\spad{j} ranges from \\spad{j1} to \\spad{j2}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} subMatrix(m,1,3,2,4)" + +--->bookvol10.2.pamphlet-->MatrixCategory((setsubMatrix! (% % (Integer) (Integer) %))): Improper first word in comments: +"\\indented{1}{\\spad{setsubMatrix(x,i1,j1,y)} destructively alters the} \\indented{1}{matrix \\spad{x.} Here \\spad{x(i,j)} is set to \\spad{y(i-i1+1,j-j1+1)} for} \\indented{1}{\\spad{i = i1,...,i1-1+nrows \\spad{y}} and \\spad{j = j1,...,j1-1+ncols y}.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} setsubMatrix!(m,2,2,matrix [[3,3],[3,3]])" + +--->bookvol10.2.pamphlet-->MatrixCategory((+ (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{x + \\spad{y}} is the sum of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m+m}" + +--->bookvol10.2.pamphlet-->MatrixCategory((- (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{x - \\spad{y}} is the difference of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m-m}" + +--->bookvol10.2.pamphlet-->MatrixCategory((- (% %))): Improper first word in comments: +"\\indented{1}{\\spad{-x} returns the negative of the matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{-m}" + +--->bookvol10.2.pamphlet-->MatrixCategory((* (% % %))): Improper first word in comments: +"\\indented{1}{\\spad{x * \\spad{y}} is the product of the matrices \\spad{x} and \\spad{y.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m*m}" + +--->bookvol10.2.pamphlet-->MatrixCategory((* (% R %))): Improper first word in comments: +"\\indented{1}{\\spad{r*x} is the left scalar multiple of the scalar \\spad{r} and the} \\indented{1}{matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} 1/3*m" + +--->bookvol10.2.pamphlet-->MatrixCategory((* (% % R))): Improper first word in comments: +"\\indented{1}{\\spad{x * \\spad{r}} is the right scalar multiple of the scalar \\spad{r} and the} \\indented{1}{matrix \\spad{x.}} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m*1/3}" + +--->bookvol10.2.pamphlet-->MatrixCategory((* (% (Integer) %))): Improper first word in comments: +"\\indented{1}{\\spad{n * \\spad{x}} is an integer multiple.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} 3*m" + +--->bookvol10.2.pamphlet-->MatrixCategory((* (Col % Col))): Improper first word in comments: +"\\indented{1}{\\spad{x * \\spad{c}} is the product of the matrix \\spad{x} and the column vector \\spad{c.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} c:=coerce([1,2,3,4,5])@Matrix(INT) \\spad{X} \\spad{m*c}" + +--->bookvol10.2.pamphlet-->MatrixCategory((* (Row Row %))): Improper first word in comments: +"\\indented{1}{\\spad{r * \\spad{x}} is the product of the row vector \\spad{r} and the matrix \\spad{x.}} \\indented{1}{Error: if the dimensions are incompatible.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} r:=transpose([1,2,3,4,5])@Matrix(INT) \\spad{X} \\spad{r*m}" + +--->bookvol10.2.pamphlet-->MatrixCategory((** (% % (NonNegativeInteger)))): Improper first word in comments: +"\\indented{1}{\\spad{x \\spad{**} \\spad{n}} computes a non-negative integral power of the matrix \\spad{x.}} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} m:=matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m**3}" + +--->bookvol10.2.pamphlet-->MatrixCategory((exquo ((Union % failed) % R))): Improper first word in comments: +"\\indented{1}{\\spad{exquo(m,r)} computes the exact quotient of the elements} \\indented{1}{of \\spad{m} by \\spad{r,} returning \\axiom{\"failed\"} if this is not possible.} \\blankline \\spad{X} m:=matrix [[2**i for \\spad{i} in 2..4] for \\spad{j} in 1..5] \\spad{X} exquo(m,2)" + +--->bookvol10.2.pamphlet-->MatrixCategory((/ (% % R))): Improper first word in comments: +"\\indented{1}{\\spad{m/r} divides the elements of \\spad{m} by \\spad{r.} Error: if \\spad{r = 0}.} \\blankline \\spad{X} m:=matrix [[2**i for \\spad{i} in 2..4] for \\spad{j} in 1..5] \\spad{X} \\spad{m/4}" + +--->bookvol10.2.pamphlet-->MatrixCategory((rowEchelon (% %))): Improper first word in comments: +"\\indented{1}{\\spad{rowEchelon(m)} returns the row echelon form of the matrix \\spad{m.}} \\blankline \\spad{X} rowEchelon matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->bookvol10.2.pamphlet-->MatrixCategory((columnSpace ((List Col) %))): Improper first word in comments: +"\\indented{1}{\\spad{columnSpace(m)} returns a sublist of columns of the matrix \\spad{m}} \\indented{1}{forming a basis of its column space} \\blankline \\spad{X} columnSpace matrix [[1,2,3],[4,5,6],[7,8,9],[1,1,1]]" + +--->bookvol10.2.pamphlet-->MatrixCategory((rank ((NonNegativeInteger) %))): Improper first word in comments: +"\\indented{1}{\\spad{rank(m)} returns the rank of the matrix \\spad{m.}} \\blankline \\spad{X} rank matrix [[1,2,3],[4,5,6],[7,8,9]]" + +--->bookvol10.2.pamphlet-->MatrixCategory((nullity ((NonNegativeInteger) %))): Improper first word in comments: +"\\indented{1}{\\spad{nullity(m)} returns the nullity of the matrix \\spad{m.} This is} \\indented{1}{the dimension of the null space of the matrix \\spad{m.}} \\blankline \\spad{X} nullity matrix [[1,2,3],[4,5,6],[7,8,9]]" + +--->bookvol10.2.pamphlet-->MatrixCategory((nullSpace ((List Col) %))): Improper first word in comments: +"\\indented{1}{\\spad{nullSpace(m)} returns a basis for the null space of} \\indented{1}{the matrix \\spad{m.}} \\blankline \\spad{X} nullSpace matrix [[1,2,3],[4,5,6],[7,8,9]]" + +--->bookvol10.2.pamphlet-->MatrixCategory((determinant (R %))): Improper first word in comments: +"\\indented{1}{\\spad{determinant(m)} returns the determinant of the matrix \\spad{m.}} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} determinant matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->bookvol10.2.pamphlet-->MatrixCategory((minordet (R %))): Improper first word in comments: +"\\indented{1}{\\spad{minordet(m)} computes the determinant of the matrix \\spad{m} using} \\indented{1}{minors. Error: if the matrix is not square.} \\blankline \\spad{X} minordet matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->bookvol10.2.pamphlet-->MatrixCategory((pfaffian (R %))): Improper first word in comments: +"\\indented{1}{\\spad{pfaffian(m)} returns the Pfaffian of the matrix \\spad{m.}} \\indented{1}{Error if the matrix is not antisymmetric} \\blankline \\spad{X} pfaffian [[0,1,0,0],[-1,0,0,0],[0,0,0,1],[0,0,-1,0]]" + +--->bookvol10.2.pamphlet-->MatrixCategory((inverse ((Union % failed) %))): Improper first word in comments: +"\\indented{1}{\\spad{inverse(m)} returns the inverse of the matrix \\spad{m.}} \\indented{1}{If the matrix is not invertible, \"failed\" is returned.} \\indented{1}{Error: if the matrix is not square.} \\blankline \\spad{X} inverse matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]" + +--->bookvol10.2.pamphlet-->MatrixCategory((** (% % (Integer)))): Improper first word in comments: +"\\indented{1}{\\spad{m**n} computes an integral power of the matrix \\spad{m.}} \\indented{1}{Error: if matrix is not square or if the matrix} \\indented{1}{is square but not invertible.} \\blankline \\spad{X} (matrix [[j**i for \\spad{i} in 0..4] for \\spad{j} in 1..5]) \\spad{**} 2" + +========================================================================= +typos 40268: + +>compiling VECTCAT.spad to VECTCAT.nrlib + +--->-->VectorCategory&((cross (% % %))): Improper first word in comments: vectorProduct +"vectorProduct(u,v) constructs the cross product of \\spad{u} and \\spad{v.} Error: if \\spad{u} and \\spad{v} are not of length 3." + +--->-->VectorCategory&((length (R %))): Missing left brace +"\\spad{length(v)} computes the sqrt(dot(v,v)), \\spadignore{i.e.} the magnitude" + +--->-->VectorCategory&((magnitude (R %))): Missing left brace +"\\spad{magnitude(v)} computes the sqrt(dot(v,v)), \\spadignore{i.e.} the length" + +--->-->VectorCategory&(constructor): Missing left brace +"\\spadtype{VectorCategory} represents the type of vector like objects, \\spadignore{i.e.} finite sequences indexed by some finite segment of the integers. The operations available on vectors depend on the structure of the underlying components. Many operations from the component domain are defined for vectors componentwise. It can by assumed that extraction or updating components can be done in constant time." + +--->bookvol10.2.pamphlet-->VectorCategory((cross (% % %))): Improper first word in comments: vectorProduct +"vectorProduct(u,v) constructs the cross product of \\spad{u} and \\spad{v.} Error: if \\spad{u} and \\spad{v} are not of length 3." + +--->bookvol10.2.pamphlet-->VectorCategory((length (R %))): Missing left brace +"\\spad{length(v)} computes the sqrt(dot(v,v)), \\spadignore{i.e.} the magnitude" + +--->bookvol10.2.pamphlet-->VectorCategory((magnitude (R %))): Missing left brace +"\\spad{magnitude(v)} computes the sqrt(dot(v,v)), \\spadignore{i.e.} the length" + +--->bookvol10.2.pamphlet-->VectorCategory(constructor): Missing left brace + +========================================================================= +typos 40257: + +>compiling DIRPCAT.spad to DIRPCAT.nrlib + +--->-->DirectProductCategory&(): Spurious comments: \spad{y*r} multiplies each component of the vector \spad{y} by the element \spad{r.} + +--------constructor--------- +--->bookvol10.2.pamphlet-->DirectProductCategory(): Spurious comments: \spad{y*r} multiplies each component of the vector \spad{y} by the element \spad{r.} + +========================================================================= +typos 40253: + +>compiling FAXF.spad to FAXF.nrlib + +--->-->FiniteAlgebraicExtensionField&((normalElement ($))): Missing left brace +"\\spad{normalElement()} returns a element, normal over the ground field \\spad{F,} \\spadignore{i.e.} \\spad{a**(q**i), 0 \\spad{<=} \\spad{i} < extensionDegree()} is an F-basis, where \\spad{q = size()\\$F}. At the first call, the element is computed by \\spadfunFrom{createNormalElement}{FiniteAlgebraicExtensionField} then cached in a global variable. On subsequent calls, the element is retrieved by referencing the global variable." + +--->-->FiniteAlgebraicExtensionField&((normal? ((Boolean) $))): Missing left brace +"\\spad{normal?(a)} tests whether the element \\spad{a} is normal over the ground field \\spad{F,} \\spadignore{i.e.} \\spad{a**(q**i), 0 \\spad{<=} \\spad{i} \\spad{<=} extensionDegree()-1} is an F-basis, where \\spad{q = size()\\$F}. Implementation according to Lidl/Niederreiter: Theorem 2.39." + +--->-->FiniteAlgebraicExtensionField&((linearAssociatedExp ($ $ (SparseUnivariatePolynomial F)))): Missing left brace +"\\spad{linearAssociatedExp(a,f)} is linear over \\spad{F,} \\spadignore{i.e.} for elements a from \\spad{\\$,} \\spad{c,d} form \\spad{F} and \\spad{f,g} univariate polynomials over \\spad{F} we have \\spadfun{linearAssociatedExp}(a,cf+dg) equals \\spad{c} times \\spadfun{linearAssociatedExp}(a,f) plus \\spad{d} times \\spadfun{linearAssociatedExp}(a,g). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from F[X]: \\spadfun{linearAssociatedExp}(a,monomial(1,k)\\$SUP(F)) is defined to be \\spadfun{Frobenius}(a,k) which is a**(q**k), where q=size()\\$F." + +--->-->FiniteAlgebraicExtensionField&(constructor): Missing left brace +"FiniteAlgebraicExtensionField \\spad{F} is the category of fields which are finite algebraic extensions of the field \\spad{F.} If \\spad{F} is finite then any finite algebraic extension of \\spad{F} is finite, too. Let \\spad{K} be a finite algebraic extension of the finite field \\spad{F.} The exponentiation of elements of \\spad{K} defines a Z-module structure on the multiplicative group of \\spad{K.} The additive group of \\spad{K} becomes a module over the ring of polynomials over \\spad{F} via the operation \\spadfun{linearAssociatedExp}(a:K,f:SparseUnivariatePolynomial \\spad{F)} which is linear over \\spad{F,} \\spadignore{i.e.} for elements a from \\spad{K,} \\spad{c,d} from \\spad{F} and \\spad{f,g} univariate polynomials over \\spad{F} we have \\spadfun{linearAssociatedExp}(a,cf+dg) equals \\spad{c} times \\spadfun{linearAssociatedExp}(a,f) plus \\spad{d} times \\spadfun{linearAssociatedExp}(a,g). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from F[X]: \\spadfun{linearAssociatedExp}(a,monomial(1,k)\\$SUP(F)) is defined to be \\spadfun{Frobenius}(a,k) which is a**(q**k) where q=size()\\$F. The operations order and discreteLog associated with the multiplicative exponentiation have additive analogues associated to the operation \\spadfun{linearAssociatedExp}. These are the functions \\spadfun{linearAssociatedOrder} and \\spadfun{linearAssociatedLog}, respectively." + +--->bookvol10.2.pamphlet-->FiniteAlgebraicExtensionField((normalElement ($))): Missing left brace +"\\spad{normalElement()} returns a element, normal over the ground field \\spad{F,} \\spadignore{i.e.} \\spad{a**(q**i), 0 \\spad{<=} \\spad{i} < extensionDegree()} is an F-basis, where \\spad{q = size()\\$F}. At the first call, the element is computed by \\spadfunFrom{createNormalElement}{FiniteAlgebraicExtensionField} then cached in a global variable. On subsequent calls, the element is retrieved by referencing the global variable." + +--->bookvol10.2.pamphlet-->FiniteAlgebraicExtensionField((normal? ((Boolean) $))): Missing left brace +"\\spad{normal?(a)} tests whether the element \\spad{a} is normal over the ground field \\spad{F,} \\spadignore{i.e.} \\spad{a**(q**i), 0 \\spad{<=} \\spad{i} \\spad{<=} extensionDegree()-1} is an F-basis, where \\spad{q = size()\\$F}. Implementation according to Lidl/Niederreiter: Theorem 2.39." + +--->bookvol10.2.pamphlet-->FiniteAlgebraicExtensionField((linearAssociatedExp ($ $ (SparseUnivariatePolynomial F)))): Missing left brace +"\\spad{linearAssociatedExp(a,f)} is linear over \\spad{F,} \\spadignore{i.e.} for elements a from \\spad{\\$,} \\spad{c,d} form \\spad{F} and \\spad{f,g} univariate polynomials over \\spad{F} we have \\spadfun{linearAssociatedExp}(a,cf+dg) equals \\spad{c} times \\spadfun{linearAssociatedExp}(a,f) plus \\spad{d} times \\spadfun{linearAssociatedExp}(a,g). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from F[X]: \\spadfun{linearAssociatedExp}(a,monomial(1,k)\\$SUP(F)) is defined to be \\spadfun{Frobenius}(a,k) which is a**(q**k), where q=size()\\$F." + +--->bookvol10.2.pamphlet-->FiniteAlgebraicExtensionField(constructor): Missing left brace +"FiniteAlgebraicExtensionField \\spad{F} is the category of fields which are finite algebraic extensions of the field \\spad{F.} If \\spad{F} is finite then any finite algebraic extension of \\spad{F} is finite, too. Let \\spad{K} be a finite algebraic extension of the finite field \\spad{F.} The exponentiation of elements of \\spad{K} defines a Z-module structure on the multiplicative group of \\spad{K.} The additive group of \\spad{K} becomes a module over the ring of polynomials over \\spad{F} via the operation \\spadfun{linearAssociatedExp}(a:K,f:SparseUnivariatePolynomial \\spad{F)} which is linear over \\spad{F,} \\spadignore{i.e.} for elements a from \\spad{K,} \\spad{c,d} from \\spad{F} and \\spad{f,g} univariate polynomials over \\spad{F} we have \\spadfun{linearAssociatedExp}(a,cf+dg) equals \\spad{c} times \\spadfun{linearAssociatedExp}(a,f) plus \\spad{d} times \\spadfun{linearAssociatedExp}(a,g). Therefore \\spadfun{linearAssociatedExp} is defined completely by its action on monomials from F[X]: \\spadfun{linearAssociatedExp}(a,monomial(1,k)\\$SUP(F)) is defined to be \\spadfun{Frobenius}(a,k) which is a**(q**k) where q=size()\\$F. The operations order and discreteLog associated with the multiplicative exponentiation have additive analogues associated to the operation \\spadfun{linearAssociatedExp}. These are the functions \\spadfun{linearAssociatedOrder} and \\spadfun{linearAssociatedLog}, respectively." + +========================================================================= +typos 40222: + +>compiling FINAALG.spad to FINAALG.nrlib + +--->-->FiniteRankNonAssociativeAlgebra&((antiAssociative? ((Boolean)))): Missing left brace +"\\spad{antiAssociative?()} tests if multiplication in algebra is anti-associative, \\spadignore{i.e.} \\spad{(a*b)*c + a*(b*c) = 0} for all \\spad{a},b,c in the algebra." + +--->-->FiniteRankNonAssociativeAlgebra&((lieAdmissible? ((Boolean)))): Missing left brace +"\\spad{lieAdmissible?()} tests if the algebra defined by the commutators is a Lie algebra, \\spadignore{i.e.} satisfies the Jacobi identity. The property of anticommutativity follows from definition." + +--->-->FiniteRankNonAssociativeAlgebra&((jordanAdmissible? ((Boolean)))): Missing left brace +"\\spad{jordanAdmissible?()} tests if 2 is invertible in the coefficient domain and the multiplication defined by \\spad{(1/2)(a*b+b*a)} determines a Jordan algebra, \\spadignore{i.e.} satisfies the Jordan identity. The property of \\spadatt{commutative(\"*\")} follows from by definition." + +--->-->FiniteRankNonAssociativeAlgebra&((associatorDependence ((List (Vector R))))): Missing left brace +"\\spad{associatorDependence()} looks for the associator identities, \\spadignore{i.e.} finds a basis of the solutions of the linear combinations of the six permutations of \\spad{associator(a,b,c)} which yield 0, for all \\spad{a},b,c in the algebra. The order of the permutations is \\spad{123 231 312 132 321 213}." + +--->bookvol10.2.pamphlet-->FiniteRankNonAssociativeAlgebra((antiAssociative? ((Boolean)))): Missing left brace +"\\spad{antiAssociative?()} tests if multiplication in algebra is anti-associative, \\spadignore{i.e.} \\spad{(a*b)*c + a*(b*c) = 0} for all \\spad{a},b,c in the algebra." + +--->bookvol10.2.pamphlet-->FiniteRankNonAssociativeAlgebra((lieAdmissible? ((Boolean)))): Missing left brace +"\\spad{lieAdmissible?()} tests if the algebra defined by the commutators is a Lie algebra, \\spadignore{i.e.} satisfies the Jacobi identity. The property of anticommutativity follows from definition." + +--->bookvol10.2.pamphlet-->FiniteRankNonAssociativeAlgebra((jordanAdmissible? ((Boolean)))): Missing left brace +"\\spad{jordanAdmissible?()} tests if 2 is invertible in the coefficient domain and the multiplication defined by \\spad{(1/2)(a*b+b*a)} determines a Jordan algebra, \\spadignore{i.e.} satisfies the Jordan identity. The property of \\spadatt{commutative(\"*\")} follows from by definition." + +--->bookvol10.2.pamphlet-->FiniteRankNonAssociativeAlgebra((associatorDependence ((List (Vector R))))): Missing left brace +"\\spad{associatorDependence()} looks for the associator identities, \\spadignore{i.e.} finds a basis of the solutions of the linear combinations of the six permutations of \\spad{associator(a,b,c)} which yield 0, for all \\spad{a},b,c in the algebra. The order of the permutations is \\spad{123 231 312 132 321 213}." + +========================================================================= +typos 40183: + +>compiling RMATCAT.spad to RMATCAT.nrlib + +--->-->RectangularMatrixCategory&((square? ((Boolean) %))): Mismatch: left pren matches right brace +"\\spad{square?(m)} returns \\spad{true} if \\spad{m} is a square matrix (\\spadignore{i.e.} if \\spad{m} has the same number of rows as columns) and \\spad{false} otherwise." + +--->-->RectangularMatrixCategory&((diagonal? ((Boolean) %))): Mismatch: left pren matches right brace +"\\spad{diagonal?(m)} returns \\spad{true} if the matrix \\spad{m} is square and diagonal (\\spadignore{i.e.} all entries of \\spad{m} not on the diagonal are zero) and \\spad{false} otherwise." + +--->-->RectangularMatrixCategory&((symmetric? ((Boolean) %))): Mismatch: left pren matches right brace +"\\spad{symmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and symmetric (\\spadignore{i.e.} \\spad{m[i,j] = m[j,i]} for all \\spad{i} and \\spad{j)} and \\spad{false} otherwise." + +--->-->RectangularMatrixCategory&((antisymmetric? ((Boolean) %))): Mismatch: left pren matches right brace +"\\spad{antisymmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and antisymmetric (\\spadignore{i.e.} \\spad{m[i,j] = -m[j,i]} for all \\spad{i} and \\spad{j)} and \\spad{false} otherwise." + +--->bookvol10.2.pamphlet-->RectangularMatrixCategory((square? ((Boolean) %))): Mismatch: left pren matches right brace +"\\spad{square?(m)} returns \\spad{true} if \\spad{m} is a square matrix (\\spadignore{i.e.} if \\spad{m} has the same number of rows as columns) and \\spad{false} otherwise." + +--->bookvol10.2.pamphlet-->RectangularMatrixCategory((diagonal? ((Boolean) %))): Mismatch: left pren matches right brace +"\\spad{diagonal?(m)} returns \\spad{true} if the matrix \\spad{m} is square and diagonal (\\spadignore{i.e.} all entries of \\spad{m} not on the diagonal are zero) and \\spad{false} otherwise." + +--->bookvol10.2.pamphlet-->RectangularMatrixCategory((symmetric? ((Boolean) %))): Mismatch: left pren matches right brace +"\\spad{symmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and symmetric (\\spadignore{i.e.} \\spad{m[i,j] = m[j,i]} for all \\spad{i} and \\spad{j)} and \\spad{false} otherwise." + +--->bookvol10.2.pamphlet-->RectangularMatrixCategory((antisymmetric? ((Boolean) %))): Mismatch: left pren matches right brace +"\\spad{antisymmetric?(m)} returns \\spad{true} if the matrix \\spad{m} is square and antisymmetric (\\spadignore{i.e.} \\spad{m[i,j] = -m[j,i]} for all \\spad{i} and \\spad{j)} and \\spad{false} otherwise." + +========================================================================= +typos 40155: + +>compiling FSAGG.spad to FSAGG.nrlib + +--->-->FiniteSetAggregate&((complement (% %))): Missing left brace +"\\spad{complement(u)} returns the complement of the set u, \\spadignore{i.e.} the set of all values not in u." + +--->bookvol10.2.pamphlet-->FiniteSetAggregate((complement (% %))): Missing left brace +"\\spad{complement(u)} returns the complement of the set u, \\spadignore{i.e.} the set of all values not in u." + +========================================================================= +typos 40142: + +>compiling TBAGG.spad to TBAGG.nrlib + +--->-->TableAggregate&((table (%))): Improper first word in comments: +"\\indented{1}{table()$T creates an empty table of type \\spad{T.}} \\blankline \\spad{E} Data:=Record(age:Integer,gender:String) \\spad{E} a1:AssociationList(String,Data):=table() \\spad{E} a1.\"tim\":=[55,\"male\"]$Data" + +--->-->TableAggregate&(constructor): Missing left brace +"A table aggregate is a model of a table, \\spadignore{i.e.} a discrete many-to-one mapping from keys to entries." + +--->bookvol10.2.pamphlet-->TableAggregate((table (%))): Improper first word in comments: +"\\indented{1}{table()$T creates an empty table of type \\spad{T.}} \\blankline \\spad{E} Data:=Record(age:Integer,gender:String) \\spad{E} a1:AssociationList(String,Data):=table() \\spad{E} a1.\"tim\":=[55,\"male\"]$Data" + +--->bookvol10.2.pamphlet-->TableAggregate(constructor): Missing left brace +"A table aggregate is a model of a table, \\spadignore{i.e.} a discrete many-to-one mapping from keys to entries." + +========================================================================= +typos 40138: + +>compiling ACF.spad to ACF.nrlib + +--->-->AlgebraicallyClosedField&((rootOf ($ (Polynomial $)))): Improper first word in comments: +"\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)" + +--->-->AlgebraicallyClosedField&((rootOf ($ (SparseUnivariatePolynomial $)))): Improper first word in comments: +"\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)" + +--->-->AlgebraicallyClosedField&((rootOf ($ (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: +"\\indented{1}{rootOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{The object returned displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a,x)" + +--->-->AlgebraicallyClosedField&((rootsOf ((List $) (Polynomial $)))): Improper first word in comments: +"\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the} \\indented{1}{interpreter to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)" + +--->-->AlgebraicallyClosedField&((rootsOf ((List $) (SparseUnivariatePolynomial $)))): Improper first word in comments: +"\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)" + +--->-->AlgebraicallyClosedField&((rootsOf ((List $) (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: +"\\indented{1}{rootsOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0};} \\indented{1}{The returned roots display as \\spad{'y1},...,\\spad{'yn}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a,x)" + +--->-->AlgebraicallyClosedField&((zeroOf ($ (Polynomial $)))): Improper first word in comments: +"\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{If possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zeroOf(a)" + +--->-->AlgebraicallyClosedField&((zeroOf ($ (SparseUnivariatePolynomial $)))): Improper first word in comments: +"\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a)" + +--->-->AlgebraicallyClosedField&((zeroOf ($ (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: +"\\indented{1}{zeroOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity which} \\indented{1}{displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a,x)" + +--->-->AlgebraicallyClosedField&((zerosOf ((List $) (Polynomial $)))): Improper first word in comments: +"\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible.} \\indented{1}{Otherwise they are implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zerosOf(a)" + +--->-->AlgebraicallyClosedField&((zerosOf ((List $) (SparseUnivariatePolynomial $)))): Improper first word in comments: +"\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a)" + +--->-->AlgebraicallyClosedField&((zerosOf ((List $) (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: +"\\indented{1}{zerosOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities} \\indented{1}{which display as \\spad{'yi}.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a,x)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootOf ($ (Polynomial $)))): Improper first word in comments: +"\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootOf ($ (SparseUnivariatePolynomial $)))): Improper first word in comments: +"\\indented{1}{rootOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootOf ($ (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: +"\\indented{1}{rootOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{The object returned displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootOf(a,x)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootsOf ((List $) (Polynomial $)))): Improper first word in comments: +"\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the} \\indented{1}{interpreter to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootsOf ((List $) (SparseUnivariatePolynomial $)))): Improper first word in comments: +"\\indented{1}{rootsOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((rootsOf ((List $) (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: +"\\indented{1}{rootsOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0};} \\indented{1}{The returned roots display as \\spad{'y1},...,\\spad{'yn}.} \\indented{1}{Note that the returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} rootsOf(a,x)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zeroOf ($ (Polynomial $)))): Improper first word in comments: +"\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0}.} \\indented{1}{If possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zeroOf(a)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zeroOf ($ (SparseUnivariatePolynomial $)))): Improper first word in comments: +"\\indented{1}{zeroOf(p) returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zeroOf ($ (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: +"\\indented{1}{zeroOf(p, \\spad{y)} returns \\spad{y} such that \\spad{p(y) = 0};} \\indented{1}{if possible, \\spad{y} is expressed in terms of radicals.} \\indented{1}{Otherwise it is an implicit algebraic quantity which} \\indented{1}{displays as \\spad{'y}.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zeroOf(a,x)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zerosOf ((List $) (Polynomial $)))): Improper first word in comments: +"\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible.} \\indented{1}{Otherwise they are implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\indented{1}{Error: if \\spad{p} has more than one variable \\spad{y.}} \\blankline \\spad{X} \\spad{a:Polynomial(Integer):=-3*x^2+2*x-13} \\spad{X} zerosOf(a)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zerosOf ((List $) (SparseUnivariatePolynomial $)))): Improper first word in comments: +"\\indented{1}{zerosOf(p) returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a)" + +--->bookvol10.2.pamphlet-->AlgebraicallyClosedField((zerosOf ((List $) (SparseUnivariatePolynomial $) (Symbol)))): Improper first word in comments: +"\\indented{1}{zerosOf(p, \\spad{y)} returns \\spad{[y1,...,yn]} such that \\spad{p(yi) = 0}.} \\indented{1}{The yi's are expressed in radicals if possible, and otherwise} \\indented{1}{as implicit algebraic quantities} \\indented{1}{which display as \\spad{'yi}.} \\indented{1}{The returned symbols y1,...,yn are bound in the interpreter} \\indented{1}{to respective root values.} \\blankline \\spad{X} \\spad{a:SparseUnivariatePolynomial(Integer):=-3*x^3+2*x+13} \\spad{X} zerosOf(a,x)" + +========================================================================= +typos 40130: + +>compiling FFCAT.spad to FFCAT.nrlib + +--->-->FunctionFieldCategory&((numberOfComponents ((NonNegativeInteger)))): Improper first word in comments: +"\\indented{1}{numberOfComponents() returns the number of absolutely irreducible} \\indented{1}{components.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} numberOfComponents()$R" + +--->-->FunctionFieldCategory&((genus ((NonNegativeInteger)))): Improper first word in comments: +"\\indented{1}{genus() returns the genus of one absolutely irreducible component} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} genus()$R" + +--->-->FunctionFieldCategory&((absolutelyIrreducible? ((Boolean)))): Improper first word in comments: +"\\indented{1}{absolutelyIrreducible?() tests if the curve absolutely irreducible?} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} \\spad{absolutelyIrreducible?()$R2}" + +--->-->FunctionFieldCategory&((rationalPoint? ((Boolean) F F))): Improper first word in comments: +"\\indented{1}{rationalPoint?(a, \\spad{b)} tests if \\spad{(x=a,y=b)} is on the curve.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} rationalPoint?(0,0)$R \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} \\spad{rationalPoint?(0,0)$R2}" + +--->-->FunctionFieldCategory&((branchPointAtInfinity? ((Boolean)))): Improper first word in comments: +"\\indented{1}{branchPointAtInfinity?() tests if there is a branch point} \\indented{1}{at infinity.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} branchPointAtInfinity?()$R \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} branchPointAtInfinity?()$R" + +--->-->FunctionFieldCategory&((integralBasis ((Vector $)))): Improper first word in comments: +"\\indented{1}{integralBasis() returns the integral basis for the curve.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralBasis()$R" + +--->-->FunctionFieldCategory&((integralBasisAtInfinity ((Vector $)))): Improper first word in comments: +"\\indented{1}{integralBasisAtInfinity() returns the local integral basis} \\indented{1}{at infinity} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralBasisAtInfinity()$R" + +--->-->FunctionFieldCategory&((integralMatrix ((Matrix RF)))): Improper first word in comments: +"\\indented{1}{integralMatrix() returns \\spad{M} such that} \\indented{1}{\\spad{(w1,...,wn) = \\spad{M} \\spad{(1,} \\spad{y,} ..., y**(n-1))},} \\indented{1}{where \\spad{(w1,...,wn)} is the integral basis of} \\indented{1}{\\spadfunFrom{integralBasis}{FunctionFieldCategory}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralMatrix()$R" + +--->-->FunctionFieldCategory&((inverseIntegralMatrix ((Matrix RF)))): Improper first word in comments: +"\\indented{1}{inverseIntegralMatrix() returns \\spad{M} such that} \\indented{1}{\\spad{M (w1,...,wn) = \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(w1,...,wn)} is the integral basis of} \\indented{1}{\\spadfunFrom{integralBasis}{FunctionFieldCategory}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} inverseIntegralMatrix()$R" + +--->-->FunctionFieldCategory&((integralMatrixAtInfinity ((Matrix RF)))): Improper first word in comments: +"\\indented{1}{integralMatrixAtInfinity() returns \\spad{M} such that} \\indented{1}{\\spad{(v1,...,vn) = \\spad{M} \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(v1,...,vn)} is the local integral basis at infinity} \\indented{1}{returned by \\spad{infIntBasis()}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralMatrixAtInfinity()$R" + +--->-->FunctionFieldCategory&((inverseIntegralMatrixAtInfinity ((Matrix RF)))): Improper first word in comments: +"\\indented{1}{inverseIntegralMatrixAtInfinity() returns \\spad{M} such} \\indented{1}{that \\spad{M (v1,...,vn) = \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(v1,...,vn)} is the local integral basis at infinity} \\indented{1}{returned by \\spad{infIntBasis()}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} inverseIntegralMatrixAtInfinity()$R" + +--->-->FunctionFieldCategory&((rationalPoints ((List (List F))))): Improper first word in comments: +"\\indented{1}{rationalPoints() returns the list of all the affine} rational points." + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((numberOfComponents ((NonNegativeInteger)))): Improper first word in comments: +"\\indented{1}{numberOfComponents() returns the number of absolutely irreducible} \\indented{1}{components.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} numberOfComponents()$R" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((genus ((NonNegativeInteger)))): Improper first word in comments: +"\\indented{1}{genus() returns the genus of one absolutely irreducible component} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} genus()$R" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((absolutelyIrreducible? ((Boolean)))): Improper first word in comments: +"\\indented{1}{absolutelyIrreducible?() tests if the curve absolutely irreducible?} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} \\spad{absolutelyIrreducible?()$R2}" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((rationalPoint? ((Boolean) F F))): Improper first word in comments: +"\\indented{1}{rationalPoint?(a, \\spad{b)} tests if \\spad{(x=a,y=b)} is on the curve.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} rationalPoint?(0,0)$R \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} \\spad{rationalPoint?(0,0)$R2}" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((branchPointAtInfinity? ((Boolean)))): Improper first word in comments: +"\\indented{1}{branchPointAtInfinity?() tests if there is a branch point} \\indented{1}{at infinity.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} branchPointAtInfinity?()$R \\spad{X} \\spad{R2} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 2 * x**2, 4) \\spad{X} branchPointAtInfinity?()$R" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((integralBasis ((Vector $)))): Improper first word in comments: +"\\indented{1}{integralBasis() returns the integral basis for the curve.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralBasis()$R" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((integralBasisAtInfinity ((Vector $)))): Improper first word in comments: +"\\indented{1}{integralBasisAtInfinity() returns the local integral basis} \\indented{1}{at infinity} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralBasisAtInfinity()$R" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((integralMatrix ((Matrix RF)))): Improper first word in comments: +"\\indented{1}{integralMatrix() returns \\spad{M} such that} \\indented{1}{\\spad{(w1,...,wn) = \\spad{M} \\spad{(1,} \\spad{y,} ..., y**(n-1))},} \\indented{1}{where \\spad{(w1,...,wn)} is the integral basis of} \\indented{1}{\\spadfunFrom{integralBasis}{FunctionFieldCategory}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralMatrix()$R" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((inverseIntegralMatrix ((Matrix RF)))): Improper first word in comments: +"\\indented{1}{inverseIntegralMatrix() returns \\spad{M} such that} \\indented{1}{\\spad{M (w1,...,wn) = \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(w1,...,wn)} is the integral basis of} \\indented{1}{\\spadfunFrom{integralBasis}{FunctionFieldCategory}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} inverseIntegralMatrix()$R" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((integralMatrixAtInfinity ((Matrix RF)))): Improper first word in comments: +"\\indented{1}{integralMatrixAtInfinity() returns \\spad{M} such that} \\indented{1}{\\spad{(v1,...,vn) = \\spad{M} \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(v1,...,vn)} is the local integral basis at infinity} \\indented{1}{returned by \\spad{infIntBasis()}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} integralMatrixAtInfinity()$R" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((inverseIntegralMatrixAtInfinity ((Matrix RF)))): Improper first word in comments: +"\\indented{1}{inverseIntegralMatrixAtInfinity() returns \\spad{M} such} \\indented{1}{that \\spad{M (v1,...,vn) = \\spad{(1,} \\spad{y,} ..., y**(n-1))}} \\indented{1}{where \\spad{(v1,...,vn)} is the local integral basis at infinity} \\indented{1}{returned by \\spad{infIntBasis()}.} \\blankline \\spad{X} \\spad{P0} \\spad{:=} UnivariatePolynomial(x, Integer) \\spad{X} \\spad{P1} \\spad{:=} UnivariatePolynomial(y, Fraction \\spad{P0)} \\spad{X} \\spad{R} \\spad{:=} RadicalFunctionField(INT, \\spad{P0,} \\spad{P1,} 1 - x**20, 20) \\spad{X} inverseIntegralMatrixAtInfinity()$R" + +--->bookvol10.2.pamphlet-->FunctionFieldCategory((rationalPoints ((List (List F))))): Improper first word in comments: +"\\indented{1}{rationalPoints() returns the list of all the affine} rational points." diff --git a/changelog b/changelog index d178057..e4171b0 100644 --- a/changelog +++ b/changelog @@ -1,3 +1,9 @@ +20130317 tpd src/axiom-website/patches.html 20130317.07.tpd.patch +20130317 tpd buglist fix multiple typos +20130317 tpd books/bookvol10.2 fix multiple typos +20130317 tpd src/axiom-website/patches.html 20130317.06.tpd.patch +20130317 tpd buglist REAL fix 40345 +20130317 tpd books/bookvol10.2 REAL fix 40345 20130317 tpd src/axiom-website/patches.html 20130317.05.tpd.patch 20130317 tpd buglist ORDSET fix 40346 20130317 tpd books/bookvol10.2 ORDSET fix 40346 diff --git a/src/axiom-website/patches.html b/src/axiom-website/patches.html index b411ed5..4c4d83c 100644 --- a/src/axiom-website/patches.html +++ b/src/axiom-website/patches.html @@ -4095,5 +4095,9 @@ books/bookvol10.4 MONAD fix 40350, add 7236 books/bookvol10.3 OPTPROB fix 40347 20130317.05.tpd.patch books/bookvol10.2 ORDSET fix 40346 +20130317.06.tpd.patch +books/bookvol10.2 REAL fix 40345 +20130317.07.tpd.patch +books/bookvol10.2 fix multiple typos