JuliaFloat32Vector

jarray32.spad line 1 [edit on github]

This domain provides a fast JuliaFloat32 vector type with no bound checking on elt's. Minimum index is 1.

#: % -> NonNegativeInteger

from Aggregate

*: (%, JuliaFloat32) -> %

from VectorCategory JuliaFloat32

*: (Integer, %) -> %

from VectorCategory JuliaFloat32

*: (JuliaFloat32, %) -> %

from VectorCategory JuliaFloat32

+: (%, %) -> %

from VectorCategory JuliaFloat32

-: % -> %

from VectorCategory JuliaFloat32

-: (%, %) -> %

from VectorCategory JuliaFloat32

<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

~=: (%, %) -> Boolean

from BasicType

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

from HomogeneousAggregate JuliaFloat32

coerce: % -> OutputForm

from CoercibleTo OutputForm

concat: (%, %) -> %

from LinearAggregate JuliaFloat32

concat: (%, JuliaFloat32) -> %

from LinearAggregate JuliaFloat32

concat: (JuliaFloat32, %) -> %

from LinearAggregate JuliaFloat32

concat: List % -> %

from LinearAggregate JuliaFloat32

construct: List JuliaFloat32 -> %

from Collection JuliaFloat32

convert: % -> InputForm if JuliaFloat32 has ConvertibleTo InputForm

from ConvertibleTo InputForm

copy!: (%, %) -> %

copy!(b,a) copies efficiently a to b. No check are done on arrays dimension.

copy: % -> %

from Aggregate

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

from LinearAggregate JuliaFloat32

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

from HomogeneousAggregate JuliaFloat32

count: (JuliaFloat32, %) -> NonNegativeInteger

from HomogeneousAggregate JuliaFloat32

cross: (%, %) -> %

from VectorCategory JuliaFloat32

delete: (%, Integer) -> %

from LinearAggregate JuliaFloat32

delete: (%, UniversalSegment Integer) -> %

from LinearAggregate JuliaFloat32

dot: (%, %) -> JuliaFloat32

from VectorCategory JuliaFloat32

elt: (%, Integer) -> JuliaFloat32

from Eltable(Integer, JuliaFloat32)

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

from EltableAggregate(Integer, JuliaFloat32)

elt: (%, UniversalSegment Integer) -> %

from Eltable(UniversalSegment Integer, %)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

entries: % -> List JuliaFloat32

from IndexedAggregate(Integer, JuliaFloat32)

entry?: (JuliaFloat32, %) -> Boolean

from IndexedAggregate(Integer, JuliaFloat32)

eq?: (%, %) -> Boolean

from Aggregate

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

from Evalable JuliaFloat32

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

from InnerEvalable(JuliaFloat32, JuliaFloat32)

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

from Evalable JuliaFloat32

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

from InnerEvalable(JuliaFloat32, JuliaFloat32)

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

from HomogeneousAggregate JuliaFloat32

fill!: (%, JuliaFloat32) -> %

from IndexedAggregate(Integer, JuliaFloat32)

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

from Collection JuliaFloat32

first: % -> JuliaFloat32

from IndexedAggregate(Integer, JuliaFloat32)

first: (%, NonNegativeInteger) -> %

from LinearAggregate JuliaFloat32

hash: % -> SingleInteger if JuliaFloat32 has Hashable

from Hashable

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

from Hashable

index?: (Integer, %) -> Boolean

from IndexedAggregate(Integer, JuliaFloat32)

indices: % -> List Integer

from IndexedAggregate(Integer, JuliaFloat32)

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

from LinearAggregate JuliaFloat32

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

from LinearAggregate JuliaFloat32

jlApply: (String, %) -> %

jlApply(func, v) applies func to argument v and returns a JuliaFloat32Vector.

jlApply: (String, %) -> JuliaFloat32

jlApply(func, v) applies func to argument v and returns a Julia Float32.

jlApply: (String, %) -> Void

jlApply(func, v) applies func to argument v.

jlApply: (String, %, %) -> Void

jlApply(func, v1, v2) applies func to arguments v1 and v2.

jlApply: (String, %, %, %) -> Void

jlApply(func, v1, v2, v3) applies func to arguments v1, v2 and v3.

jlApply: (String, %, JuliaFloat32) -> JuliaFloat32

jlApply(func, v, val) applies func to arguments v and val and returns a Julia Float32.

jlApprox?: (%, %) -> Boolean

jlApprox?(x,y) computes inexact equality comparison with default parameters. Two numbers compare equal if their relative distance or their absolute distance is within tolerance bounds. Applied component-vise.

jlDisplay: % -> Void

jldisplay(v) pretty prints v (à la Julia).

juliaVPrint: Boolean -> Boolean

juliaVPrint(b) defines whether or not FriCAS uses the printing version of Julia for vectors instead of its OutputForm version. Returns previous value. By default it is the Julia version.

