Vector

A column vector.

The interface is modeled on that provided by Scalala (which in turn was modeled on Matlab), with the exception that all operations are executed immediately. This provides a more natural interface, at the cost of suboptimal performance since linear algebra libraries are not used.

In the following descriptions, "v" represents a vector, "s" a scalar, "m" a matrix, "b" a boolean, "i" and integer, "d" a double. The update operations, such as "+=", update the elements of the vector in place.

Constructors:
  new Vector(i)              (create vector of length i)
  new Vector(d*)             (create vector with elements d)
  copy           => v        (create a copy of a vector)
  length         => i        (number of elements in vector)

Vector operations:
  map(f: d => d)     => v        (map a Vector by applying f to each element)
  mapSelf(f: d => d)			    (use f to map each element in place)
  reduce((d, d)=> d) => d        (reduce a Vector to a scalar)
  randomize                      (initialize to random values in [0, 1))

Vector / Scalar operations:
  v + s   => v          (add scalar to each element to produce a new matrix)
  v += s                (add scalar to all elements of matrix in-place)
  v - s   => v
  v -= s
  v * s   => v
  v *= s
  v / s   => v
  v /= s
  -v      => v          (map each element to new matrix my multiplying by -1)
  v := s                (assign scalar to all elements of the matrix)

Vector / Vector operations:
  v + v          => v
  v += v
  v - v          => v
  v -= v
  v :* v         => v   (element-wise multiplication)
  v :*= v               (element-wise multiplication in-place)
  v :/ v         => v   (element-wise right division)
  v :/= n               (element-wise right division in-place)
  v :\ v         => v   (element-wise left division)
  v :\= v               (element-wise left division in-place)
  v1 === v2		=> b   (m1 and m2 have same shape, identical elements)
  v1 !=== v2     => b
  v1 ~== v2
  v1 !~== v2
  v1 := v2			   (assign elements of v2 to v1)


--------------------
  v1 dot v2           => d   (dot product of two vectors)
  v1 outerProduct v2  => m   (outer product of two vectors)
  v concat v2         => v   (concatentate two vectors)


 -------------------------------------------------




Matrix conversions:
  shape(i, i)           => m (create matrix)
  rectangularize        => m (create squarest matrix possible)

Miscellaneous:
  normL1     => d       (L1 norm of the vector)
  normL2     => d       (L2 norm of the vector)
  argmax     => i       (index of largest element)
  print                 (print out a vector for debugging)

Annotations: @SerialVersionUID()

Linear Supertypes

Tensor, Serializable, Serializable, AnyRef, Any

Known Subclasses

Dyad2D, SymmetricTensor

Instance Constructors

new Vector(tensor: Tensor)

Create a vector from a 1-dimensional tensor.
new Vector(e: Float*)

Create a vector from one or more Floats.
new Vector(length: Int)

Create a vector of size "length".
new Vector(data: Array[Float])

Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def !===(v: Vector): Boolean
def !~==(v: Vector): Boolean
final def ##(): Int

Definition Classes
AnyRef → Any
def *(that: Matrix): Matrix
def *(s: Float): Vector
def *=(s: Float): Unit
def +(v: Vector): Vector
def +(s: Float): Vector
def +=(v: Vector): Unit
def +=(s: Float): Unit
def -(v: Vector): Vector
def -(): Vector
def -(s: Float): Vector
def -=(v: Vector): Unit
def -=(s: Float): Unit
def /(s: Float): Vector
def /=(s: Float): Unit
def :*(v: Vector): Vector
def :*=(v: Vector): Unit
def :/(v: Vector): Vector
def :/=(v: Vector): Unit
def :=(v: Vector): Unit
def :=(s: Float): Unit
def :\(v: Vector): Vector
def :\=(v: Vector): Unit
def <(v: Float): Vector
def <=(v: Float): Vector
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def ===(v: Vector): Boolean
def >(v: Float): Vector
def >=(v: Float): Vector
def abs: Vector
def apply(index: Int): Float
def argmax: Int
final def asArray: Array[Float]

View this Vector as an array with full read and write access.
final def asInstanceOf[T0]: T0

Definition Classes
Any
def canEqual(other: Any): Boolean

Helper for equals.
Helper for equals.

Definition Classes
Tensor
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def concat(that: Vector): Vector
def copy: Vector
def dot(that: Vector): Float

Compute the dot product of "this" and "that".
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(other: Any): Boolean

Test "this" and "other" for deep equality.
Test "this" and "other" for deep equality. Allows "==" to work.

Definition Classes
Tensor → AnyRef → Any
def expand(bigSize: Int, borderFill: Boolean): Vector

Expand the vector, optionally extending the border into the expanded region.
Expand the vector, optionally extending the border into the expanded region. This operation is a key part of the FFT. The new vector is of size "bigSize" element (0) of this is anchored at (0) in the larger vector. If "borderFill" is true, then the two edges of the vector are extended evenly in all directions, as though the bigger vector were actually a loop with opposite edges touching.
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
def flip: Vector

