diff options
Diffstat (limited to 'src/algebra/newpoint.spad.pamphlet')
| -rw-r--r-- | src/algebra/newpoint.spad.pamphlet | 732 |
1 files changed, 732 insertions, 0 deletions
diff --git a/src/algebra/newpoint.spad.pamphlet b/src/algebra/newpoint.spad.pamphlet new file mode 100644 index 00000000..b6b32e30 --- /dev/null +++ b/src/algebra/newpoint.spad.pamphlet @@ -0,0 +1,732 @@ +\documentclass{article} +\usepackage{axiom} +\begin{document} +\title{\$SPAD/src/algebra newpoint.spad} +\author{The Axiom Team} +\maketitle +\begin{abstract} +\end{abstract} +\eject +\tableofcontents +\eject +\section{category PTCAT PointCategory} +<<category PTCAT PointCategory>>= +)abbrev category PTCAT PointCategory +++ Author: +++ Date Created: +++ Date Last Updated: +++ Basic Operations: point, elt, setelt, copy, dimension, minIndex, maxIndex, +++ convert +++ Related Constructors: +++ Also See: +++ AMS Classifications: +++ Keywords: +++ References: +++ Description: PointCategory is the category of points in space which +++ may be plotted via the graphics facilities. Functions are provided for +++ defining points and handling elements of points. + +PointCategory(R:Ring) : Category == VectorCategory(R) with + point: List R -> % + ++ point(l) returns a point category defined by a list l of elements from + ++ the domain R. + dimension: % -> PositiveInteger + ++ dimension(s) returns the dimension of the point category s. + convert: List R -> % + ++ convert(l) takes a list of elements, l, from the domain Ring and + ++ returns the form of point category. + cross: (%,%) -> % + ++ cross(p,q) computes the cross product of the two points \spad{p} + ++ and \spad{q}. Error if the p and q are not 3 dimensional + extend : (%,List R) -> % + ++ extend(x,l,r) \undocumented + +@ +\section{domain POINT Point} +<<domain POINT Point>>= +)abbrev domain POINT Point +++ Description: +++ This domain implements points in coordinate space + +Point(R:Ring) : Exports == Implementation where + -- Domains for points, subspaces and properties of components in + -- a subspace + + Exports ==> PointCategory(R) + + Implementation ==> Vector (R) add + PI ==> PositiveInteger + + point(l:List R):% == + pt := new(#l,R) + for x in l for i in minIndex(pt).. repeat + pt.i := x + pt + dimension p == (# p)::PI -- Vector returns NonNegativeInteger...? + convert(l:List R):% == point(l) + cross(p0, p1) == + #p0 ^=3 or #p1^=3 => error "Arguments to cross must be three dimensional" + point [p0.2 * p1.3 - p1.2 * p0.3, _ + p1.1 * p0.3 - p0.1 * p1.3, _ + p0.1 * p1.2 - p1.1 * p0.2] + extend(p,l) == concat(p,point l) + +@ +\section{domain COMPPROP SubSpaceComponentProperty} +<<domain COMPPROP SubSpaceComponentProperty>>= +)abbrev domain COMPPROP SubSpaceComponentProperty +++ Description: +++ This domain implements some global properties of subspaces. + +SubSpaceComponentProperty() : Exports == Implementation where + + O ==> OutputForm + I ==> Integer + PI ==> PositiveInteger + NNI ==> NonNegativeInteger + L ==> List + B ==> Boolean + + Exports ==> SetCategory with + new : () -> % + ++ new() \undocumented + closed? : % -> B + ++ closed?(x) \undocumented + solid? : % -> B + ++ solid?(x) \undocumented + close : (%,B) -> B + ++ close(x,b) \undocumented + solid : (%,B) -> B + ++ solid(x,b) \undocumented + copy : % -> % + ++ copy(x) \undocumented + + Implementation ==> add + Rep := Record(closed:B, solid:B) + closed? p == p.closed + solid? p == p.solid + close(p,b) == p.closed := b + solid(p,b) == p.solid := b + new() == [false,false] + copy p == + annuderOne := new() + close(annuderOne,closed? p) + solid(annuderOne,solid? p) + annuderOne + coerce p == + hconcat(["Component is "::O, + (closed? p => ""::O; "not "::O),"closed, "::O, _ + (solid? p => ""::O; "not "::O),"solid"::O ]) + +@ +\section{domain SUBSPACE SubSpace} +<<domain SUBSPACE SubSpace>>= +)abbrev domain SUBSPACE SubSpace +++ Description: +++ This domain \undocumented +SubSpace(n:PI,R:Ring) : Exports == Implementation where + -- n is the dimension of the subSpace + -- The SubSpace domain is implemented as a tree. The root of the tree + -- is the only node in which the field dataList - which points to a + -- list of points over the ring, R - is defined. The children of the + -- root are the top level components of the SubSpace (in 2D, these + -- would be separate curves; in 3D, these would be separate surfaces). + -- The pt field is only defined in the leaves. + -- By way of example, consider a three dimensional subspace with + -- two components - a three by three grid and a sphere. The internal + -- representation of this subspace is a tree with a depth of three. + -- The root holds a list of all the points used in the subspace (so, + -- if the grid and the sphere share points, the shared points would not + -- be represented redundantly but would be referenced by index). + -- The root, in this case, has two children - the first points to the + -- grid component and the second to the sphere component. The grid child + -- has four children of its own - a 3x3 grid has 4 endpoints - and each + -- of these point to a list of four points. To see it another way, the + -- grid (child of the root) holds a list of line components which, when + -- placed one above the next, forms a grid. Each of these line components + -- is a list of points. + -- Points could be explicitly added to subspaces at any level. A path + -- could be given as an argument to the addPoint() function. It is a list + -- of NonNegativeIntegers and refers, in order, to the n-th child of the + -- current node. For example, + -- addPoint(s,[2,3],p) + -- would add the point p to the subspace s by going to the second child of + -- the root and then the third child of that node. If the path does extend + -- to the full depth of the tree, nodes are automatically added so that + -- the tree is of constant depth down any path. By not specifying the full + -- path, new components could be added - e.g. for s from SubSpace(3,Float) + -- addPoint(s,[],p) + -- would create a new child to the root (a new component in N-space) and + -- extend a path to a leaf of depth 3 that points to the data held in p. + -- The subspace s would now have a new component which has one child + -- which, in turn, has one child (the leaf). The new component is then a + -- point. + + I ==> Integer + PI ==> PositiveInteger + NNI ==> NonNegativeInteger + L ==> List + B ==> Boolean + POINT ==> Point(R) + PROP ==> SubSpaceComponentProperty() + S ==> String + O ==> OutputForm + empty ==> nil -- macro to ease conversion to new aggcat.spad + + Exports ==> SetCategory with + leaf? : % -> B + ++ leaf?(x) \undocumented + root? : % -> B + ++ root?(x) \undocumented + internal? : % -> B + ++ internal?(x) \undocumented + new : () -> % + ++ new() \undocumented + subspace : () -> % + ++ subspace() \undocumented + birth : % -> % -- returns a pointer to the baby + ++ birth(x) \undocumented + child : (%,NNI) -> % + ++ child(x,n) \undocumented + children : % -> List % + ++ children(x) \undocumented + numberOfChildren: % -> NNI + ++ numberOfChildren(x) \undocumented + shallowCopy : % -> % + ++ shallowCopy(x) \undocumented + deepCopy : % -> % + ++ deepCopy(x) \undocumented + merge : (%,%) -> % + ++ merge(s1,s2) the subspaces s1 and s2 into a single subspace. + merge : List % -> % + ++ merge(ls) a list of subspaces, ls, into one subspace. + separate : % -> List % + ++ separate(s) makes each of the components of the \spadtype{SubSpace}, + ++ s, into a list of separate and distinct subspaces and returns + ++ the list. + addPoint : (%,List NNI,POINT) -> % + ++ addPoint(s,li,p) adds the 4 dimensional point, p, to the 3 + ++ dimensional subspace, s. The list of non negative integers, li, + ++ dictates the path to follow, or, to look at it another way, + ++ points to the component in which the point is to be added. It's + ++ length should range from 0 to \spad{n - 1} where n is the dimension + ++ of the subspace. If the length is \spad{n - 1}, then a specific + ++ lowest level component is being referenced. If it is less than + ++ \spad{n - 1}, then some higher level component (0 indicates top + ++ level component) is being referenced and a component of that level + ++ with the desired point is created. The subspace s is returned + ++ with the additional point. + addPoint2 : (%,POINT) -> % + ++ addPoint2(s,p) adds the 4 dimensional point, p, to the 3 + ++ dimensional subspace, s. + ++ The subspace s is returned with the additional point. + addPointLast : (%,%,POINT, NNI) -> % + ++ addPointLast(s,s2,li,p) adds the 4 dimensional point, p, to the 3 + ++ dimensional subspace, s. s2 point to the end of the subspace + ++ s. n is the path in the s2 component. + ++ The subspace s is returned with the additional point. + modifyPoint : (%,List NNI,POINT) -> % + ++ modifyPoint(s,li,p) replaces an existing point in the 3 dimensional + ++ subspace, s, with the 4 dimensional point, p. The list of non + ++ negative integers, li, dictates the path to follow, or, to look at + ++ it another way, points to the component in which the existing point + ++ is to be modified. An error message occurs if s is empty, otherwise + ++ the subspace s is returned with the point modification. + addPoint : (%,List NNI,NNI) -> % + ++ addPoint(s,li,i) adds the 4 dimensional point indicated by the + ++ index location, i, to the 3 dimensional subspace, s. The list of + ++ non negative integers, li, dictates the path to follow, or, to + ++ look at it another way, points to the component in which the point + ++ is to be added. It's length should range from 0 to \spad{n - 1} + ++ where n is the dimension of the subspace. If the length is + ++ \spad{n - 1}, then a specific lowest level component is being + ++ referenced. If it is less than \spad{n - 1}, then some higher + ++ level component (0 indicates top level component) is being + ++ referenced and a component of that level with the desired point + ++ is created. The subspace s is returned with the additional point. + modifyPoint : (%,List NNI,NNI) -> % + ++ modifyPoint(s,li,i) replaces an existing point in the 3 dimensional + ++ subspace, s, with the 4 dimensional point indicated by the index + ++ location, i. The list of non negative integers, li, dictates + ++ the path to follow, or, to look at it another way, points to the + ++ component in which the existing point is to be modified. An error + ++ message occurs if s is empty, otherwise the subspace s is returned + ++ with the point modification. + addPoint : (%,POINT) -> NNI + ++ addPoint(s,p) adds the point, p, to the 3 dimensional subspace, s, + ++ and returns the new total number of points in s. + modifyPoint : (%,NNI,POINT) -> % + ++ modifyPoint(s,ind,p) modifies the point referenced by the index + ++ location, ind, by replacing it with the point, p in the 3 dimensional + ++ subspace, s. An error message occurs if s is empty, otherwise the + ++ subspace s is returned with the point modification. + + closeComponent : (%,List NNI,B) -> % + ++ closeComponent(s,li,b) sets the property of the component in the + ++ 3 dimensional subspace, s, to be closed if b is true, or open if + ++ b is false. The list of non negative integers, li, dictates the + ++ path to follow, or, to look at it another way, points to the + ++ component whose closed property is to be set. The subspace, s, + ++ is returned with the component property modification. + defineProperty : (%,List NNI,PROP) -> % + ++ defineProperty(s,li,p) defines the component property in the + ++ 3 dimensional subspace, s, to be that of p, where p is of the + ++ domain \spadtype{SubSpaceComponentProperty}. The list of non + ++ negative integers, li, dictates the path to follow, or, to look + ++ at it another way, points to the component whose property is + ++ being defined. The subspace, s, is returned with the component + ++ property definition. + traverse : (%,List NNI) -> % + ++ traverse(s,li) follows the branch list of the 3 dimensional + ++ subspace, s, along the path dictated by the list of non negative + ++ integers, li, which points to the component which has been + ++ traversed to. The subspace, s, is returned, where s is now + ++ the subspace pointed to by li. + extractPoint : % -> POINT + ++ extractPoint(s) returns the point which is given by the current + ++ index location into the point data field of the 3 dimensional + ++ subspace s. + extractIndex : % -> NNI + ++ extractIndex(s) returns a non negative integer which is the current + ++ index of the 3 dimensional subspace s. + extractClosed : % -> B + ++ extractClosed(s) returns the \spadtype{Boolean} value of the closed + ++ property for the indicated 3 dimensional subspace s. If the + ++ property is closed, \spad{True} is returned, otherwise \spad{False} + ++ is returned. + extractProperty : % -> PROP + ++ extractProperty(s) returns the property of domain + ++ \spadtype{SubSpaceComponentProperty} of the indicated 3 dimensional + ++ subspace s. + level : % -> NNI + ++ level(s) returns a non negative integer which is the current + ++ level field of the indicated 3 dimensional subspace s. + parent : % -> % + ++ parent(s) returns the subspace which is the parent of the indicated + ++ 3 dimensional subspace s. If s is the top level subspace an error + ++ message is returned. + pointData : % -> L POINT + ++ pointData(s) returns the list of points from the point data field + ++ of the 3 dimensional subspace s. + + Implementation ==> add + import String() + + Rep := Record(pt:POINT, index:NNI, property:PROP, _ + childrenField:List %, _ + lastChild: List %, _ + levelField:NNI, _ + pointDataField:L POINT, _ + lastPoint: L POINT, _ + noPoints: NNI, _ + noChildren: NNI, _ + parentField:List %) -- needn't be list but...base case? + + TELLWATT : String := "Non-null list: Please inform Stephen Watt" + + leaf? space == empty? children space + root? space == (space.levelField = 0$NNI) + internal? space == ^(root? space and leaf? space) + + new() == + [point(empty())$POINT,0,new()$PROP,empty(),empty(),0,_ + empty(),empty(),0,0,empty()] + subspace() == new() + + birth momma == + baby := new() + baby.levelField := momma.levelField+1 + baby.parentField := [momma] + if not empty?(lastKid := momma.lastChild) then + not empty? rest lastKid => error TELLWATT + if empty? lastKid + then + momma.childrenField := [baby] + momma.lastChild := momma.childrenField + momma.noChildren := 1 + else + setrest_!(lastKid,[baby]) + momma.lastChild := rest lastKid + momma.noChildren := momma.noChildren + 1 + baby + + child(space,num) == + space.childrenField.num + + children space == space.childrenField + numberOfChildren space == space.noChildren + + shallowCopy space == + node := new() + node.pt := space.pt + node.index := space.index + node.property := copy(space.property) + node.levelField := space.levelField + node.parentField := nil() + if root? space then + node.pointDataField := copy(space.pointDataField) + node.lastPoint := tail(node.pointDataField) + node.noPoints := space.noPoints + node + + deepCopy space == + node := shallowCopy(space) + leaf? space => node + for c in children space repeat + cc := deepCopy c + cc.parentField := [node] + node.childrenField := cons(cc,node.childrenField) + node.childrenField := reverse_!(node.childrenField) + node.lastChild := tail node.childrenField + node + + merge(s1,s2) == + ------------------ need to worry about reindexing s2 & parentField + n1 : Rep := deepCopy s1 + n2 : Rep := deepCopy s2 + n1.childrenField := append(children n1,children n2) + n1 + + merge listOfSpaces == + ------------------ need to worry about reindexing & parentField + empty? listOfSpaces => error "empty list passed as argument to merge" + -- notice that the properties of the first subspace on the + -- list are the ones that are inherited...hmmmm... + space := deepCopy first listOfSpaces + for s in rest listOfSpaces repeat + -- because of the initial deepCopy, above, everything is + -- deepCopied to be consistent...more hmmm... + space.childrenField := append(space.childrenField,[deepCopy c for c in s.childrenField]) + space + + separate space == + ------------------ need to worry about reindexing & parentField + spaceList := empty() + for s in space.childrenField repeat + spc:=shallowCopy space + spc.childrenField:=[deepCopy s] + spaceList := cons(spc,spaceList) + spaceList + + addPoint(space:%,path:List NNI,point:POINT) == + if not empty?(lastPt := space.lastPoint) then + not empty? rest lastPt => error TELLWATT + if empty? lastPt + then + space.pointDataField := [point] + space.lastPoint := space.pointDataField + else + setrest_!(lastPt,[point]) + space.lastPoint := rest lastPt + space.noPoints := space.noPoints + 1 + which := space.noPoints + node := space + depth : NNI := 0 + for i in path repeat + node := child(node,i) + depth := depth + 1 + for more in depth..(n-1) repeat + node := birth node + node.pt := point -- will be obsolete field + node.index := which + space + + addPoint2(space:%,point:POINT) == + if not empty?(lastPt := space.lastPoint) then + not empty? rest lastPt => error TELLWATT + if empty? lastPt + then + space.pointDataField := [point] + space.lastPoint := space.pointDataField + else + setrest_!(lastPt,[point]) + space.lastPoint := rest lastPt + space.noPoints := space.noPoints + 1 + which := space.noPoints + node := space + depth : NNI := 0 + node := birth node + first := node + for more in 1..n-1 repeat + node := birth node + node.pt := point -- will be obsolete field + node.index := which + first + + addPointLast(space:%,node:%, point:POINT, depth:NNI) == + if not empty?(lastPt := space.lastPoint) then + not empty? rest lastPt => error TELLWATT + if empty? lastPt + then + space.pointDataField := [point] + space.lastPoint := space.pointDataField + else + setrest_!(lastPt,[point]) + space.lastPoint := rest lastPt + space.noPoints := space.noPoints + 1 + which := space.noPoints + if depth = 2 then node := child(node, 2) + for more in depth..(n-1) repeat + node := birth node + node.pt := point -- will be obsolete field + node.index := which + node -- space + + addPoint(space:%,path:List NNI,which:NNI) == + node := space + depth : NNI := 0 + for i in path repeat + node := child(node,i) + depth := depth + 1 + for more in depth..(n-1) repeat + node := birth node + node.pt := space.pointDataField.which -- will be obsolete field + node.index := which + space + + addPoint(space:%,point:POINT) == + root? space => + if not empty?(lastPt := space.lastPoint) then + not empty? rest lastPt => error TELLWATT + if empty? lastPt + then + space.pointDataField := [point] + space.lastPoint := space.pointDataField + else + setrest_!(lastPt,[point]) + space.lastPoint := rest lastPt + space.noPoints := space.noPoints + 1 + error "You need to pass a top level SubSpace (level should be zero)" + + modifyPoint(space:%,path:List NNI,point:POINT) == + if not empty?(lastPt := space.lastPoint) then + not empty? rest lastPt => error TELLWATT + if empty? lastPt + then + space.pointDataField := [point] + space.lastPoint := space.pointDataField + else + setrest_!(lastPt,[point]) + space.lastPoint := rest lastPt + space.noPoints := space.noPoints + 1 + which := space.noPoints + node := space + for i in path repeat + node := child(node,i) + node.pt := point ---------- will be obsolete field + node.index := which + space + + modifyPoint(space:%,path:List NNI,which:NNI) == + node := space + for i in path repeat + node := child(node,i) + node.pt := space.pointDataField.which ---------- will be obsolete field + node.index := which + space + + modifyPoint(space:%,which:NNI,point:POINT) == + root? space => + space.pointDataField.which := point + space + error "You need to pass a top level SubSpace (level should be zero)" + + closeComponent(space,path,val) == + node := space + for i in path repeat + node := child(node,i) + close(node.property,val) + space + + defineProperty(space,path,prop) == + node := space + for i in path repeat + node := child(node,i) + node.property := prop + space + + traverse(space,path) == + for i in path repeat space := child(space,i) + space + + extractPoint space == + node := space + while ^root? node repeat node := parent node + (node.pointDataField).(space.index) + extractIndex space == space.index + extractClosed space == closed? space.property + extractProperty space == space.property + + parent space == + empty? space.parentField => error "This is a top level SubSpace - it does not have a parent" + first space.parentField + pointData space == space.pointDataField + level space == space.levelField + s1 = s2 == + ------------ extra checks for list of point data + (leaf? s1 and leaf? s2) => + (s1.pt = s2.pt) and (s1.property = s2.property) and (s1.levelField = s2.levelField) + -- note that the ordering of children is important + #s1.childrenField ^= #s2.childrenField => false + and/[c1 = c2 for c1 in s1.childrenField for c2 in s2.childrenField] + and (s1.property = s2.property) and (s1.levelField = s2.levelField) + coerce(space:%):O == + hconcat([n::O,"-Space with depth of "::O, _ + (n - space.levelField)::O," and "::O,(s:=(#space.childrenField))::O, _ + (s=1 => " component"::O;" components"::O)]) + +@ +\section{package PTPACK PointPackage} +<<package PTPACK PointPackage>>= +)abbrev package PTPACK PointPackage +++ Description: +++ This package \undocumented +PointPackage(R:Ring):Exports == Implementation where + + POINT ==> Point(R) + I ==> Integer + PI ==> PositiveInteger + NNI ==> NonNegativeInteger + L ==> List + B ==> Boolean + + Exports == with + xCoord : POINT -> R + ++ xCoord(pt) returns the first element of the point, pt, + ++ although no assumptions are made as to the coordinate + ++ system being used. This function is defined for the + ++ convenience of the user dealing with a Cartesian + ++ coordinate system. + yCoord : POINT -> R + ++ yCoord(pt) returns the second element of the point, pt, + ++ although no assumptions are made as to the coordinate + ++ system being used. This function is defined for the + ++ convenience of the user dealing with a Cartesian + ++ coordinate system. + zCoord : POINT -> R + ++ zCoord(pt) returns the third element of the point, pt, + ++ although no assumptions are made as to the coordinate + ++ system being used. This function is defined for the + ++ convenience of the user dealing with a Cartesian + ++ or a cylindrical coordinate system. + rCoord : POINT -> R + ++ rCoord(pt) returns the first element of the point, pt, + ++ although no assumptions are made as to the coordinate + ++ system being used. This function is defined for the + ++ convenience of the user dealing with a spherical + ++ or a cylindrical coordinate system. + thetaCoord : POINT -> R + ++ thetaCoord(pt) returns the second element of the point, pt, + ++ although no assumptions are made as to the coordinate + ++ system being used. This function is defined for the + ++ convenience of the user dealing with a spherical + ++ or a cylindrical coordinate system. + phiCoord : POINT -> R + ++ phiCoord(pt) returns the third element of the point, pt, + ++ although no assumptions are made as to the coordinate + ++ system being used. This function is defined for the + ++ convenience of the user dealing with a spherical + ++ coordinate system. + color : POINT -> R + ++ color(pt) returns the fourth element of the point, pt, + ++ although no assumptions are made with regards as to + ++ how the components of higher dimensional points are + ++ interpreted. This function is defined for the + ++ convenience of the user using specifically, color + ++ to express a fourth dimension. + hue : POINT -> R + ++ hue(pt) returns the third element of the two dimensional point, pt, + ++ although no assumptions are made with regards as to how the + ++ components of higher dimensional points are interpreted. This + ++ function is defined for the convenience of the user using + ++ specifically, hue to express a third dimension. + shade : POINT -> R + ++ shade(pt) returns the fourth element of the two dimensional + ++ point, pt, although no assumptions are made with regards as to + ++ how the components of higher dimensional points are interpreted. + ++ This function is defined for the convenience of the user using + ++ specifically, shade to express a fourth dimension. + + -- 2D and 3D extraction of data + Implementation ==> add + + xCoord p == elt(p,1) + yCoord p == elt(p,2) + zCoord p == elt(p,3) + rCoord p == elt(p,1) + thetaCoord p == elt(p,2) + phiCoord p == elt(p,3) + color p == + #p > 3 => p.4 + p.3 + hue p == elt(p,3) -- 4D points in 2D using extra dimensions for palette information + shade p == elt(p,4) -- 4D points in 2D using extra dimensions for palette information + +@ +\section{package PTFUNC2 PointFunctions2} +<<package PTFUNC2 PointFunctions2>>= +)abbrev package PTFUNC2 PointFunctions2 +++ Description: +++ This package \undocumented +PointFunctions2(R1:Ring,R2:Ring):Exports == Implementation where + + Exports == with + map : ((R1->R2),Point(R1)) -> Point(R2) + ++ map(f,p) \undocumented + + Implementation ==> add + import Point(R1) + import Point(R2) + + map(mapping,p) == + point([mapping p.(i::PositiveInteger) for i in minIndex(p)..maxIndex(p)])$Point(R2) + +@ +\section{License} +<<license>>= +--Copyright (c) 1991-2002, The Numerical ALgorithms Group Ltd. +--All rights reserved. +-- +--Redistribution and use in source and binary forms, with or without +--modification, are permitted provided that the following conditions are +--met: +-- +-- - Redistributions of source code must retain the above copyright +-- notice, this list of conditions and the following disclaimer. +-- +-- - Redistributions in binary form must reproduce the above copyright +-- notice, this list of conditions and the following disclaimer in +-- the documentation and/or other materials provided with the +-- distribution. +-- +-- - Neither the name of The Numerical ALgorithms Group Ltd. nor the +-- names of its contributors may be used to endorse or promote products +-- derived from this software without specific prior written permission. +-- +--THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS +--IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED +--TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +--PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER +--OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, +--EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, +--PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR +--PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF +--LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING +--NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +--SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +@ +<<*>>= +<<license>> + +<<category PTCAT PointCategory>> +<<domain POINT Point>> +<<domain COMPPROP SubSpaceComponentProperty>> +<<domain SUBSPACE SubSpace>> +<<package PTPACK PointPackage>> +<<package PTFUNC2 PointFunctions2>> +@ +\eject +\begin{thebibliography}{99} +\bibitem{1} nothing +\end{thebibliography} +\end{document} |