JuliaFloat64Vector

jarray64.spad line 72 [edit on github]

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

#: % -> NonNegativeInteger

from Aggregate

*: (%, JuliaFloat64) -> %

from VectorCategory JuliaFloat64

*: (Integer, %) -> %

from VectorCategory JuliaFloat64

*: (JuliaFloat64, %) -> %

from VectorCategory JuliaFloat64

+: (%, %) -> %

from VectorCategory JuliaFloat64

-: % -> %

from VectorCategory JuliaFloat64

-: (%, %) -> %

from VectorCategory JuliaFloat64

<=: (%, %) -> Boolean

from PartialOrder

<: (%, %) -> Boolean

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean

from PartialOrder

>: (%, %) -> Boolean

from PartialOrder

~=: (%, %) -> Boolean

from BasicType

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

from HomogeneousAggregate JuliaFloat64

coerce!: % -> DoubleFloatVector

coerce!(v) coerces v to a DoubleFloatVector.

coerce: % -> DoubleFloatVector

coerce(v) coerces a copy of v to a DoubleFloatVector.

coerce: % -> OutputForm

from CoercibleTo OutputForm

concat: (%, %) -> %

from LinearAggregate JuliaFloat64

concat: (%, JuliaFloat64) -> %

from LinearAggregate JuliaFloat64

concat: (JuliaFloat64, %) -> %

from LinearAggregate JuliaFloat64

concat: List % -> %

from LinearAggregate JuliaFloat64

construct: List JuliaFloat64 -> %

from Collection JuliaFloat64

convert: % -> 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 JuliaFloat64

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

from HomogeneousAggregate JuliaFloat64

count: (JuliaFloat64, %) -> NonNegativeInteger

from HomogeneousAggregate JuliaFloat64

cross: (%, %) -> %

from VectorCategory JuliaFloat64

delete: (%, Integer) -> %

from LinearAggregate JuliaFloat64

delete: (%, UniversalSegment Integer) -> %

from LinearAggregate JuliaFloat64

dot: (%, %) -> JuliaFloat64

from VectorCategory JuliaFloat64

elt: (%, Integer) -> JuliaFloat64

from Eltable(Integer, JuliaFloat64)

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

from EltableAggregate(Integer, JuliaFloat64)

elt: (%, UniversalSegment Integer) -> %

from Eltable(UniversalSegment Integer, %)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

entries: % -> List JuliaFloat64

from IndexedAggregate(Integer, JuliaFloat64)

entry?: (JuliaFloat64, %) -> Boolean

from IndexedAggregate(Integer, JuliaFloat64)

eq?: (%, %) -> Boolean

from Aggregate

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

from Evalable JuliaFloat64

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

from InnerEvalable(JuliaFloat64, JuliaFloat64)

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

from Evalable JuliaFloat64

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

from InnerEvalable(JuliaFloat64, JuliaFloat64)

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

from HomogeneousAggregate JuliaFloat64

fill!: (%, JuliaFloat64) -> %

from IndexedAggregate(Integer, JuliaFloat64)

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

from Collection JuliaFloat64

first: % -> JuliaFloat64

from IndexedAggregate(Integer, JuliaFloat64)

first: (%, NonNegativeInteger) -> %

from LinearAggregate JuliaFloat64

hash: % -> SingleInteger if JuliaFloat64 has Hashable

from Hashable

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

from Hashable

index?: (Integer, %) -> Boolean

from IndexedAggregate(Integer, JuliaFloat64)

indices: % -> List Integer

from IndexedAggregate(Integer, JuliaFloat64)

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

from LinearAggregate JuliaFloat64

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

from LinearAggregate JuliaFloat64

jlApply: (String, %) -> %

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

jlApply: (String, %) -> JuliaFloat64

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

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

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

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

from LinearAggregate JuliaFloat64

length: % -> JuliaFloat64

from VectorCategory JuliaFloat64

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

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

from HomogeneousAggregate JuliaFloat64

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

from LinearAggregate JuliaFloat64

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

from HomogeneousAggregate JuliaFloat64

max: % -> JuliaFloat64

