Class Vector
Represents a vector (1D matrix) of real (floating point) numbers
Defined in: jsmatrix.src.js.
Constructor Attributes | Constructor Name and Description |
---|---|
Vector(nElements)
Vector implementation
|
Field Attributes | Field Name and Description |
---|---|
Number of vector elements
|
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.
|
|
beDiagonalFrom(mat)
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
|
|
beNegativeOf(vec)
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 )
|
|
canMultiplyMat(mat)
Testing if receiver can multiply given matrix from left ( this^T * mat )
|
|
copied()
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)
|
|
decrsv()
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
|
|
empty()
Empties receiver (resizes it to size 0)
|
|
energyNorm(mat)
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.
|
|
getsv()
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)
|
|
incrsv()
Alias for incrSubVector, see Vector#incrSubVector
|
|
indexOf(val)
Returns index of first occurrence of given value
|
|
ineg()
Alias for neagete(), see Vector#negate
|
|
isEmpty()
Tests if receiver is empty (has size 0)
|
|
isEqualTo(vec)
Testing vectors equality
|
|
isSameSizeAs(vec)
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()
Negate receiver ( ret *= -1.
|
|
negated()
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
|
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
|
|
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 )
|
|
setsv()
Alias for setSubVector, see Vector#setSubVector
|
|
size()
Returns size (numer of elements) of receiver
|
|
squaredEnergyNorm(mat)
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
|
|
tensor()
Alias for dyadic(), see Vector#dyadic
|
|
toArray()
Returns elements of receiver as an Array object
|
|
Returns matrix with receiver's elements on its diagonal
|
|
toString()
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])
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])
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])
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])
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])
{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