DoubleFloatVectorΒΆ

numarr.spad line 1 [edit on github]

This is a low-level domain which implements vectors (one dimensional arrays) of double precision floating point numbers. Indexing is 0 based, there is no bound checking (unless provided by lower level).

#: % -> NonNegativeInteger

from Aggregate

*: (%, DoubleFloat) -> %

from VectorCategory DoubleFloat

*: (DoubleFloat, %) -> %

from VectorCategory DoubleFloat

*: (Integer, %) -> %

from VectorCategory DoubleFloat

+: (%, %) -> %

from VectorCategory DoubleFloat

-: % -> %

from VectorCategory DoubleFloat

-: (%, %) -> %

from VectorCategory DoubleFloat

<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

~=: (%, %) -> Boolean

from BasicType

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

from HomogeneousAggregate DoubleFloat

coerce: % -> OutputForm

from CoercibleTo OutputForm

concat: (%, %) -> %

from LinearAggregate DoubleFloat

concat: (%, DoubleFloat) -> %

from LinearAggregate DoubleFloat

concat: (DoubleFloat, %) -> %

from LinearAggregate DoubleFloat

concat: List % -> %

from LinearAggregate DoubleFloat

construct: List DoubleFloat -> %

from Collection DoubleFloat

convert: % -> InputForm

from ConvertibleTo InputForm

copy: % -> %

from Aggregate

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

from LinearAggregate DoubleFloat

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

from HomogeneousAggregate DoubleFloat

count: (DoubleFloat, %) -> NonNegativeInteger

from HomogeneousAggregate DoubleFloat

cross: (%, %) -> %

from VectorCategory DoubleFloat

delete: (%, Integer) -> %

from LinearAggregate DoubleFloat

delete: (%, UniversalSegment Integer) -> %

from LinearAggregate DoubleFloat

dot: (%, %) -> DoubleFloat

from VectorCategory DoubleFloat

elt: (%, Integer) -> DoubleFloat

from Eltable(Integer, DoubleFloat)

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

from EltableAggregate(Integer, DoubleFloat)

elt: (%, UniversalSegment Integer) -> %

from Eltable(UniversalSegment Integer, %)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

entries: % -> List DoubleFloat

from IndexedAggregate(Integer, DoubleFloat)

entry?: (DoubleFloat, %) -> Boolean

from IndexedAggregate(Integer, DoubleFloat)

eq?: (%, %) -> Boolean

from Aggregate

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

from InnerEvalable(DoubleFloat, DoubleFloat)

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

from Evalable DoubleFloat

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

from InnerEvalable(DoubleFloat, DoubleFloat)

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

from Evalable DoubleFloat

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

from HomogeneousAggregate DoubleFloat

fill!: (%, DoubleFloat) -> %

from IndexedAggregate(Integer, DoubleFloat)

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

from Collection DoubleFloat

first: % -> DoubleFloat

from IndexedAggregate(Integer, DoubleFloat)

first: (%, NonNegativeInteger) -> %

from LinearAggregate DoubleFloat

hash: % -> SingleInteger

from SetCategory

hashUpdate!: (HashState, %) -> HashState

from SetCategory

index?: (Integer, %) -> Boolean

from IndexedAggregate(Integer, DoubleFloat)

indices: % -> List Integer

from IndexedAggregate(Integer, DoubleFloat)

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

from LinearAggregate DoubleFloat

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

from LinearAggregate DoubleFloat

latex: % -> String

from SetCategory

leftTrim: (%, DoubleFloat) -> %

from LinearAggregate DoubleFloat

length: % -> DoubleFloat

from VectorCategory DoubleFloat

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

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

from HomogeneousAggregate DoubleFloat

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

from LinearAggregate DoubleFloat

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

from HomogeneousAggregate DoubleFloat

max: % -> DoubleFloat

from HomogeneousAggregate DoubleFloat

max: (%, %) -> %

from OrderedSet

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

from HomogeneousAggregate DoubleFloat

maxIndex: % -> Integer

from IndexedAggregate(Integer, DoubleFloat)

member?: (DoubleFloat, %) -> Boolean

from HomogeneousAggregate DoubleFloat

members: % -> List DoubleFloat

from HomogeneousAggregate DoubleFloat

merge: (%, %) -> %

from LinearAggregate DoubleFloat

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

from LinearAggregate DoubleFloat

min: % -> DoubleFloat

from HomogeneousAggregate DoubleFloat

min: (%, %) -> %

from OrderedSet

minIndex: % -> Integer

from IndexedAggregate(Integer, DoubleFloat)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

new: (NonNegativeInteger, DoubleFloat) -> %

from LinearAggregate DoubleFloat

outerProduct: (%, %) -> Matrix DoubleFloat

from VectorCategory DoubleFloat

parts: % -> List DoubleFloat

from HomogeneousAggregate DoubleFloat

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

from LinearAggregate DoubleFloat

position: (DoubleFloat, %) -> Integer

from LinearAggregate DoubleFloat

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

from LinearAggregate DoubleFloat

qelt: (%, Integer) -> DoubleFloat

from EltableAggregate(Integer, DoubleFloat)

qnew: Integer -> %

qnew(n) creates a new uninitialized vector of length n.

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

from EltableAggregate(Integer, DoubleFloat)

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

from Collection DoubleFloat

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

from Collection DoubleFloat

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

from Collection DoubleFloat

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

from Collection DoubleFloat

remove: (DoubleFloat, %) -> %

from Collection DoubleFloat

removeDuplicates: % -> %

from Collection DoubleFloat

reverse!: % -> %

from LinearAggregate DoubleFloat

reverse: % -> %

from LinearAggregate DoubleFloat

rightTrim: (%, DoubleFloat) -> %

from LinearAggregate DoubleFloat

sample: %

from Aggregate

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

from Collection DoubleFloat

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

from EltableAggregate(Integer, DoubleFloat)

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

from LinearAggregate DoubleFloat

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller?: (%, %) -> Boolean

from Comparable

sort!: % -> %

from LinearAggregate DoubleFloat

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

from LinearAggregate DoubleFloat

sort: % -> %

from LinearAggregate DoubleFloat

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

from LinearAggregate DoubleFloat

sorted?: % -> Boolean

from LinearAggregate DoubleFloat

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

from LinearAggregate DoubleFloat

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

from IndexedAggregate(Integer, DoubleFloat)

trim: (%, DoubleFloat) -> %

from LinearAggregate DoubleFloat

zero?: % -> Boolean

from VectorCategory DoubleFloat

zero: NonNegativeInteger -> %

from VectorCategory DoubleFloat

Aggregate

BasicType

CoercibleTo OutputForm

Collection DoubleFloat

Comparable

ConvertibleTo InputForm

Eltable(Integer, DoubleFloat)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, DoubleFloat)

Evalable DoubleFloat if DoubleFloat has Evalable DoubleFloat

finiteAggregate

FiniteLinearAggregate DoubleFloat

HomogeneousAggregate DoubleFloat

IndexedAggregate(Integer, DoubleFloat)

InnerEvalable(DoubleFloat, DoubleFloat) if DoubleFloat has Evalable DoubleFloat

LinearAggregate DoubleFloat

OneDimensionalArrayAggregate DoubleFloat

OrderedSet

PartialOrder

SetCategory

shallowlyMutable

VectorCategory DoubleFloat