JuliaWSVector EΒΆ

jwsagg.spad line 248 [edit on github]

Julia Wolfram Symbolic vectors using Wolfram Symbolic Transport Protocol.

#: % -> JuliaWSInteger

from JuliaWSAggregate E

#: % -> NonNegativeInteger

from Aggregate

*: (%, E) -> %

x * r is the right scalar multiple of the scalar r and the vector x.

*: (E, %) -> %

r*x is the left scalar multiple of the scalar r and the vector x.

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

from VectorCategory E

*: (JuliaWSInteger, %) -> %

n*a scale the vector a by n.

+: (%, %) -> %

a + b is the vector addition. WS error if dimensions are incompatible.

-: % -> %

-a negates each elements of the vector a.

-: (%, %) -> %

a - b is the vector substraction. WS error if dimensions are incompatible.

<=: (%, %) -> Boolean if E has OrderedSet

from PartialOrder

<: (%, %) -> Boolean if E has OrderedSet

from PartialOrder

=: (%, %) -> Boolean

from BasicType

>=: (%, %) -> Boolean if E has OrderedSet

from PartialOrder

>: (%, %) -> Boolean if E has OrderedSet

from PartialOrder

~=: (%, %) -> Boolean

from BasicType

accumulate: % -> % if E has JuliaWSNumber

from JuliaWSAggregate E

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

from HomogeneousAggregate E

append: (%, E) -> %

from JuliaWSAggregate E

coerce: % -> JuliaObject

from JuliaObjectType

coerce: % -> JuliaWSExpression

from JuliaWSAggregate E

coerce: % -> JuliaWSMatrix E if E has JuliaWSRing

coerce(v) coerces inplace v to a WS matrix.

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: List E -> %

from JuliaWSAggregate E

concat: (%, %) -> %

from LinearAggregate E

concat: (%, E) -> %

from LinearAggregate E

concat: (E, %) -> %

from LinearAggregate E

concat: List % -> %

from LinearAggregate E

construct: List E -> %

from Collection E

convert: % -> InputForm if E has ConvertibleTo InputForm

from ConvertibleTo InputForm

convert: % -> String

from ConvertibleTo String

copy: % -> %

from Aggregate

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

from LinearAggregate E

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

from HomogeneousAggregate E

count: (E, %) -> NonNegativeInteger

from HomogeneousAggregate E

cross: (%, %) -> %

cross(v1,v2) computes the vector cross product of v1 and v2.

delete: (%, Integer) -> %

from LinearAggregate E

delete: (%, JuliaWSList JuliaWSInteger) -> %

from JuliaWSAggregate E

delete: (%, UniversalSegment Integer) -> %

from LinearAggregate E

differences: % -> % if E has JuliaWSNumber

from JuliaWSAggregate E

dimensions: % -> JuliaWSList JuliaWSInteger

from JuliaWSAggregate E

dot: (%, %) -> E

dot(v1, v2) is the dot product of v1 and v2.

elt: (%, Integer) -> E

from JuliaWSAggregate E

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

from EltableAggregate(Integer, E)

elt: (%, UniversalSegment Integer) -> %

from Eltable(UniversalSegment Integer, %)

empty?: % -> Boolean

from Aggregate

empty: () -> %

from Aggregate

entries: % -> List E

from IndexedAggregate(Integer, E)

entry?: (E, %) -> Boolean

from IndexedAggregate(Integer, E)

eq?: (%, %) -> Boolean

from Aggregate

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

from InnerEvalable(E, E)

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

from Evalable E

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

from InnerEvalable(E, E)

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

from Evalable E

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

from HomogeneousAggregate E

extract: (%, JuliaWSExpression) -> %

from JuliaWSAggregate E

fill!: (%, E) -> %

from IndexedAggregate(Integer, E)

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

from Collection E

first: % -> E

from JuliaWSAggregate E

first: (%, NonNegativeInteger) -> %

from LinearAggregate E

hash: % -> SingleInteger if E has Hashable

from Hashable

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

from Hashable

index?: (Integer, %) -> Boolean

from IndexedAggregate(Integer, E)

indices: % -> List Integer

from IndexedAggregate(Integer, E)

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

from LinearAggregate E

insert: (%, E, JuliaWSInteger) -> %

from JuliaWSAggregate E

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

from LinearAggregate E

intersection: (%, %) -> %

from JuliaWSAggregate E

jlAbout: % -> Void

from JuliaObjectType

jlApply: (String, %) -> %

from JuliaObjectType

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

from JuliaObjectType

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

from JuliaObjectType

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

from JuliaObjectType

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

from JuliaObjectType

jlDisplay: % -> Void

from JuliaObjectType

jlEval: % -> %

from JuliaWSObject

jlHead: % -> JuliaWSSymbol

from JuliaWSObject

jlId: % -> JuliaInt64

from JuliaObjectType

jlNumeric: % -> %

from JuliaWSObject

jlNumeric: (%, PositiveInteger) -> %

from JuliaWSObject

jlObject: () -> String

from JuliaObjectType

jlRef: % -> SExpression

from JuliaObjectType

jlref: String -> %

from JuliaObjectType

jlSymbolic: % -> String

from JuliaWSObject

jlType: % -> String

from JuliaObjectType

join: (%, %) -> %

from JuliaWSAggregate E

jWSAggregate: List E -> %

from JuliaWSAggregate E

jWSInterpret: (String, String) -> %

from JuliaWSObject

jWSVector: List E -> %

jWSVector(list) constructs list as a JuliaWSVector.

jWSVector: String -> %