latex: % -> String

from SetCategory

leftTrim: (%, JuliaFloat32) -> %

from LinearAggregate JuliaFloat32

length: % -> JuliaFloat32

from VectorCategory JuliaFloat32

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

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

from HomogeneousAggregate JuliaFloat32

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

from LinearAggregate JuliaFloat32

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

from HomogeneousAggregate JuliaFloat32

max: % -> JuliaFloat32

from HomogeneousAggregate JuliaFloat32

max: (%, %) -> %

from OrderedSet

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

from HomogeneousAggregate JuliaFloat32

maxIndex: % -> Integer

from IndexedAggregate(Integer, JuliaFloat32)

member?: (JuliaFloat32, %) -> Boolean

from HomogeneousAggregate JuliaFloat32

members: % -> List JuliaFloat32

from HomogeneousAggregate JuliaFloat32

merge: (%, %) -> %

from LinearAggregate JuliaFloat32

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

from LinearAggregate JuliaFloat32

min: % -> JuliaFloat32

from HomogeneousAggregate JuliaFloat32

min: (%, %) -> %

from OrderedSet

minIndex: % -> Integer

from IndexedAggregate(Integer, JuliaFloat32)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

new: (NonNegativeInteger, JuliaFloat32) -> %

from LinearAggregate JuliaFloat32

nrand: NonNegativeInteger -> %

nrand(n) returns a normally distributed Julia vector of size n with mean=0 and standard deviation=1.

outerProduct: (%, %) -> Matrix JuliaFloat32

from VectorCategory JuliaFloat32

parts: % -> List JuliaFloat32

from HomogeneousAggregate JuliaFloat32

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

from LinearAggregate JuliaFloat32

position: (JuliaFloat32, %) -> Integer

from LinearAggregate JuliaFloat32

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

from LinearAggregate JuliaFloat32

qelt: (%, Integer) -> JuliaFloat32

from EltableAggregate(Integer, JuliaFloat32)

qnew: NonNegativeInteger -> %

qnew(n) returns an unitialized vector of dimension n.

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

from EltableAggregate(Integer, JuliaFloat32)

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

from Collection JuliaFloat32

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

from Collection JuliaFloat32

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

from Collection JuliaFloat32

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

from Collection JuliaFloat32

remove: (JuliaFloat32, %) -> %

from Collection JuliaFloat32

removeDuplicates: % -> %

from Collection JuliaFloat32

reverse!: % -> %

from LinearAggregate JuliaFloat32

reverse: % -> %

from LinearAggregate JuliaFloat32

rightTrim: (%, JuliaFloat32) -> %

from LinearAggregate JuliaFloat32

sample: %

from Aggregate

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

from Collection JuliaFloat32

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

from EltableAggregate(Integer, JuliaFloat32)

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

from LinearAggregate JuliaFloat32

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller?: (%, %) -> Boolean

from Comparable

sort!: % -> %

from LinearAggregate JuliaFloat32

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

from LinearAggregate JuliaFloat32

sort: % -> %

from LinearAggregate JuliaFloat32

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

from LinearAggregate JuliaFloat32

sorted?: % -> Boolean

from LinearAggregate JuliaFloat32

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

from LinearAggregate JuliaFloat32

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

from IndexedAggregate(Integer, JuliaFloat32)

trim: (%, JuliaFloat32) -> %

from LinearAggregate JuliaFloat32

urand01: NonNegativeInteger -> %

urand01(n) returns a uniformly (0$NNI..1) distributed Julia vector of size n.

urand: (NonNegativeInteger, JuliaFloat32) -> %

urand(n, x) returns a uniformly (0$NNI..x) distributed Julia vector of size n.

vector: List JuliaFloat32 -> %

vector(l) converts the list l to a vector.

zero?: % -> Boolean

from VectorCategory JuliaFloat32

zero: NonNegativeInteger -> %

from VectorCategory JuliaFloat32

Aggregate

BasicType

CoercibleTo OutputForm

Collection JuliaFloat32

Comparable

ConvertibleTo InputForm if JuliaFloat32 has ConvertibleTo InputForm

Eltable(Integer, JuliaFloat32)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, JuliaFloat32)

Evalable JuliaFloat32 if JuliaFloat32 has Evalable JuliaFloat32

finiteAggregate

FiniteLinearAggregate JuliaFloat32

Hashable if JuliaFloat32 has Hashable

HomogeneousAggregate JuliaFloat32

IndexedAggregate(Integer, JuliaFloat32)

InnerEvalable(JuliaFloat32, JuliaFloat32) if JuliaFloat32 has Evalable JuliaFloat32

JuliaVectorCategory JuliaFloat32

LinearAggregate JuliaFloat32

OneDimensionalArrayAggregate JuliaFloat32

OrderedSet

PartialOrder

SetCategory

shallowlyMutable

VectorCategory JuliaFloat32