Class Index | File Index

Classes


Class Vector

Represents a vector (1D matrix) of real (floating point) numbers
Defined in: jsmatrix.src.js.

Class Summary
Constructor Attributes Constructor Name and Description
 
Vector(nElements)
Vector implementation
Field Summary
Field Attributes Field Name and Description
 
Number of vector elements
Method Summary
Method Attributes Method Name and Description
 
add(vec)
Returns sum of receiver and vector ( ret = this + vec )
 
appendElements(newElems)
Appends given float/vector to the end of receiver
 
assemble(vec, coeffs)
assemble receiver to given vector ( vec[coeffs] += this )
 
beColOf(mat, c)
Modifies receiver to become column of given matrix - indexing from 0.
 
Alias for beColOf(), see Vector#beColOf
 
beCopyOf(vec)
Modifies receiver to become copy of given vector (this = vec).
 
beCrossProductOf(vec1, vec1)
Modifies receiver to become cross product of two vectors.
 
Modifies receiver to contain diagonal elements of mat ( this = diag(mat) )
 
beDifferenceOf(vec1, vec2)
Modifies receiver to become difference of two vectors ( this = vec1 - vec2 ).
 
Sets all elements of receiver to 1.0
 
Modifies receiver to become negative of given vector (this = -vec).
 
beProductOf(mat, vec)
Modifies receiver to become product of given matrix and vector ( this = mat * vec ).
 
beRowOf(mat, r)
Modifies receiver to become row of given matrix - indexing from 0.
 
beSolutionOf(mat, rhs, method, saveOrig, precompDecomps)
Modifies receiver to be a solution of linear system of equations mat*this = rhs.
 
beSubVectorOf(vec, coeffs)
Modifies receiver to become subvector of given vector (this = vec[coeffs]).
 
beSumOf(vec1, vec2)
Modifies receiver to become sum of two vectors ( this = vec1 + vec2 ).
 
beTProductOf(vec, mat)
Modifies receiver to become product of given vector and matrix ( this = vec^T * mat )
 
Testing if receiver can multiply given matrix from left ( this^T * mat )
 
Returns copy of receiver
 
copy()
Alias for copied(), see Vector#copied
<static>  
Vector.create(arry)
Constructs new Vector from given array
 
cross(vec)
Returns vector (cross) product of receiver and given vector.
 
decrSubVector(coeffs, vec)
Decrement subvector at defined positions of receiver (this[coeffs] -= vec)
 
Alias for decrSubVector, see Vector#decrSubVector
 
diag(mat)
Returns matrix with receiver's elements on diagonal (if no argument is specified, seeVector#toDiagonalMatrix) or modifies receiver to contain diagonal elements of given matrix (if given matrix is specified, seeVector#beDiagonalFrom)
 
dot(vec, n)
Returns dot (inner) product of receiver and given vector
 
