# PointCategory RΒΆ

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.

#: % -> NonNegativeInteger

from Aggregate

*: (%, R) -> %

from VectorCategory R

*: (Integer, %) -> %

from VectorCategory R

*: (R, %) -> %

from VectorCategory R

+: (%, %) -> %

from VectorCategory R

-: % -> %

from VectorCategory R

-: (%, %) -> %

from VectorCategory R

<=: (%, %) -> Boolean if R has OrderedSet

from PartialOrder

<: (%, %) -> Boolean if R has OrderedSet

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean if R has OrderedSet

from PartialOrder

>: (%, %) -> Boolean if R has OrderedSet

from PartialOrder

~=: (%, %) -> Boolean

from BasicType

any?: (R -> Boolean, %) -> Boolean

from HomogeneousAggregate R

coerce: % -> OutputForm
concat: (%, %) -> %

from LinearAggregate R

concat: (%, R) -> %

from LinearAggregate R

concat: (R, %) -> %

from LinearAggregate R

concat: List % -> %

from LinearAggregate R

construct: List R -> %

from Collection R

convert: % -> InputForm if R has ConvertibleTo InputForm
convert: List R -> %

`convert(l)` takes a list of elements, `l`, from the domain Ring and returns the form of point category.

copy: % -> %

from Aggregate

copyInto!: (%, %, Integer) -> %

from LinearAggregate R

count: (R -> Boolean, %) -> NonNegativeInteger

from HomogeneousAggregate R

count: (R, %) -> NonNegativeInteger

from HomogeneousAggregate R

cross: (%, %) -> %

`cross(p, q)` computes the cross product of the two points `p` and `q`. Error if the `p` and `q` are not 3 dimensional

delete: (%, Integer) -> %

from LinearAggregate R

delete: (%, UniversalSegment Integer) -> %

from LinearAggregate R

dimension: % -> PositiveInteger

`dimension(s)` returns the dimension of the point category `s`.

dot: (%, %) -> R

from VectorCategory R

elt: (%, Integer) -> R

from Eltable(Integer, R)

elt: (%, Integer, R) -> R

from EltableAggregate(Integer, R)

elt: (%, UniversalSegment Integer) -> %

from Eltable(UniversalSegment Integer, %)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

entries: % -> List R

from IndexedAggregate(Integer, R)

entry?: (R, %) -> Boolean

from IndexedAggregate(Integer, R)

eq?: (%, %) -> Boolean

from Aggregate

eval: (%, Equation R) -> % if R has Evalable R

from Evalable R

eval: (%, List Equation R) -> % if R has Evalable R

from Evalable R

eval: (%, List R, List R) -> % if R has Evalable R

from InnerEvalable(R, R)

eval: (%, R, R) -> % if R has Evalable R

from InnerEvalable(R, R)

every?: (R -> Boolean, %) -> Boolean

from HomogeneousAggregate R

extend: (%, List R) -> %

`extend(x, l, r)` undocumented

fill!: (%, R) -> %

from IndexedAggregate(Integer, R)

find: (R -> Boolean, %) -> Union(R, failed)

from Collection R

first: % -> R

from IndexedAggregate(Integer, R)

first: (%, NonNegativeInteger) -> %

from LinearAggregate R

hash: % -> SingleInteger if R has Hashable

from Hashable

hashUpdate!: (HashState, %) -> HashState if R has Hashable

from Hashable

index?: (Integer, %) -> Boolean

from IndexedAggregate(Integer, R)

indices: % -> List Integer

from IndexedAggregate(Integer, R)

insert: (%, %, Integer) -> %

from LinearAggregate R

insert: (R, %, Integer) -> %

from LinearAggregate R

latex: % -> String

from SetCategory

leftTrim: (%, R) -> %

from LinearAggregate R

length: % -> R if R has RadicalCategory

from VectorCategory R

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

map!: (R -> R, %) -> %

from HomogeneousAggregate R

map: ((R, R) -> R, %, %) -> %

from LinearAggregate R

map: (R -> R, %) -> %

from HomogeneousAggregate R

max: % -> R if R has OrderedSet

from HomogeneousAggregate R

max: (%, %) -> % if R has OrderedSet

from OrderedSet

max: ((R, R) -> Boolean, %) -> R

from HomogeneousAggregate R

maxIndex: % -> Integer

from IndexedAggregate(Integer, R)

member?: (R, %) -> Boolean

from HomogeneousAggregate R

members: % -> List R

from HomogeneousAggregate R

merge: (%, %) -> % if R has OrderedSet

from LinearAggregate R

merge: ((R, R) -> Boolean, %, %) -> %

from LinearAggregate R

min: % -> R if R has OrderedSet

from HomogeneousAggregate R

min: (%, %) -> % if R has OrderedSet

from OrderedSet

minIndex: % -> Integer

from IndexedAggregate(Integer, R)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

new: (NonNegativeInteger, R) -> %

from LinearAggregate R

outerProduct: (%, %) -> Matrix R

from VectorCategory R

parts: % -> List R

from HomogeneousAggregate R

point: List R -> %

`point(l)` returns a point category defined by a list `l` of elements from the domain `R`.

position: (R -> Boolean, %) -> Integer

from LinearAggregate R

position: (R, %) -> Integer

from LinearAggregate R

position: (R, %, Integer) -> Integer

from LinearAggregate R

qelt: (%, Integer) -> R

from EltableAggregate(Integer, R)

qsetelt!: (%, Integer, R) -> R

from EltableAggregate(Integer, R)

reduce: ((R, R) -> R, %) -> R

from Collection R

reduce: ((R, R) -> R, %, R) -> R

from Collection R

reduce: ((R, R) -> R, %, R, R) -> R

from Collection R

remove: (R -> Boolean, %) -> %

from Collection R

remove: (R, %) -> %

from Collection R

removeDuplicates: % -> %

from Collection R

reverse!: % -> %

from LinearAggregate R

reverse: % -> %

from LinearAggregate R

rightTrim: (%, R) -> %

from LinearAggregate R

sample: %

from Aggregate

select: (R -> Boolean, %) -> %

from Collection R

setelt!: (%, Integer, R) -> R

from EltableAggregate(Integer, R)

setelt!: (%, UniversalSegment Integer, R) -> R

from LinearAggregate R

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller?: (%, %) -> Boolean if R has Comparable

from Comparable

sort!: % -> % if R has OrderedSet

from LinearAggregate R

sort!: ((R, R) -> Boolean, %) -> %

from LinearAggregate R

sort: % -> % if R has OrderedSet

from LinearAggregate R

sort: ((R, R) -> Boolean, %) -> %

from LinearAggregate R

sorted?: % -> Boolean if R has OrderedSet

from LinearAggregate R

sorted?: ((R, R) -> Boolean, %) -> Boolean

from LinearAggregate R

swap!: (%, Integer, Integer) -> Void

from IndexedAggregate(Integer, R)

trim: (%, R) -> %

from LinearAggregate R

zero?: % -> Boolean

from VectorCategory R

zero: NonNegativeInteger -> %

from VectorCategory R

Aggregate

BasicType

Comparable if R has Comparable

Eltable(Integer, R)

Evalable R if R has Evalable R

finiteAggregate

Hashable if R has Hashable

InnerEvalable(R, R) if R has Evalable R

OrderedSet if R has OrderedSet

PartialOrder if R has OrderedSet

SetCategory

shallowlyMutable