WSVector EΒΆ

jwsagg.spad line 248 [edit on github]

Julia Wolfram Symbolic vectors using the MathLink Julia package.

#: % -> NonNegativeInteger

from Aggregate

#: % -> WSInteger

from WSAggregate E

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

*: (WSInteger, %) -> %

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 WSNumber

from WSAggregate E

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

from HomogeneousAggregate E

append: (%, E) -> %

from WSAggregate E

coerce: % -> JLObject

from JLObjectType

coerce: % -> OutputForm

from CoercibleTo OutputForm

coerce: % -> WSExpression

from WSAggregate E

coerce: % -> WSMatrix E if E has WSRing

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

coerce: List E -> %

from WSAggregate 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: (%, UniversalSegment Integer) -> %

from LinearAggregate E

delete: (%, WSList WSInteger) -> %

from WSAggregate E

differences: % -> % if E has WSNumber

from WSAggregate E

dimensions: % -> WSList WSInteger

from WSAggregate E

dot: (%, %) -> E

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

elt: (%, Integer) -> E

from WSAggregate 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: (%, WSExpression) -> %

from WSAggregate E

fill!: (%, E) -> %

from IndexedAggregate(Integer, E)

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

from Collection E

first: % -> E

from WSAggregate 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, WSInteger) -> %

from WSAggregate E

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

from LinearAggregate E

intersection: (%, %) -> %

from WSAggregate E

jlAbout: % -> Void

from JLObjectType

jlApply: (String, %) -> %

from JLObjectType

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

from JLObjectType

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

from JLObjectType

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

from JLObjectType

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

from JLObjectType

jlDisplay: % -> Void

from JLObjectType

jlDump: JLObject -> Void

from JLObjectType

jlEval: % -> %

from WSObject

jlHead: % -> WSSymbol

from WSObject

jlId: % -> JLInt64

from JLObjectType

jlNumeric: % -> %

from WSObject

jlNumeric: (%, PositiveInteger) -> %

from WSObject

jlObject: () -> String

from JLObjectType

jlRef: % -> SExpression

from JLObjectType

jlref: String -> %

from JLObjectType

jlSymbolic: % -> String

from WSObject

jlType: % -> String

from JLObjectType

join: (%, %) -> %

from WSAggregate E

jWSAggregate: List E -> %

from WSAggregate E

jWSInterpret: (String, String) -> %

from WSObject

jWSVector: List E -> %

jWSVector(list) constructs list as a WSVector.

jWSVector: String -> %

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

last: % -> E

from WSAggregate E

latex: % -> String

from SetCategory

leftTrim: (%, E) -> %

from LinearAggregate E

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

from VectorCategory E

length: % -> WSInteger

from WSAggregate 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 JLObjectType

new: (NonNegativeInteger, E) -> %

from LinearAggregate E

norm: % -> E

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

nothing?: % -> Boolean

from JLObjectType

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

from VectorCategory E

part: (%, WSInteger) -> E

from WSAggregate 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 WSAggregate E

qelt: (%, Integer) -> E

from WSAggregate E

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

from WSAggregate E

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

from EltableAggregate(Integer, E)

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

from WSAggregate 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 WSAggregate E

replacePart: (%, %) -> %

from WSAggregate E

rest: % -> %

from WSAggregate E

reverse!: % -> %

from LinearAggregate E

reverse: % -> %

from WSAggregate E

reverse: (%, WSInteger) -> %

from WSAggregate E

reverse: (%, WSList WSInteger) -> %

from WSAggregate E

riffle: (%, %) -> %

from WSAggregate E

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

from WSAggregate E

rightTrim: (%, E) -> %

from LinearAggregate E

sample: %

from Aggregate

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

from Collection E

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

from WSAggregate E

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

from EltableAggregate(Integer, E)

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

from LinearAggregate E

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

from WSAggregate E

setIntersection: (%, %) -> %

from WSAggregate 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 WSAggregate E

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

from LinearAggregate E

sorted?: % -> Boolean

from WSAggregate E

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

from LinearAggregate E

string: % -> String

from JLType

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

from IndexedAggregate(Integer, E)

take: (%, Integer) -> %

from WSAggregate E

take: (%, WSList WSInteger) -> %

from WSAggregate E

toString: % -> String

from WSObject

total: % -> E if E has WSNumber

from WSAggregate 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 WSAggregate E

vector: WSList 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

JLObjectType

JLType

LinearAggregate E

OneDimensionalArrayAggregate E

OrderedSet if E has OrderedSet

PartialOrder if E has OrderedSet

SetCategory

shallowlyMutable

VectorCategory E

WSAggregate E

WSObject