dyadic(vec)
Returns dyadic (tensor, outer, direct,.
 
elementsPermutation(coeffs, backward)
Returns permutated copy of receiver according to given coefficients
 
Empties receiver (resizes it to size 0)
 
Returns energy norm of receiver (ret = sqrt(this*mat*this))
 
fromArray(arry)
Sets elements of receiver form given Array object
 
get(e)
Coefficient access function, returns one element of receiver ( ret = this[r] ).
 
getSubVector(coeffs)
Returns subvector of receiver.
 
Alias for getSubVector, see Vector#getSubVector
 
iadd(vec)
Add given vector to receiver ( this += vec )
 
imulf(f)
Multiply receiver by float f ( this *= f )
 
incr(e, val)
Coefficient access function, increment one element of receiver ( this[r] += val ).
 
incrSubVector(coeffs, vec)
Increment subvector at defined positions of receiver (this[coeffs] += vec)
 
Alias for incrSubVector, see Vector#incrSubVector
 
indexOf(val)
Returns index of first occurrence of given value
 
ineg()
Alias for neagete(), see Vector#negate
 
Tests if receiver is empty (has size 0)
 
isEqualTo(vec)
Testing vectors equality
 
Testing vectors size equality
 
isub(vec)
Subtract given vector to receiver ( this -= vec )
 
max()
Returns maximal value of receiver elements
 
min()
Returns minimal value of receiver elements
 
mul(what)
Returns product of receiver and given multiplier (float or Matrix)
 
mulf(f)
Returns receiver multiplied by float f ( ret = this * f )
 
mulm(mat)
Returns product of receiver and given matrix ( ret = this^T * mat )
 
neg()
Alias for negated(), see Vector#negated
 
Negate receiver ( ret *= -1.
 
Returns negative of receiver ( ret = -this )
 
norm()
Returns (Euclidean) norm of receiver (ret = sqrt(this^T * this) )
 
Normlize receiver ( this.norm()=1.
 
Returns normalized copy of receiver ( ret.norm()=1.
 
one()
Alias for beFullOfOnes(), see Vector#beFullOfOnes
<static>  
Vector.Ones(nElements)
Creates a vector full of ones
 
Alias for dyadic() (inspired by LaTeX symbol for dyadic product operation), see Vector#dyadic
 
Alias for dyadic(), see Vector#dyadic
 
permuteElements(coeffs, backward)
Permute elements of receiver according to given coefficients
 
resize(nElements)
Resize receiver according to given size (delete extra elements or add zero elements)
 
resized(nElements)
Returns resized copy of receiver according to given size (delete extra elements or add zero elements)
 
set(e, val)
Coefficient access function, sets one element of receiver ( this[r] = val ).
 
setSubVector(coeffs, vec)
Sets subvector at defined positions of receiver ( this[coeffs]=vec )
 
Alias for setSubVector, see Vector#setSubVector
 
size()
Returns size (numer of elements) of receiver
 
Returns squared energy norm of receiver (ret = this^T*mat*this)
 
Returns squared (Euclidean) norm of receiver (ret = this.
 
sub(vec)
Returns difference of receiver and vector ( ret = this - vec )
 
sum()
Returns sum of all elements of receiver
 
swapElements(e1, e2)
Swaps two elements of receiver
 
Alias for dyadic(), see Vector#dyadic
 
Returns elements of receiver as an Array object
 
Returns matrix with receiver's elements on its diagonal
 
Returns string representation of receiver
<static>  
Vector.UnitX()
Creates unit vector in x direction
<static>  
Vector.UnitY()
Creates unit vector in y direction
<static>  
Vector.UnitZ()
Creates unit vector in z direction
 
x()
Alias for mul(), see Vector#mul
 
zero()
Zeroes all elements of receiver
<static>  
Vector.Zeros(nElements)
Creates a vector full of zeros
Class Detail
Vector(nElements)
Vector implementation
Parameters:
{int} nElements Optional, Default: 0
number of elements of newly created Vector object
Field Detail
{int} nElements
Number of vector elements
Default Value:
0
Method Detail
{Vector} add(vec)
Returns sum of receiver and vector ( ret = this + vec )
v1 = vec([1,2,3]);
v2 = vec([6,1,5]);
v4 = v1.add(v2); // v4 = Vector([7,3,8])
Parameters:
{Vector} vec
2nd vector of the sum
Returns:
{Vector} sum of receiver and vec

appendElements(newElems)
Appends given float/vector to the end of receiver
v = vec([1,2]);
v.appendElements(4); // v = Vector([1,2,4]);
v.appendElements(vec([7,6])); // v = Vector([1,2,4,7,6]);
v.appendElements([vec([1,2]),vec([3,4])]); // v = Vector([1,2,4,6,7,1,2,3,4])
Parameters:
{float|Vector|[Vectors]} newElems
new element(s) to be appended

assemble(vec, coeffs)
assemble receiver to given vector ( vec[coeffs] += this )
v1 = vec([5,8,2,4,3,5]);
v2 = vec([1,2,3]);
v2.assemble(v1,[5,1,2]); // v1 = Vector([5,10,5,4,3,6])
Parameters:
{Vector} vec
vector where receiver is assembled
{[floats]|Vector} coeffs
array containing coefficients of vec to be incremented

beColOf(mat, c)
Modifies receiver to become column of given matrix - indexing from 0. Receiver's size is adjusted
v = vec([1,2]);
m = mat([[11,12,13],[21,22,23],[31,32,33]]);
v.beColOf(m,1) // v = Vector([12,22,32])
Parameters:
{Matix} mat
given matrix
{float} c
desired column (indexing from 0)

beColumnOf()
Alias for beColOf(), see Vector#beColOf

beCopyOf(vec)
Modifies receiver to become copy of given vector (this = vec). Receiver's size is adjusted
v1 = vec([4,5]);
v2 = vec([1,2,3]);
v1.beCopyOf(v2) // v2 = Vector([1,2,3])
Parameters:
{Vector} vec
vector to be copied to receiver

beCrossProductOf(vec1, vec1)
Modifies receiver to become cross product of two vectors. Both given vectors have to be of length 3. Receiver's size is adjusted
v = vec([5,6]);
v1 = vec([1,2,3]);
v2 = vec([4,5,6]);
v.beCrossProductOf(v1,v2); // v = Vector([-3,6,-3])
Parameters:
{Vector} vec1
1st vector for multiplication
{Vector} vec1
2nd vector for multiplication

beDiagonalFrom(mat)
Modifies receiver to contain diagonal elements of mat ( this = diag(mat) )
v = vec([6,7]);
m = mat([[1,2,3],[4,5,6],[7,8,9]]);
v.beDiagonalFrom(m); // v = Vector([1,5,9])
Parameters:
{Matrix} mat
matrix whose diagonal is copied to receiver

beDifferenceOf(vec1, vec2)
Modifies receiver to become difference of two vectors ( this = vec1 - vec2 ). Receiver's size is adjusted
v = vec([4,5]);
v1 = vec([1,2,3]);
v2 = vec([6,1,5]);
v.beDifferenceOf(v1,v2); // v = Vector([-5,1,-2])
Parameters:
{Vector} vec1
1st vector of the difference
{Vector} vec2
2nd vector of the difference

beFullOfOnes()
Sets all elements of receiver to 1.0
v = vec([1,2,3,4]);
v.beFullOfOnes(); // v = Vector([1,1,1,1])

beNegativeOf(vec)
Modifies receiver to become negative of given vector (this = -vec). Receiver's size is adjusted
v1 = vec([4,5])
v2 = vec([1,2,3]);
v1.beNegativeOf(v2); // v1 = Vector([-1,-2,-3])
Parameters:
{Vector} vec
given vector

beProductOf(mat, vec)
Modifies receiver to become product of given matrix and vector ( this = mat * vec ). Receiver's size is adjusted
v = vec([4,5]);
m = mat([[11,12,13],[21,22,23],[31,32,33]]);
v1 = vec([1,2,3]);
v.beProductOf(m,v1); // v = Vector([74,134,194])
Parameters:
{Matrix} mat
matrix of multiplication
{Vector} vec
vector of multiplication

beRowOf(mat, r)
Modifies receiver to become row of given matrix - indexing from 0. Receiver's size is adjusted
v = vec([1,2]);
m = mat([[11,12,13],[21,22,23],[31,32,33]]);
v.beRowOf(m,1) // v = Vector([21,22,23])
Parameters:
{Matix} mat
given matrix
{float} r
desired row (indexing from 0)

beSolutionOf(mat, rhs, method, saveOrig, precompDecomps)
Modifies receiver to be a solution of linear system of equations mat*this = rhs. Receiver's size is adjusted
v = vec([2,3]);
a = mat([[1,2,9],[8,3,2],[3,7,3]]);
b = vec([32,20,26]);
v.beSolutionOf(a,b); // v = Vector([1,2,3])
Parameters:
{Matrix} mat
matrix of the system
{Vector} rhs
vector of right hand side
{string} method Optional, Default: "default"
see Matrix#linSolve
{bool} saveOrig Optional, Default: true
see Matrix#linSolve
{[Matrices]} precompDecomps Optional, Default: undefined
see Matrix#linSolve

beSubVectorOf(vec, coeffs)
Modifies receiver to become subvector of given vector (this = vec[coeffs]). Receiver's size is adjusted
v1 = vec([4,7,9,1,8,3,2,4,6,7,5,1,6,9]);
v2 = vec([3,4]);
v2.beSubVectorOf(v1,[2,3,6,8,9]); // v2 = Vector([9,1,2,6,7])
Parameters:
{Vector} vec
vector to get subvector from
{[floats]|Vector} coeffs
array containing coefficients of desired subvector

beSumOf(vec1, vec2)
Modifies receiver to become sum of two vectors ( this = vec1 + vec2 ). Receiver's size is adjusted
v = vec([3,4]);
v1 = vec([1,2,3]);
v2 = vec([6,1,5]);
v.beSumOf(v1,v2); // v = Vector([7,3,8])
Parameters:
{Vector} vec1
1st vector of the sum
{Vector} vec2
2nd vector of the sum

beTProductOf(vec, mat)
Modifies receiver to become product of given vector and matrix ( this = vec^T * mat )
v= vec([5,6]);
v1 = vec([1,2,3]);
m = mat([[11,12,13],[21,22,23],[31,32,33]])
v.beTProductOf(v1,m); // v = Vector([146,152,158])
Parameters:
{Vector} vec
vector of multiplication
{Matrix} mat
matrix of multiplication

{bool} canMultiplyMat(mat)
Testing if receiver can multiply given matrix from left ( this^T * mat )
v = vec([1,2,3]);
m1 = mat([[11,12,13],[21,22,23]]);
m2 = mat([[11,12],[21,22],[31,32]]);
t1 = v.canMultiplyMat(m1); // t1 = true
t2 = v.canMultiplyMat(m2); // t2 = false
Parameters:
{Matrix} mat
matrix to be tested
Returns:
{bool} true if the multiplication is possible, false otherwise

{Vector} copied()
Returns copy of receiver
v1 = vec([1,2,3]);
v2 = v1;
v3 = v1.copied();
v1.set(1,6);
// v1; = Vector([1,6,3])
// v2; = Vector([1,6,3])
// v3; = Vector([1,2,3])
Returns:
{Vector} copy of receiver

copy()
Alias for copied(), see Vector#copied

<static> {Vector} Vector.create(arry)
Constructs new Vector from given array
v = Vector.create([1,2,3,4]); // v = Vector([1,2,3,4])
Parameters:
{[floats]} arry Optional, Default: []
array containing elements of new vector
Returns:
{Vector} new Vector object

{Vector} cross(vec)
Returns vector (cross) product of receiver and given vector. Both receiver and given vector have to be of length 3.
v1 = vec([1,2,3]);
v2 = vec([4,5,6]);
v3 = v1.cross(v2); // v3 = Vector([-3,6,-3])
Parameters:
{Vector} vec
2nd vector of multiplication
Returns:
{Vector} cross product of receiver and vec

decrSubVector(coeffs, vec)
Decrement subvector at defined positions of receiver (this[coeffs] -= vec)
v = vec([4,7,9,1,8,3,2,4,6,7,5,1,6,9]);
v.decrSubVector([2,3,6,8,9],vec([1.1,2.2,3.3,4.4,5.5])); // v = Vector([4,7,7.9,-1.2,8,3,-1.3,4,1.6,1.5,5,1,6,9])
Parameters:
{[floats]|Vector} coeffs
array containing coefficients to be decremented
{Vector} vec
vector to be subtracted

decrsv()
Alias for decrSubVector, see Vector#decrSubVector

{Matrix|undefined} diag(mat)
Returns matrix with receiver's elements on diagonal (if no argument is specified, seeVector#toDiagonalMatrix) or modifies receiver to contain diagonal elements of given matrix (if given matrix is specified, seeVector#beDiagonalFrom)
v = vec([6,7]);
m1 = mat([[1,2,3],[4,5,6],[7,8,9]]);
v.diag(m1); // v = Vector([1,5,9])
m2 = v.diag(); // m2 = Matrix([[1,0,0],[0,5,0],[0,0,9]])
Parameters:
{Matrix} mat Optional, Default: undefined
matrix whose diagonal is copied to receiver. If not specified, diagnal matrix is returned
Returns:
{Matrix|undefined} if no input parameter, returns diagonal matrix, otherwise nothing

{float} dot(vec, n)
Returns dot (inner) product of receiver and given vector
v1 = vec([1,2,3]);
v2 = vec([6,1,5]);
d2 = v1.dot(v2,2); // d2 = 8
Parameters:
{Vector} vec
vector for dot product
{int} n Optional, Default: 0
dot product will be made from first n elements. If not specified, zero or negative, all elements are used
Returns:
{float} dot product of receiver and vec from first n elements

{Matrix} dyadic(vec)
Returns dyadic (tensor, outer, direct,..) product of receiver and given vector
v1 = vec([1,2,3]);
v2 = vec([4,5,6]);
m = v1.dyadic(v2); // m = Matrix([[4,5,6],[8,10,12],[12,15,18]])
Parameters:
{Vector} vec
vector for multiplication
Returns:
{Matrix} dyadic product of receiver and vec

{Vector} elementsPermutation(coeffs, backward)
Returns permutated copy of receiver according to given coefficients
v1 = vec([7,9,6]);
v2 = v1.elementsPermutation([1,2,0]); // v2 = Vector([9,6,7])
v3 = v1.elementsPermutation([1,2,0],true); // v3 = Vector([6,7,9])
Parameters:
{[ints]|Vector} coeffs
coefficients of permutation. The content will be changed(!), use a copy if you need to preserve the content
{bool} backward Optional, Default: false
if false, receiver is permutated to given coefficients (forward). If true, from given coefficients (backward)
Returns:
{Vector} permutated copy of receiver

empty()
Empties receiver (resizes it to size 0)
v = vec([1,2,3,4]);
v.empty(); // v = Vector([])

{float} energyNorm(mat)
Returns energy norm of receiver (ret = sqrt(this*mat*this))
v = vec([1,2,3]);
m = mat([[8,0,0],[0,2,1],[0,1,3]]);
n = v.energyNorm(m); // n = 7.4162
Parameters:
{Matrix} mat
marix of norm
Returns:
{float} energy norm of receiver

fromArray(arry)
Sets elements of receiver form given Array object
v.fromArray([3,6,5,2]); // v = Vector([3,6,5,2])
Parameters:
{[floats]} arry
Array object containing new receiver elements

{float} get(e)
Coefficient access function, returns one element of receiver ( ret = this[r] ). Vector.get(e) is almost equivalent to direct Vector[e] access method
v = vec([4,7,2,4]);
a = v.get(1); // a = 7
a = v[1]; // a = 7
a = v.get(9); // a = null
a = v[9]; // a = undefined
Parameters:
{int} e
index of element to be returned
Returns:
{float} value of the e-th element

{Vector} getSubVector(coeffs)
Returns subvector of receiver. ret = this[coeffs]
v1 = vec([4,7,9,1,8,3,2,4,6,7,5,1,6,9]);
v2 = v1.getSubVector([2,3,6,8,9]); // v2 = Vector([9,1,2,6,7])
Parameters:
{[floats]|Vector} coeffs
array containing coefficients of desired subvector
Returns:
{Vector} desired subvector

getsv()
Alias for getSubVector, see Vector#getSubVector

iadd(vec)
Add given vector to receiver ( this += vec )
v1 = vec([1,2,3]);
v2 = vec([6,1,5]);
v1.iadd(v2); // v1 = Vector([7,3,8])
Parameters:
{Vector} vec
vector to be added

imulf(f)
Multiply receiver by float f ( this *= f )
v = vec([1,2,3]);
v.imulf(3); // v = Vector([3,6,9])
Parameters:
{float} f
float multiplier

incr(e, val)
Coefficient access function, increment one element of receiver ( this[r] += val ). Vector.incr(e,val) is much safer than direct Vector[e] += val (see example)
v = vec([4,7,2,4]);
v.incr(1,4.); // v = Vector([4,11,2,4])
v[1] += 4.; // v = Vector([4,15,2,4])
v.incr(9,4.); // nothing is done, out of bounds
// v = Vector([4,15,2,4])
/// v[9] += 4. would result into error (v[9] is not defined)
Parameters:
{int} e
index of element to be incremented
{float} val
value to be added

incrSubVector(coeffs, vec)
Increment subvector at defined positions of receiver (this[coeffs] += vec)
v = vec([4,7,9,1,8,3,2,4,6,7,5,1,6,9]);
v.incrSubVector([2,3,6,8,9],vec([1.1,2.2,3.3,4.4,5.5])); // v = Vector([4,7,10.1,3.2,8,3,5.3,4,10.4,12.5,5,1,6,9])
Parameters:
{[floats]|Vector} coeffs
array containing coefficients to be incremented
{Vector} vec
vector to be added

incrsv()
Alias for incrSubVector, see Vector#incrSubVector

{int} indexOf(val)
Returns index of first occurrence of given value
v = vec([5,6,1,2,6,8,6,2]);
i1 = v.indexOf(2); // i1 = 3
i2 = v.indexOf(6); // i2 = 1
i3 = v.indexOf(8); // i3 = 5
Parameters:
{float} val
value whose index will be returned
Returns:
{int} index of first occurrence of val

ineg()
Alias for neagete(), see Vector#negate

isEmpty()
Tests if receiver is empty (has size 0)
v = new Vector(3);
b1 = v.isEmpty(); // b1 = false
v.empty();
b2 = v.isEmpty(); // b2 = true
Returns:
true if receiver is empty, false otherwise

{bool} isEqualTo(vec)
Testing vectors equality
v1 = vec([1,2,3]);
v2 = vec([1,2,2.999999999]);
v3 = vec([1,2,1]);
t1 = v1.isEqualTo(v2); // t1 = true
t2 = v1.isEqualTo(v3); // t2 = false
Parameters:
{Vector} vec
vector to be compared with receiver
Returns:
{bool} true if this==vec, false otherwise

{bool} isSameSizeAs(vec)
Testing vectors size equality
a = vec([1,2,3,4]);
b = vec([5,6,7,8,9,10,11,12]);
c = vec([13,14,15,16]);
t1 = a.isSameSizeAs(b); // t1 = false
t2 = a.isSameSizeAs(c); // t2 = true
Parameters:
{Vector} vec
vector to be tested
Returns:
{bool} true if vec and receiver has same size, false otherwise

isub(vec)
Subtract given vector to receiver ( this -= vec )
v1 = vec([1,2,3]);
v1.isub(v2); // v1 = Vector([-5,1,-2])
Parameters:
{Vector} vec
vector to be subtracted

{float} max()
Returns maximal value of receiver elements
v = vec([1,-4,3,2]);
m = v.max(); // m = 3
Returns:
{float} maximal value of receiver elements

{float} min()
Returns minimal value of receiver elements
v = vec([3,3,1,2]);
m = v.min(); // m = 1
Returns:
{float} minimal value of receiver elements

{Vector} mul(what)
Returns product of receiver and given multiplier (float or Matrix)
v1 = vec([1,2,3]);
v2 = v1.mul(mat([[11,12,13],[21,22,23],[31,32,33]])); // v2 = Vector([146,152,158])
v3 = v1.mul(3); // v3 = Vector([3,6,9])
Parameters:
{Matrix|float} what
matrix or float to multiply
Returns:
{Vector} copy of receiver multiplied by what

{Vector} mulf(f)
Returns receiver multiplied by float f ( ret = this * f )
v1 = vec([1,2,3]);
v2 = v1.mulf(3); // v2 = Vector([3,6,9])
Parameters:
{float} f
float multiplier
Returns:
{Vector} copy of receiver multiplied by f

{Vector} mulm(mat)
Returns product of receiver and given matrix ( ret = this^T * mat )
v1 = vec([1,2,3]);
m = mat([[11,12,13],[21,22,23],[31,32,33]])
v2 = v1.mulm(m); // v2 = Vector([146,152,158])
Parameters:
{Matrix} mat
matrix to multiply
Returns:
{Vector} copy of receiver multiplied by mat

neg()
Alias for negated(), see Vector#negated

negate()
Negate receiver ( ret *= -1., ret = -ret )
v1 = vec([1,2,3]);
v1.negate(); // v1 = Vector([-1,-2,-3])

{Vector} negated()
Returns negative of receiver ( ret = -this )
v1 = vec([1,2,3]);
v2 = v1.negated(); // v2 = Vector([-1,-2,-3])
Returns:
{Vector} negative of receiver

{float} norm()
Returns (Euclidean) norm of receiver (ret = sqrt(this^T * this) )
v = vec([4,2,4]);
n = v.norm(); // n = 6
Returns:
{float} Euclidean norm of receiver

normalize()
Normlize receiver ( this.norm()=1. )
v = vec([4,2,4]);
v.normalize(); // v = Vector([0.6666,0.3333,0.6666])

{Vector} normalized()
Returns normalized copy of receiver ( ret.norm()=1. )
v1 = vec([4,2,4]);
v2 = v1.normalized(); // v2 = Vector([0.6666,0.3333,0.6666])
Returns:
{Vector} normalized copy of receiver

one()
Alias for beFullOfOnes(), see Vector#beFullOfOnes

<static> {Vector} Vector.Ones(nElements)
Creates a vector full of ones
v = Vector.Ones(6); // v = Vector([1,1,1,1,1,1])
Parameters:
{int} nElements Optional, Default: 0
number of elements
Returns:
{Vector} new vector full of zeros

otimes()
Alias for dyadic() (inspired by LaTeX symbol for dyadic product operation), see Vector#dyadic

outer()
Alias for dyadic(), see Vector#dyadic

permuteElements(coeffs, backward)
Permute elements of receiver according to given coefficients
v = vec([7,9,6]);
v.permuteElements([1,2,0]); // v = Vector([9,6,7])
v.permuteElements([1,2,0],true); // v = Vector([7,9,6])
Parameters:
{[ints]|Vector} coeffs
coefficients of permutation
{bool} backward Optional, Default: false
if false, receiver is permutated to given coefficients (forward). If true, from given coefficients (backward)

resize(nElements)
Resize receiver according to given size (delete extra elements or add zero elements)
v1 = vec([4,7,9,1,7,3])
v2 = vec([4,6]);
v1.resize(4); // v1 = Vector([4,7,9,1])
v2.resize(4); // v2 = Vector([4,6,0,0])
Parameters:
{int} nElements
new number of elements

{Vector} resized(nElements)
Returns resized copy of receiver according to given size (delete extra elements or add zero elements)
v1 = vec([4,7,9,1]);
v2 = v1.resized(2); // v2 = Vector([4,7])
v3 = v1.resized(6); // v3 = Vector([4,7,9,1,0,0])
Parameters:
{int} nElements
new number of elements
Returns:
{Vector} resized copy of receiver

set(e, val)
Coefficient access function, sets one element of receiver ( this[r] = val ). Vector.set(e) is almost equivalent to direct Vector[e] access method
v = vec([4,7,2,4]);
v.set(1,68.); // v = Vector([4,68,2,4])
v[1] = 43.; // v = Vector([4,43,2,4])
v.set(9,68.); // nothing is done - out of bounds
// v = Vector([4,43,2,4])
v[9] = 43.;
/// new object this[9] is created, but no reflection to actual Vector is made
// v = Vector([4,43,2,4])
Parameters:
{int} e
index of element to be set
{float} val
value to be set

setSubVector(coeffs, vec)
Sets subvector at defined positions of receiver ( this[coeffs]=vec )
v = vec([4,7,9,1,8,3,2,4,6,7,5,1,6,9]);
v.setSubVector([2,3,6,8,9],vec([1.1,2.2,3.3,4.4,5.5])); // v = Vector([4,7,1.1,2.2,8,3,3.3,4,4.4,5.5,5,1,6,9])
Parameters:
{[floats]|Vector} coeffs
array containing coefficients to be set
{Vector} vec
vector to be set

setsv()
Alias for setSubVector, see Vector#setSubVector

{int} size()
Returns size (numer of elements) of receiver
v = vec([1,5,8,2]);
s = v.size(); // s = 4
Returns:
{int} length (number of elements) of receiver

{float} squaredEnergyNorm(mat)
Returns squared energy norm of receiver (ret = this^T*mat*this)
v = vec([1,2,3]);
m = mat([[8,0,0],[0,2,1],[0,1,3]]);
n = v.squaredEnergyNorm(m); // n = 55
Parameters:
{Matrix} mat
marix of norm
Returns:
{float} squared energy norm of receiver

{float} squaredNorm()
Returns squared (Euclidean) norm of receiver (ret = this.^T * this )
v = vec([4,2,4]);
n = v.squaredNorm(); // n = 36
Returns:
{float} squared Euclidean norm of receiver

{Vector} sub(vec)
Returns difference of receiver and vector ( ret = this - vec )
v1 = vec([1,2,3]);
v2 = vec([6,1,5]);
v4 = v1.sub(v2); // v4 = Vector([-5,1,-2])
Parameters:
{Vector} vec
2nd vector of subtraction
Returns:
{Vector} difference of receiver and vec

{float} sum()
Returns sum of all elements of receiver
v = vec([1,2,3]);
s = v.sum(); // s = 6
Returns:
{float} sum of all elements of receiver

swapElements(e1, e2)
Swaps two elements of receiver
v = vec([1,2,3,4,5,6,7]);
v.swapElements(1,4); // v = Vector([1,5,3,4,2,6,7])
Parameters:
{int} e1
index of first element to swap
{int} e2
index of second element to swap

tensor()
Alias for dyadic(), see Vector#dyadic

{[floats]} toArray()
Returns elements of receiver as an Array object
v =vec([3,4,5,6]);
s = v.toArray(); // s = [3,4,5,6]
Returns:
{[floats]} Array object containing receiver's elements

{Matrix} toDiagonalMatrix()
Returns matrix with receiver's elements on its diagonal
v = vec([1,2,3]);
m = v.toDiagonalMatrix(); // m = Matrix([[1,0,0],[0,2,0],[0,0,3]])
Returns:
{Matrix} diagonal matrix with receiver's elements on its diagonal

{string} toString()
Returns string representation of receiver
v1 = vec([0.5999999999999999,2,3]);
s = v1.toString(); // s = 'Vector([ 1, 2, 3 ])'
Returns:
{string} string representation of receiver

<static> {Vector} Vector.UnitX()
Creates unit vector in x direction
v = Vector.UnitX(); // v = Vector([1,0,0])
Returns:
{Vector} unit x vector

<static> {Vector} Vector.UnitY()
Creates unit vector in y direction
v = Vector.UnitY(); // v = Vector([0,1,0])
Returns:
{Vector} unit y vector

<static> {Vector} Vector.UnitZ()
Creates unit vector in z direction
v = Vector.UnitZ(); // v = Vector([0,0,1])
Returns:
{Vector} unit z vector

x()
Alias for mul(), see Vector#mul

zero()
Zeroes all elements of receiver
v = vec([1,2,3,4]);
v.zero(); // v = Vector([0,0,0,0])

<static> {Vector} Vector.Zeros(nElements)
Creates a vector full of zeros
v = Vector.Zeros(4); // v = Vector([0,0,0,0])
Parameters:
{int} nElements Optional, Default: 0
number of elements
Returns:
{Vector} new vector full of zeros

Documentation generated by JsDoc Toolkit 2.4.0 on Wed Dec 12 2012 09:21:39 GMT+0100 (CET)