from HomogeneousAggregate JuliaFloat64

max: (%, %) -> %

from OrderedSet

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

from HomogeneousAggregate JuliaFloat64

maxIndex: % -> Integer

from IndexedAggregate(Integer, JuliaFloat64)

member?: (JuliaFloat64, %) -> Boolean

from HomogeneousAggregate JuliaFloat64

members: % -> List JuliaFloat64

from HomogeneousAggregate JuliaFloat64

merge: (%, %) -> %

from LinearAggregate JuliaFloat64

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

from LinearAggregate JuliaFloat64

min: % -> JuliaFloat64

from HomogeneousAggregate JuliaFloat64

min: (%, %) -> %

from OrderedSet

minIndex: % -> Integer

from IndexedAggregate(Integer, JuliaFloat64)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

new: (NonNegativeInteger, JuliaFloat64) -> %

from LinearAggregate JuliaFloat64

nrand: NonNegativeInteger -> %

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

outerProduct: (%, %) -> Matrix JuliaFloat64

from VectorCategory JuliaFloat64

parts: % -> List JuliaFloat64

from HomogeneousAggregate JuliaFloat64

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

from LinearAggregate JuliaFloat64

position: (JuliaFloat64, %) -> Integer

from LinearAggregate JuliaFloat64

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

from LinearAggregate JuliaFloat64

qelt: (%, Integer) -> JuliaFloat64

from EltableAggregate(Integer, JuliaFloat64)

qnew: NonNegativeInteger -> %

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

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

from EltableAggregate(Integer, JuliaFloat64)

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

from Collection JuliaFloat64

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

from Collection JuliaFloat64

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

from Collection JuliaFloat64

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

from Collection JuliaFloat64

remove: (JuliaFloat64, %) -> %

from Collection JuliaFloat64

removeDuplicates: % -> %

from Collection JuliaFloat64

reverse!: % -> %

from LinearAggregate JuliaFloat64

reverse: % -> %

from LinearAggregate JuliaFloat64

rightTrim: (%, JuliaFloat64) -> %

from LinearAggregate JuliaFloat64

sample: %

from Aggregate

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

from Collection JuliaFloat64

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

from EltableAggregate(Integer, JuliaFloat64)

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

from LinearAggregate JuliaFloat64

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller?: (%, %) -> Boolean

from Comparable

sort!: % -> %

from LinearAggregate JuliaFloat64

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

from LinearAggregate JuliaFloat64

sort: % -> %

from LinearAggregate JuliaFloat64

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

from LinearAggregate JuliaFloat64

sorted?: % -> Boolean

from LinearAggregate JuliaFloat64

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

from LinearAggregate JuliaFloat64

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

from IndexedAggregate(Integer, JuliaFloat64)

trim: (%, JuliaFloat64) -> %

from LinearAggregate JuliaFloat64

urand01: NonNegativeInteger -> %

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

urand: (NonNegativeInteger, JuliaFloat64) -> %

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

vector: List JuliaFloat64 -> %

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

zero?: % -> Boolean

from VectorCategory JuliaFloat64

zero: NonNegativeInteger -> %

from VectorCategory JuliaFloat64

Aggregate

BasicType

CoercibleTo OutputForm

Collection JuliaFloat64

Comparable

ConvertibleTo InputForm

Eltable(Integer, JuliaFloat64)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, JuliaFloat64)

Evalable JuliaFloat64 if JuliaFloat64 has Evalable JuliaFloat64

finiteAggregate

FiniteLinearAggregate JuliaFloat64

Hashable if JuliaFloat64 has Hashable

HomogeneousAggregate JuliaFloat64

IndexedAggregate(Integer, JuliaFloat64)

InnerEvalable(JuliaFloat64, JuliaFloat64) if JuliaFloat64 has Evalable JuliaFloat64

JuliaVectorCategory JuliaFloat64

LinearAggregate JuliaFloat64

OneDimensionalArrayAggregate JuliaFloat64

OrderedSet

PartialOrder

SetCategory

shallowlyMutable

VectorCategory JuliaFloat64