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()
Vector implementation
Field Summary
Field Attributes Field Name and Description
 
 
<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
Method Summary
Method Attributes Method Name and Description
 
add(vec)
Returns sum of receiver and vector ( ret = this + vec )
 
appendItems(items)
Appends given float/vector to the end of receiver
 
Testing if receiver can multiply given matrix ( this^T * mat )
 
copy()
Returns copy of receiver
<static>  
Vector.create(arry)
Constructs new Vector from given array
 
cross(vec)
Returns vector (cross) product of receiver and given vector.
 
decrsv(items, vec)
Decrement subvector to defined positions of receiver
 
diag()
Alias for toDiagonalMatrix(), see Vector#toDiagonalMatrix
 
dot(vec, n)
Dot product of receiver and given vector
 
fromArray(arry)
Sets elements of receiver form given array
 
get(r)
Returns one element of receiver ( ret = this[r] ) - numbering from 0
 
getsv(items)
Returns subvector of receiver - numbering from 0
 
iadd(vec)
Add given vector to receiver ( this += vec )
 
imulf(f)
Multiply receiver by float f ( this *= f )
 
incr(r, val)
Increment one element of receiver ( this[r] += val ) - numbering from 0
 
incrsv(items, vec)
Increment subvector to defined positions of receiver
 
ineg()
Alias for neagete(), see Vector#negate
 
isEqualTo(vec)
Testing vector equality
 
Testing vector's size equality
 
isub(vec)
Substract given vector to receiver ( this -= vec )
 
itemPermutation(indx, backward)
Returns permutated copy of receiver according to given indices
 
