# ThreeSpaceCategory RΒΆ

The category ThreeSpaceCategory is used for creating three dimensional objects using functions for defining points, curves, polygons, constructs and the subspaces containing them.

=: (%, %) -> Boolean

from BasicType

~=: (%, %) -> Boolean

from BasicType

check: % -> %

check(s) returns lllpt, list of lists of lists of point information about the ThreeSpace s.

closedCurve?: % -> Boolean

closedCurve?(s) returns true if the ThreeSpace s contains a single closed curve component, i.e. the first element of the curve is also the last element, or false otherwise.

closedCurve: % -> List Point R

closedCurve(s) checks to see if the 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 PointDomain(m, R) and if so, returns the list of points. An error is signaled otherwise.

closedCurve: (%, List List R) -> %

closedCurve(s, [[lr0], [lr1], ..., [lrn], [lr0]]) adds a closed curve component defined by a list of points lr0 through lrn, which are lists of elements from the domain PointDomain(m, R), where R is the Ring over which the point elements are defined and m is the dimension of the 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 ThreeSpace, s.

closedCurve: (%, List Point R) -> %

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 ThreeSpace s.

closedCurve: List Point R -> %

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 ThreeSpace whose component is the closed curve defined by lp.

coerce: % -> OutputForm

coerce(s) returns the ThreeSpace s to Output format.

components: % -> List %

components(s) takes the ThreeSpace s, and creates a list containing a unique ThreeSpace for each single component of s. If s has no components defined, the list returned is empty.

composite: List % -> %

composite([s1, s2, ..., sn]) will create a new ThreeSpace that is a union of all the components from each ThreeSpace in the parameter list, grouped as a composite.

composites: % -> List %

composites(s) takes the ThreeSpace s, and creates a list containing a unique 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 ThreeSpace that is an exact copy of s.

create3Space: () -> %

create3Space() creates a ThreeSpace object capable of holding point, curve, mesh components and any combination.

create3Space: SubSpace(3, R) -> %

create3Space(s) creates a ThreeSpace object containing objects pre-defined within some SubSpace s.

curve?: % -> Boolean

curve?(s) queries whether the ThreeSpace, s, is a curve, i.e. has one component, a list of list of points, and returns true if it is, or false otherwise.

curve: % -> List Point R

curve(s) checks to see if the 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 otherwise.

curve: (%, List List 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 PointDomain(m, R), where R is the Ring over which the point elements are defined and m is the dimension of the points, to the ThreeSpace s.

curve: (%, List Point R) -> %

curve(s, [p0, p1, ..., pn]) adds a space curve component defined by a list of points p0 through pn, to the ThreeSpace s.

curve: List Point R -> %

curve([p0, p1, p2, ..., pn]) creates a space curve defined by the list of points p0 through pn, and returns the ThreeSpace whose component is the curve.

enterPointData: (%, List Point R) -> NonNegativeInteger

enterPointData(s, [p0, p1, ..., pn]) adds a list of points from p0 through pn to the ThreeSpace, s, and returns the index, to the starting point of the list.

hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

latex: % -> String

from SetCategory

lllip: % -> List List List NonNegativeInteger

lllip(s) checks to see if the 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: % -> List List List Point R

lllp(s) checks to see if the 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: % -> List List SubSpaceComponentProperty

llprop(s) checks to see if the 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.

lp: % -> List Point R

lp(s) returns the list of points component which the ThreeSpace, s, contains; these points are used by reference, i.e. the component holds indices referring to the points rather than the points themselves. This allows for sharing of the points.

lprop: % -> List SubSpaceComponentProperty

lprop(s) checks to see if the ThreeSpace, s, is composed of a list of subspace component properties, and if so, returns the list; An error is signaled otherwise.

merge: (%, %) -> %

merge(s1, s2) will create a new ThreeSpace that has the components of s1 and s2; Groupings of components into composites are maintained.

merge: List % -> %

merge([s1, s2, ..., sn]) will create a new ThreeSpace that has the components of all the ones in the list; Groupings of components into composites are maintained.

mesh?: % -> Boolean

mesh?(s) returns true if the ThreeSpace s is composed of one component, a mesh comprising a list of curves which are lists of points, or returns false if otherwise

mesh: % -> List List Point R

mesh(s) checks to see if the 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: (%, List List List R, Boolean, Boolean) -> %

mesh(s, [ [[r10]..., [r1m]], [[r20]..., [r2m]], ..., [[rn0]..., [rnm]] ], close1, close2) adds a surface component to the ThreeSpace s, which is defined over a rectangular domain of size WxH where W is the number of lists of points from the domain 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. 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: (%, List List List R, List SubSpaceComponentProperty, SubSpaceComponentProperty) -> %

mesh(s, [ [[r10]..., [r1m]], [[r20]..., [r2m]], ..., [[rn0]..., [rnm]] ], [props], prop) adds a surface component to the ThreeSpace s, which is defined over a rectangular domain of size WxH where W is the number of lists of points from the domain PointDomain(R) and 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.

mesh: (%, List List Point R, Boolean, Boolean) -> %

mesh(s, [[p0], [p1], ..., [pn]], close1, close2) adds a surface component to the 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. 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 are defined as the first list of points (curve) and the last list of points (curve).

mesh: (%, List List Point R, List SubSpaceComponentProperty, SubSpaceComponentProperty) -> %

mesh(s, [[p0], [p1], ..., [pn]], [props], prop) adds a surface component, defined over a list curves which contains lists of points, to the ThreeSpace s; props is a list which contains the subspace component properties for each surface parameter, and prop is the subspace component property by which the points are defined.

mesh: (List List Point R, Boolean, Boolean) -> %

mesh([[p0], [p1], ..., [pn]], close1, close2) creates a surface defined over a list of curves, p0 through pn, which are lists of points; the booleans close1 and close2 indicate how the surface is to be closed: close1 set to true 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); close2 set to true 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)); the ThreeSpace containing this surface is returned.