jWSVector(str) constructs str as a JuliaWSVector. str must be in the WS language (list).

last: % -> E

from JuliaWSAggregate E

latex: % -> String

from SetCategory

leftTrim: (%, E) -> %

from LinearAggregate E

length: % -> E if E has RadicalCategory and E has Ring

from VectorCategory E

length: % -> JuliaWSInteger

from JuliaWSAggregate E

less?: (%, NonNegativeInteger) -> Boolean

from Aggregate

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

from HomogeneousAggregate E

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

from LinearAggregate E

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

from HomogeneousAggregate E

max: % -> E if E has OrderedSet

from HomogeneousAggregate E

max: (%, %) -> % if E has OrderedSet

from OrderedSet

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

from HomogeneousAggregate E

maxIndex: % -> Integer

from IndexedAggregate(Integer, E)

member?: (E, %) -> Boolean

from HomogeneousAggregate E

members: % -> List E

from HomogeneousAggregate E

merge: (%, %) -> % if E has OrderedSet

from LinearAggregate E

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

from LinearAggregate E

min: % -> E if E has OrderedSet

from HomogeneousAggregate E

min: (%, %) -> % if E has OrderedSet

from OrderedSet

minIndex: % -> Integer

from IndexedAggregate(Integer, E)

more?: (%, NonNegativeInteger) -> Boolean

from Aggregate

mutable?: % -> Boolean

from JuliaObjectType

new: (NonNegativeInteger, E) -> %

from LinearAggregate E

norm: % -> E

norm(v) computes the norm of the vector v.

nothing?: % -> Boolean

from JuliaObjectType

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

from VectorCategory E

part: (%, JuliaWSInteger) -> E

from JuliaWSAggregate E

parts: % -> List E

from HomogeneousAggregate E

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

from LinearAggregate E

position: (E, %) -> Integer

from LinearAggregate E

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

from LinearAggregate E

prepend: (%, E) -> %

from JuliaWSAggregate E

qelt: (%, Integer) -> E

from JuliaWSAggregate E

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

from JuliaWSAggregate E

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

from EltableAggregate(Integer, E)

qsetelt: (%, Integer, E) -> %

from JuliaWSAggregate E

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

from Collection E

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

from Collection E

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

from Collection E

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

from Collection E

remove: (E, %) -> %

from Collection E

removeDuplicates: % -> %

from JuliaWSAggregate E

replacePart: (%, %) -> %

from JuliaWSAggregate E

rest: % -> %

from JuliaWSAggregate E

reverse!: % -> %

from LinearAggregate E

reverse: % -> %

from JuliaWSAggregate E

reverse: (%, JuliaWSInteger) -> %

from JuliaWSAggregate E

reverse: (%, JuliaWSList JuliaWSInteger) -> %

from JuliaWSAggregate E

riffle: (%, %) -> %

from JuliaWSAggregate E

riffle: (%, %, %) -> %

from JuliaWSAggregate E

rightTrim: (%, E) -> %

from LinearAggregate E

sample: %

from Aggregate

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

from Collection E

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

from JuliaWSAggregate E

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

from EltableAggregate(Integer, E)

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

from LinearAggregate E

setelt: (%, Integer, E) -> %

from JuliaWSAggregate E

setIntersection: (%, %) -> %

from JuliaWSAggregate E

size?: (%, NonNegativeInteger) -> Boolean

from Aggregate

smaller?: (%, %) -> Boolean if E has Comparable

from Comparable

sort!: % -> % if E has OrderedSet

from LinearAggregate E

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

from LinearAggregate E

sort: % -> %

from JuliaWSAggregate E

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

from LinearAggregate E

sorted?: % -> Boolean

from JuliaWSAggregate E

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

from LinearAggregate E

string: % -> String

from JuliaObjectType

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

from IndexedAggregate(Integer, E)

take: (%, Integer) -> %

from JuliaWSAggregate E

take: (%, JuliaWSList JuliaWSInteger) -> %

from JuliaWSAggregate E

toString: % -> String

from JuliaWSObject

total: % -> E if E has JuliaWSNumber

from JuliaWSAggregate E

transpose: % -> %

transpose(v) transposes v. For esoteric purpose, and if you know what you are doing. There is only one type of vector in the Wolfram language. Should not be used, and for normal purpose, does nothing.

trim: (%, E) -> %

from LinearAggregate E

union: (%, %) -> %

from JuliaWSAggregate E

vector: JuliaWSList E -> %

vector(list) returns list as a vector. Inplace coercion. example{vector(range(5)}

zero?: % -> Boolean if E has AbelianMonoid

from VectorCategory E

zero: NonNegativeInteger -> % if E has AbelianMonoid

from VectorCategory E

Aggregate

BasicType

CoercibleTo OutputForm

Collection E

Comparable if E has Comparable

ConvertibleTo InputForm if E has ConvertibleTo InputForm

ConvertibleTo String

Eltable(Integer, E)

Eltable(UniversalSegment Integer, %)

EltableAggregate(Integer, E)

Evalable E if E has Evalable E

finiteAggregate

FiniteLinearAggregate E

Hashable if E has Hashable

HomogeneousAggregate E

IndexedAggregate(Integer, E)

InnerEvalable(E, E) if E has Evalable E

JuliaObjectType

JuliaType

JuliaWSAggregate E

JuliaWSObject

LinearAggregate E

OneDimensionalArrayAggregate E

OrderedSet if E has OrderedSet

PartialOrder if E has OrderedSet

SetCategory

shallowlyMutable

VectorCategory E