JuliaVector R

jobject.spad line 1218 [edit on github]

• R: JuliaObjectType

This domain provides a JuliaVector type for JuliaObjectType. Minimum index is 1.

#: % -> NonNegativeInteger

from Aggregate

*: (%, R) -> % if R has SemiGroup

from VectorCategory R

*: (Integer, %) -> % if R has AbelianGroup

from VectorCategory R

*: (R, %) -> % if R has SemiGroup

from VectorCategory R

+: (%, %) -> % if R has AbelianSemiGroup

from VectorCategory R

-: % -> % if R has AbelianGroup

from VectorCategory R

-: (%, %) -> % if R has AbelianGroup

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

from CoercibleTo OutputForm

coerce: JuliaComplexF64Vector -> JuliaVector JuliaObjComplexF64

coerce(x): convenience function.

coerce: JuliaFloat64Vector -> JuliaVector JuliaObjFloat64

coerce(x): convenience function.

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

from ConvertibleTo InputForm

convert: % -> String

from ConvertibleTo String

copy: % -> %

from Aggregate

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

from LinearAggregate R

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

from HomogeneousAggregate R

count: (R, %) -> NonNegativeInteger

from HomogeneousAggregate R

cross: (%, %) -> % if R has Ring

from VectorCategory R

delete: (%, Integer) -> %

from LinearAggregate R

delete: (%, UniversalSegment Integer) -> %

from LinearAggregate R

dot: (%, %) -> R if R has AbelianMonoid and R has SemiRng

from VectorCategory R

elt: (%, Integer) -> JuliaObject

from JuliaObjectAggregate

elt: (%, Integer) -> R

from Eltable(Integer, R)

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

from EltableAggregate(Integer, R)

elt: (%, JuliaSymbol) -> JuliaObject

from JuliaObjectAggregate

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

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

jlAbout: % -> Void

from JuliaObjectType

jlApply: (String, %) -> %

from JuliaObjectType

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

from JuliaObjectType

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

from JuliaObjectType

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

from JuliaObjectType

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

from JuliaObjectType

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

from JuliaObjectType

jlDisplay: % -> Void

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

jlId: % -> String

from JuliaObjectType

jlRef: % -> SExpression

from JuliaObjectType

jlref: String -> %

from JuliaObjectType

jlType: % -> String

from JuliaObjectType

jvector: String -> %

jvector(str) evaluates the string str and returns the generated vector. No checks are done at the FriCAS level.

kroneckerProduct: (%, %) -> % if R hasn’t NemoType

kroneckerProduct(v1,v2) returns the kronecker product of v1 and v2.

latex: % -> String

from SetCategory

leftTrim: (%, R) -> %

from LinearAggregate R

length: % -> R if R has Ring and 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

mutable?: % -> Boolean

from JuliaObjectType

new: (NonNegativeInteger, R) -> %

from LinearAggregate R

nothing?: % -> Boolean

from JuliaObjectType

nrand: PositiveInteger -> JuliaVector JuliaComplexFloat if R hasn’t NemoType and R has JuliaObjectRing and R has ComplexCategory JuliaFloat

rand(n) returns a JuliaVector of size n with normally distributed random numbers.

nrand: PositiveInteger -> JuliaVector JuliaFloat if R has arbitraryPrecision and R hasn’t NemoType and R has FloatingPointSystem and R has JuliaObjectRing

rand(n) returns a JuliaVector of size n with normally distributed random numbers.

outerProduct: (%, %) -> Matrix R if R has Ring

from VectorCategory R

parts: % -> List R

from HomogeneousAggregate R

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

from LinearAggregate R

position: (R, %) -> Integer

from LinearAggregate R

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

from LinearAggregate R

qelt: (%, Integer) -> JuliaObject

from JuliaObjectAggregate

qelt: (%, Integer) -> R

from EltableAggregate(Integer, R)

qelt: (%, JuliaSymbol) -> JuliaObject

from JuliaObjectAggregate

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

string: % -> String

from JuliaObjectType

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

from IndexedAggregate(Integer, R)

trim: (%, R) -> %

from LinearAggregate R

urand01: PositiveInteger -> JuliaVector JuliaComplexFloat if R hasn’t NemoType and R has JuliaObjectRing and R has ComplexCategory JuliaFloat

urand01(n) returns a JuliaVector of size n with uniformly distributed random numbers contained in [0,1] in.

urand01: PositiveInteger -> JuliaVector JuliaFloat if R has arbitraryPrecision and R hasn’t NemoType and R has FloatingPointSystem and R has JuliaObjectRing

urand01(n) returns a JuliaVector of size n with uniformly distributed random numbers contained in [0,1] in.

vector: List R -> %

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

zero?: % -> Boolean if R has AbelianMonoid

from VectorCategory R

zero: NonNegativeInteger -> % if R has AbelianMonoid

from VectorCategory R

Aggregate

BasicType

CoercibleTo OutputForm

Collection R

Comparable if R has Comparable

ConvertibleTo InputForm if R has ConvertibleTo InputForm

ConvertibleTo String

Eltable(Integer, R)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, R)

Evalable R if R has Evalable R

finiteAggregate

FiniteLinearAggregate R

Hashable if R has Hashable

HomogeneousAggregate R

IndexedAggregate(Integer, R)

InnerEvalable(R, R) if R has Evalable R

JuliaObjectAggregate

JuliaObjectType

JuliaType

JuliaVectorCategory R

LinearAggregate R

OneDimensionalArrayAggregate R

OrderedSet if R has OrderedSet

PartialOrder if R has OrderedSet

SetCategory

shallowlyMutable

VectorCategory R