Reverses the order of the elements in this
def fold(initValue: Float)(f: (Float, Float) ⇒ Float): Float
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def getData: Array[Float]

Get the data in the tensor, flattened to a linear array.
Get the data in the tensor, flattened to a linear array.

Attributes
protected[cogx]
def hashCode(): Int

Required because of overriding equals.
Required because of overriding equals.

Definition Classes
Tensor → AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def length: Int

The number of "numbers" held in the tensor.
The number of "numbers" held in the tensor.

Definition Classes
Tensor
def map(f: (Float) ⇒ Float): Vector
def mapSelf(f: (Float) ⇒ Float): Unit
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def normL1: Float
def normL2: Float
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def outerProduct(that: Vector): Matrix
def print: Unit
def randomize: Vector
def read(index: Int): Float

Tensor accessor.
Tensor accessor.

Definition Classes
Vector → Tensor
def reciprocal: Vector
def rectangularize: Matrix
def rectify: Vector
def reduce(f: (Float, Float) ⇒ Float): Float

Reduce a Vector to a scalar using "f".
def sgn: Vector
def shape(rows: Int, columns: Int): Matrix
def shape: geometry.Shape

Shape of the vector.
Shape of the vector.

Definition Classes
Vector → Tensor
def shiftCyclic(delta: Int): Vector

Rotates the elements of a vector, wrapping around the left side to the right side.
Rotates the elements of a vector, wrapping around the left side to the right side.
The rotation is specified by "delta"; for example, delta=2 would cause the element at location (0) to be moved to location (2). Returns the rotated vector. This was added in support of the LowPassFunction kernel, and because Matrix has a similar method. Not currently tested. -RJC XXX
def size: Int
def sort: Vector

Sort vector elements in ascending order (creates new Vector, "this" unchanged).
def subvector(indexRange: Range): Vector
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toArray: Array[Float]

Convert Vector to an array of doubles (copy).
def toString(): String

Definition Classes
Vector → AnyRef → Any
def transpose: Matrix
def trim(smallSize: Int): Vector

Trim "this" to a Vector of length smallSize.
def unary_-(): Vector
def update(index: Int, value: Float): Unit
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
def ~==(v: Vector): Boolean

Related Docs: object Vector | package real

class Vector extends Tensor with Serializable

Instance Constructors

new Vector(tensor: Tensor)

new Vector(e: Float*)

new Vector(length: Int)

new Vector(data: Array[Float])

Value Members

final def !=(arg0: Any): Boolean

def !===(v: Vector): Boolean

def !~==(v: Vector): Boolean

final def ##(): Int

def *(that: Matrix): Matrix

def *(s: Float): Vector

def *=(s: Float): Unit

def +(v: Vector): Vector

def +(s: Float): Vector

def +=(v: Vector): Unit

def +=(s: Float): Unit

def -(v: Vector): Vector

def -(): Vector

def -(s: Float): Vector

def -=(v: Vector): Unit

def -=(s: Float): Unit

def /(s: Float): Vector

def /=(s: Float): Unit

def :*(v: Vector): Vector

def :*=(v: Vector): Unit

def :/(v: Vector): Vector

def :/=(v: Vector): Unit

def :=(v: Vector): Unit

def :=(s: Float): Unit

def :\(v: Vector): Vector

def :\=(v: Vector): Unit

def <(v: Float): Vector

def <=(v: Float): Vector

final def ==(arg0: Any): Boolean

def ===(v: Vector): Boolean

def >(v: Float): Vector

def >=(v: Float): Vector

def abs: Vector

def apply(index: Int): Float

def argmax: Int

final def asArray: Array[Float]

final def asInstanceOf[T0]: T0

def canEqual(other: Any): Boolean

def clone(): AnyRef

def concat(that: Vector): Vector

def copy: Vector

def dot(that: Vector): Float

final def eq(arg0: AnyRef): Boolean

def equals(other: Any): Boolean

def expand(bigSize: Int, borderFill: Boolean): Vector

def finalize(): Unit

def flip: Vector

def fold(initValue: Float)(f: (Float, Float) ⇒ Float): Float

final def getClass(): Class[_]

def getData: Array[Float]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

def length: Int

def map(f: (Float) ⇒ Float): Vector

def mapSelf(f: (Float) ⇒ Float): Unit

final def ne(arg0: AnyRef): Boolean

def normL1: Float

def normL2: Float

final def notify(): Unit

final def notifyAll(): Unit

def outerProduct(that: Vector): Matrix

def print: Unit

def randomize: Vector

def read(index: Int): Float

def reciprocal: Vector

def rectangularize: Matrix

def rectify: Vector

def reduce(f: (Float, Float) ⇒ Float): Float

def sgn: Vector

def shape(rows: Int, columns: Int): Matrix

def shape: geometry.Shape