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

any? : (Mapping(Boolean, DoubleFloat), %) -> 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, %) -> NonNegativeInteger

from HomogeneousAggregate(DoubleFloat)

count : (Mapping(Boolean, 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 : (%, UniversalSegment(Integer)) -> %

from Eltable(UniversalSegment(Integer), %)

elt : (%, Integer) -> DoubleFloat

from Eltable(Integer, DoubleFloat)

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

from EltableAggregate(Integer, DoubleFloat)

empty : () -> %

from Aggregate

empty? : % -> Boolean

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? : (Mapping(Boolean, DoubleFloat), %) -> Boolean

from HomogeneousAggregate(DoubleFloat)

fill! : (%, DoubleFloat) -> %

from IndexedAggregate(Integer, DoubleFloat)

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

from Collection(DoubleFloat)

first : (%, NonNegativeInteger) -> %

from LinearAggregate(DoubleFloat)

first : % -> DoubleFloat

from IndexedAggregate(Integer, DoubleFloat)

hash : % -> SingleInteger

from Hashable

hashUpdate! : (HashState, %) -> HashState

from Hashable

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 : (Mapping(DoubleFloat, DoubleFloat), %) -> %

from HomogeneousAggregate(DoubleFloat)

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

from LinearAggregate(DoubleFloat)

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

from HomogeneousAggregate(DoubleFloat)

max : (%, %) -> %

from OrderedSet

max : % -> DoubleFloat

from HomogeneousAggregate(DoubleFloat)

max : (Mapping(Boolean, DoubleFloat, DoubleFloat), %) -> 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 : (Mapping(Boolean, DoubleFloat, DoubleFloat), %, %) -> %

from LinearAggregate(DoubleFloat)

min : (%, %) -> %

from OrderedSet

min : % -> DoubleFloat

from HomogeneousAggregate(DoubleFloat)

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, %) -> Integer

from LinearAggregate(DoubleFloat)

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

from LinearAggregate(DoubleFloat)

position : (Mapping(Boolean, DoubleFloat), %) -> 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 : (Mapping(DoubleFloat, DoubleFloat, DoubleFloat), %) -> DoubleFloat

from Collection(DoubleFloat)

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

from Collection(DoubleFloat)

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

from Collection(DoubleFloat)

remove : (DoubleFloat, %) -> %

from Collection(DoubleFloat)

remove : (Mapping(Boolean, 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 : (Mapping(Boolean, DoubleFloat), %) -> %

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 : (Mapping(Boolean, DoubleFloat, DoubleFloat), %) -> %

from LinearAggregate(DoubleFloat)

sort! : % -> %

from LinearAggregate(DoubleFloat)

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

from LinearAggregate(DoubleFloat)

sorted? : % -> Boolean

from LinearAggregate(DoubleFloat)

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

from LinearAggregate(DoubleFloat)

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

from IndexedAggregate(Integer, DoubleFloat)

trim : (%, DoubleFloat) -> %

from LinearAggregate(DoubleFloat)

zero : NonNegativeInteger -> %

from VectorCategory(DoubleFloat)

zero? : % -> Boolean

from VectorCategory(DoubleFloat)

~= : (%, %) -> Boolean

from BasicType

Comparable

ConvertibleTo(InputForm)

VectorCategory(DoubleFloat)

Collection(DoubleFloat)

shallowlyMutable

Aggregate

Eltable(Integer, DoubleFloat)

FiniteLinearAggregate(DoubleFloat)

HomogeneousAggregate(DoubleFloat)

InnerEvalable(DoubleFloat, DoubleFloat)

OrderedSet

SetCategory

OneDimensionalArrayAggregate(DoubleFloat)

PartialOrder

CoercibleTo(OutputForm)

Eltable(UniversalSegment(Integer), %)

Evalable(DoubleFloat)

IndexedAggregate(Integer, DoubleFloat)

EltableAggregate(Integer, DoubleFloat)

LinearAggregate(DoubleFloat)

finiteAggregate

Hashable

BasicType