mesh: List List Point R -> %

mesh([[p0], [p1], ..., [pn]]) creates a surface defined by a list of curves which are lists, p0 through pn, of points, and returns a ThreeSpace whose component is the surface.

modifyPointData: (%, NonNegativeInteger, Point R) -> %

modifyPointData(s, i, p) changes the point at the indexed location i in the ThreeSpace, s, to that of point p. This is useful for making changes to a point which has been transformed.

numberOfComponents: % -> NonNegativeInteger

numberOfComponents(s) returns the number of distinct object components in the indicated ThreeSpace, s, such as points, curves, polygons, and constructs.

numberOfComposites: % -> NonNegativeInteger

numberOfComposites(s) returns the number of supercomponents, or composites, in the ThreeSpace, s; Composites are arbitrary groupings of otherwise distinct and unrelated components; A ThreeSpace need not have any composites defined at all 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.

objects: % -> Record(points: NonNegativeInteger, curves: NonNegativeInteger, polygons: NonNegativeInteger, constructs: NonNegativeInteger)

objects(s) returns the ThreeSpace, s, in the form of a 3D object record containing information on the number of points, curves, polygons and constructs comprising the ThreeSpace..

point?: % -> Boolean

point?(s) queries whether the ThreeSpace, s, is composed of a single component which is a point and returns the boolean result.

point: % -> Point R

point(s) checks to see if the ThreeSpace, s, is composed of only a single point and if so, returns the point. An error is signaled otherwise.

point: (%, List R) -> %

point(s, [x, y, z]) adds a point component defined by a list of elements which are from the PointDomain(R) to the ThreeSpace, s, where R is the Ring over which the point elements are defined.

point: (%, NonNegativeInteger) -> %

point(s, i) adds a point component which is placed into a component list of the ThreeSpace, s, at the index given by i.

point: (%, Point R) -> %

point(s, p) adds a point component defined by the point, p, specified as a list from List(R), to the ThreeSpace, s, where R is the Ring over which the point is defined.

point: Point R -> %

point(p) returns a ThreeSpace object which is composed of one component, the point p.

polygon?: % -> Boolean

polygon?(s) returns true if the ThreeSpace s contains a single polygon component, or false otherwise.

polygon: % -> List Point R

polygon(s) checks to see if the 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: (%, List List R) -> %

polygon(s, [[r0], [r1], ..., [rn]]) adds a polygon component defined by a list of points r0 through rn, which are lists of elements from the domain PointDomain(m, R) to the ThreeSpace s, where m is the dimension of the points and R is the Ring over which the points are defined.

polygon: (%, List Point R) -> %

polygon(s, [p0, p1, ..., pn]) adds a polygon component defined by a list of points, p0 throught pn, to the ThreeSpace s.

polygon: List Point R -> %

polygon([p0, p1, ..., pn]) creates a polygon defined by a list of points, p0 through pn, and returns a ThreeSpace whose component is the polygon.

subspace: % -> SubSpace(3, R)

subspace(s) returns the SubSpace which holds all the point information in the ThreeSpace, s.

BasicType

SetCategory