mul(what)
Returns product of receiver and given mltiplier (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 (Eucleidian) norm of receiver (ret = sqrt(this.dot(this)) )
 
Normlize receiver
 
Returns normalized copy of receiver
<static>  
Vector.Ones(nItems)
Creates a vector full of ones
 
outer(vec)
Returns outer (dyadic, tensor, .
 
permuteItems(indx, backward)
Permute items of receiver according to given indices
 
resize(nItems)
Resize receiver according to given size (delete extra elements or add zero elements)
 
resized(nItems)
Returns resized copy of receiver according to given size (delete extra elements or add zero elements)
 
set(r, val)
Set one element of receiver ( this[r] = val ) - numbering from 0
 
setsv(items, vec)
Set subvector to defined positions of receiver
 
size()
Returns size (numer of elements) of receiver
 
Returns squared (Eucleidian) norm of receiver (ret = this.dot(this) )
 
sub(vec)
Returns difference of receiver and vector ( ret = this - vec )
 
swapItems(r1, r2)
Swaps two items (items, elements.
 
Returns elements of receiver as an array
 
Returns matrix with receiver's elements on its diagonal
 
Returns string representation of receiver
 
x(what)
Alias for mul(), see Vector#mul
 
zero()
Zeros all elements of receiver
<static>  
Vector.Zeros(nItems)
Creates a vector full of zeros
Class Detail
Vector()
Vector implementation
Field Detail
nItems

theArray

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

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

<static> {Vector} Vector.UnitZ
Creates unit vector in z direction
v = UnitX // v = Vector([0,0,1])
Method Detail
{Vector} add(vec)
Returns sum of receiver and vector ( ret = this + vec )
v1 = vec([1,2,3]);
v2 = vec([6,1,5]);
v3 = v1.add(v2); // v3 = Vector([7,3,8])
Parameters:
{Vector} vec
vector to be added
Returns:
{Vector} sum of receiver and vec

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

{bool} canMultiplyMat(mat)
Testing if receiver can multiply given matrix ( this^T * mat )
v = vec([1,2,3]);
m1 = mat([[11,12,13],[21,22,23]]);
m2 = [[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} copy()
Returns copy of receiver
v1 = vec([1,2,3]);
v2 = v1;
v3 = v1.copy();
v1.set(1,6);
// v1; = Vector([1,6,3])
// v2; = Vector([1,6,3])
// v3; = Vector([1,2,3])
Returns:
{Vector} copy of receiver

<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); // v = Vector([-3,6,-3])
Parameters:
{Vector} vec
vector for multiplication
Returns:
{Vector} cross product of receiver and vec

decrsv(items, vec)
Decrement subvector to defined positions of receiver
v = vec([4,7,9,1,8,3,2,4,6,7,5,1,6,9]);
v.decrsv([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} items
array containing row indices to be decremented - numbering from 0
{Vector|[floats]} vec
vector to be substracted

diag()
Alias for toDiagonalMatrix(), see Vector#toDiagonalMatrix

{float} dot(vec, n)
Dot product of receiver and given vector
v1 = vec([1,2,3]);
v2 = vec([6,1,5]);
d = v1.dot(v2,2); // d = 8
Parameters:
{Vector} vec
vector for dot product
{int} n Optional, Default: 0
dot prodact 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

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

{float} get(r)
Returns one element of receiver ( ret = this[r] ) - numbering from 0
v = vec([4,7,2,4]); a = v.get(1); // a = 7
Parameters:
{int} r
index of row (element) to be get (numbering from 0)
Returns:
{float} value of the r-th element

{Vector} getsv(items)
Returns subvector of receiver - numbering from 0
v1 = vec([4,7,9,1,8,3,2,4,6,7,5,1,6,9]);
v2 = v1.getsv([2,3,6,8,9]); // v2 = Vector([9,1,2,6,7])
Parameters:
{[floats]|Vector} items
array containing row indices of desired subvector - numbering from 0
Returns:
{Vector} desired subvector

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(r, val)
Increment one element of receiver ( this[r] += val ) - numbering from 0
v = vec([4,7,2,4]); v.incr(1,4); // v = vec([4,11,2,4])
Parameters:
{int} r
index of row (element) to be incremented (numbering from 0)
{float} val
value to be add

incrsv(items, vec)
Increment subvector to defined positions of receiver
v = vec([4,7,9,1,8,3,2,4,6,7,5,1,6,9]);
v.incrsv([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} items
array containing row indices to be incremented - numbering from 0
{Vector|[floats]} vec
vector to be added

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

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

{bool} isSameSizeAs(vec)
Testing vector's 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); // t1 = true
Parameters:
{Vector} vec
vector to be tested
Returns:
{bool} true if vec and receiver has same size, false otherwise

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

{Vector} itemPermutation(indx, backward)
Returns permutated copy of receiver according to given indices
v1 = vec([7,9,6]);
v2 = v1.itemPermutation([1,2,0]); // v2 = Vector([9,6,7])
v3 = v1.itemPermutation([1,2,0],true); // v3 = Vector([6,7,9])
Parameters:
{[ints]|Vector} indx
indices of permutation
{bool} backward Optional, Default: false
if false, receiver is permutated to given indices (forward). If true, from given indices (backward)
Returns:
{Vector} permutated copy of receiver

{Vector} mul(what)
Returns product of receiver and given mltiplier (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 (Eucleidian) norm of receiver (ret = sqrt(this.dot(this)) )
v = vec([4,2,4]);
n = v.norm(); // n = 6
Returns:
{float} Eucleidian norm of receiver

normalize()
Normlize receiver
v = vec([4,2,4]);
v.normalize(); // v = Vector([0.6666,0.5,0.66666])

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

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

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

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

resize(nItems)
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} nItems
new number of items

{Vector} resized(nItems)
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} nItems
new number of items
Returns:
{Vector} resized copy of receiver

set(r, val)
Set one element of receiver ( this[r] = val ) - numbering from 0
v = vec([4,7,2,4]); v.set(1,68); // v = Vector([4,68,2,4])
Parameters:
{int} r
index of row (element) to be set (numbering from 0)
{float} val
value to be set

setsv(items, vec)
Set subvector to defined positions of receiver
v = vec([4,7,9,1,8,3,2,4,6,7,5,1,6,9]);
v.setsv([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} items
array containing row indices to be set - numbering from 0
{Vector|[floats]} vec
vector to be set

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

{float} squaredNorm()
Returns squared (Eucleidian) norm of receiver (ret = this.dot(this) )
v = vec([4,2,4]);
n = v.squaredNorm(); // n = 36
Returns:
{float} squared Eucleidian 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]);
v3 = v1.sub(v2); // v3 = Vector([-5,1,-2])
Parameters:
{Vector} vec
vector to be substracted
Returns:
{Vector} difference of receiver and vec

swapItems(r1, r2)
Swaps two items (items, elements..) of receiver - numbering from 0
v = vec([1,2,3,4,5,6,7]);
v.swapItems(1,4); // v = Vector([1,5,3,4,2,6,7])
Parameters:
{int} r1
index of first row to swap - numbering from 0
{int} r2
index of second row to swap - numbering from 0

{[floats]} toArray()
Returns elements of receiver as an array
v =vec([3,4,5,6]); s = v.toArray(); // s = [3,4,5,6]
Returns:
{[floats]} array 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([1,2,3]);
alert(v1); // alerts "Vector([ 1, 2, 3 ])"
Returns:
{string} string representation of receiver

x(what)
Alias for mul(), see Vector#mul
Parameters:
what

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

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

Documentation generated by JsDoc Toolkit 2.4.0 on Sun Oct 23 2011 11:05:30 GMT+0200 (CEST)