NetVectorC - Extension of VectorC class to add routines for neural networks

User Documentation

Centre for Vision, Speech & Signal Processing

Comments:

Parent Classes:

VectorC

Methods:

NetVectorC(const SizeT dim = 0): Constructor of an vector of the specified size 'dim'. If dim is equal to 0, the vector is empty.
NetVectorC(const SizeT dim,const RealT a): Constructor of the vector of the specified size 'dim'. If 'dim' is equal to 0, the vector is empty. All elements of the vector are set to be 'a'.
NetVectorC(const NetVectorC & vv): copy constructor
NetVectorC(const VectorC & vv): copy constructor for VectorC
NetVectorC(RealT * arr,SizeT dim): Creates the vector of 'dim' elements. The vector is attached to the RealT array. If the array is located on the stack, the vector is not valid outside the array defining block.
NetVectorC(istream & s): constructor from the input stream 's'
NetVectorC Copy() const: physical copy of the object
NetVectorC & operator=(const NetVectorC & vv)
~NetVectorC(): destructor

Operators
NetVectorC operator+(const NetVectorC & b) const
NetVectorC operator-(const NetVectorC & b) const
NetVectorC operator*(const NetVectorC & b) const
NetVectorC & operator+=(const NetVectorC & b)
NetVectorC & operator-=(const NetVectorC & b)
NetVectorC & operator-=(const RealT alfa)
NetVectorC & operator*=(const NetVectorC & b)
NetVectorC & operator/=(const RealT alfa)
NetVectorC operator-(const RealT b) const
NetVectorC operator*(const RealT alfa) const
NetVectorC & operator*=(const RealT alfa)
NetVectorC & SubtractElem(const RealT alfa): Additional Methods
void SetRandom(RealT low,RealT high): Set elements to random
RealT SqrSum() const: Square all elements and then sum them
void LogSig(): Take the log sig function of values
NetVectorC Logistic(): Returns vec * (1 - vec)
IndexT MinIndex() const: Return the minimum index of vector
RealT MinValue() const: Return the minimum value in a vector
void RemElement(IntT ind): Return a new vector minus the element at index ind

#include "amma/Vector.hh"

VectorC Copy() const: physical copy of the object
Access to the element, to the vector. -------------------------------------
const VectorC & Vector() const: access to the constant object
VectorC & Vector(): access to the object
const VectorC & Point() const: access to the constant object
VectorC & Point(): access to the object
SizeT Dim() const: returns the number of items in the vector.
VectorC SubVector(const SizeT n) const: Returns the subvector created from the first 'n' elements of this vector. Set elements. -------------
VectorC & SetZero(): set all vector items to be 0
VectorC & Set(RealT x): sets vector items to x
VectorC & SetLast(RealT f): set the last element to be 'f'
VectorC & Set(const VectorC & vec): set vector according to another one
VectorC & Set(const VectorC & vec,const IndexT n): Sets the first 'n' items of this vector according to the vector 'vec'.
VectorC & Set(const IndexT i,const VectorC & vec,const IndexT n): Sets the first 'n' items beginning from the i-th one of this vector according to the vector 'vec'.
VectorC & Set(const MatrixC & mat): set items according to "mat" items
VectorC & SetUpperHalf(const MatrixC & mat): set items according to "mat" items in its upper half
VectorC & SetOddEven(const MatrixC & mat): set items according to "mat" items with odd or even indexes only
VectorC & SetOddEvenUpperHalf(const MatrixC & mat): set items according to "mat" items with odd or even indexes only in its upper half
VectorC & SetRandom(): set elements to be random
VectorC & SetRandom(RealT lo,RealT hi): set elements to be uniformly random between lo and hi
VectorC & Swap(IndexT i,IndexT j): Swaps the elements with the indexex 'i' and 'j'.
VectorC Join(const VectorC & Oth) const: Joint *this and 'Oth' vector into a new larger vector. The new vector contains this vector first followed by the 'Oth' vector. Arithmetic Operations. ----------------------
VectorC operator+(const VectorC & b) const: Returns the sum of two vectors.
VectorC operator-(const VectorC & b) const: Returns the diference between this vector and the vector 'b'.
VectorC operator*(const RealT alfa) const: Returns the multiplication of this vector by the scalar 'alpha'.
VectorC operator*(const VectorC & b) const: Returns the vector whose elements are the results of multiplication of this vector by the vector 'b' element by element.
VectorC operator/(const RealT alfa) const: Returns the division of this vector by the scalar 'alpha'.
VectorC operator/(const VectorC & b) const: Returns the vector whose elements are the results of division of this vector by the vector 'b' element by element.
VectorC & operator+=(const VectorC & b): add the vector 'b' to the vector
VectorC & operator+=(const RealT alpha): add the scalar to each element of the vector
VectorC & operator-=(const VectorC & b): subtract the vector 'b' from the vector
VectorC & operator-=(const RealT alpha): subtract the scalar from each element of the vector
VectorC & operator*=(const RealT alpha): multiply the vector by the scalar 'alpha'
VectorC & operator/=(const RealT alpha): divide the vector by the scalar 'alpha'
VectorC & operator/=(const VectorC & vec): (*this)[index] = (*this)[index]/vec[index]
VectorC & SetMul(const MatrixC & mat,const VectorC & vec): the vector is the result of the multiplication 'mat' * 'vec'
VectorC & operator*=(const VectorC & b): multiplication (*this)[i] *= b[i]
RealT TMul(const VectorC & b) const: multiplication 'RealT' = (*this).T() * b
MatrixC MulT(const VectorC & b) const: Multiplication 'MatrixC' = (*this) * b.T(). Vector Operations. ------------------
RealT Dot(const VectorC & v) const: scalar product of vectors
VectorC Cross(const VectorC & v) const: vector product of vectors
RealT Cross3(const VectorC & v) const: 3rd coor of crossproduct
MatrixC OuterP() const: The outer product of this vector with itself. In fact, the implementation is the same one for the member function MulT().
MatrixC OuterP(const VectorC & b) const: In fact, the implementation is the same one for the member function MulT().
RealT MakeUnit(): The vector is divided by its modulus. The original modulus is returned.
RealT Modulus() const: modulus of the vector
RealT SqrEuclidDistance(const VectorC & point) const: Returns the square of Euclid distance between this point and 'point'. Useful functions. -----------------
IndexT MaxIndex() const: Returns the index of the maximum element.
IndexT FirstSmallerIndex(const RealT thr) const: Returns the index of the first element which is smaller than the threshold 'thr'. If the vector does not contain an element smaller than 'thr' the return value is set to be a size of the vector (the index of the last element + 1).
IndexT FirstZeroIndex() const: Returns the index of the first zero element. If the vector does not contain an zero element the return value is set to be a size of the vector (the index of the last element +1).
RealT Sum() const: Returns the sum all elements of the vector.
RealT Product() const: Returns the product of all elements of the vector.
VectorC & Sqrt(): All elements of the vector are changed to their square root values. It is assumed that all elements of the vector are positive or zero.
VectorC & Reciprocal(): All elements of the vector are changed to their reciprocal values. It is assumed that all elements of the vector differs from zero.
VectorC SortStraight(): The map of indexes is returned.
VectorC & FixSmallToBeZero(RealT thr = 1e-12): All element whose absolute value is smaller than 'thr' are changed to be zero.

#include "amma/ReSArr1.hh"

RealSArray1dC Copy() const: Creates a new physical copy of the real array. Special operations. -------------------
RealSArray1dC operator*(const RealT & r) const: Multiples every item of the array by the real number 'r'.
const RealSArray1dC & operator+=(const RealSArray1dC & arr): Adds the array 'arr' to this array. The operation is performed on the overlapping part of the arrays only. The function returns this array.
const RealSArray1dC & operator-=(const RealSArray1dC & arr): Subtracts the array 'arr' to this array. The operation is performed on the overlapping part of the arrays only. The function returns this array.
const RealSArray1dC & operator*=(const RealT & r): Multiplies each element of this array by the real number 'r'.
const RealSArray1dC & operator/=(const RealT & r): Divides each element of this array by the real number 'r'.
void SetZero(): Sets all items of the array to be zero.
RealT MaxValue() const: Returns the maximum value saved in the array.
IndexT MaxIndex() const: Returns the index of the maximum value.
IndexT MinIndex() const: Returns the index of the minimum value.
IndexT MaxAbsIndex() const: Returns the index of the maximum absolute value.
RealT Sum() const: Returns the sum of all elements in the array.
RealSArray1dC & StraightSort(): Sorts the array into ascending numerical order by straight insertion. It is an N^2 routine, and should only be used for small N, say < 50.
RealSArray1dC & StraightSort(const SizeT n): Sorts the first n element of the array into ascending numerical order by straight insertion. It is an N^2 routine, and should only be used for small 'n', say < 50.
RealSArray1dC Join(const RealSArray1dC & it) const: Join this array with another.

#include "amma/SArray1d.hh"

SArray1dC<RealT> Copy() const: Creates a new physical copy of the array.
const SArray1dC<RealT> & operator=(const SArray1dC<RealT> & vv): Assigment, as for a BIG_OBJECT. Access to the object and its parts. -----------------------------------
const SArray1dC<RealT> & SArray1d() const: Access to the whole constant array.
SArray1dC<RealT> & SArray1d(): Access to the whole array. Modifications of the representation -----------------------------------
SArray1dC<RealT> Enlarge(const IntT factor = 2) const: Enlarges the array by item duplications. Every item is duplicated 'factor' times. The return array is extended by adding of higher indexes.
SArray1dC<RealT> & Append(const SArray1dC<RealT> & a): This array is extended by the length of the array 'a' and the contents of both arrays are copied to it. The function supports empty arrays.
SArray1dC<RealT> Join(const SArray1dC<RealT> & Oth) const: Join this Array and another into a new Array which is returned. This does not change either of its arguments. This is placed in the array first, followed by 'Oth'. Special operations ------------------
void DebugAddresses() const: Prints addresses into 'cerrAMMA'.
const BodyRefCounterC & RefCounter() const: Returns access to reference counter.
BufferRC<RealT> & Buffer(): Access base data buffer.
Experts only.
const BufferRC<RealT> & Buffer() const: Constant access base data buffer.
Experts only.

#include "amma/SBfAcc.hh"

const SizeBufferAccessC<RealT> & operator=(RealT * bp): Changes the reference element to the element pointed by 'bp'. Access to the object --------------------
RealT * ReferenceElm(void) const: Returns the pointer to the reference element of the attached buffer. The reference element need not to be the valid element of the buffer.
void * ReferenceVoid(void) const: Returns the pointer to the reference element of the attached buffer. The reference element need not to be the valid element of the buffer. The function is intended to be used in printing.
const BufferAccessC<RealT> & Access(void) const: Returns this object.
RealT * DataStart() const: Returns the address of the first element of the buffer.
SizeT N() const: Returns the number of elements of the array.
SizeT Size() const: Returns the number of elements of the array.
const BufferSizeC & Limits() const: Returns the usable range of indeces expressed by this object.
const BufferSizeC & Range() const: Returns the usable range of indeces expressed by this object.
IndexT IMin() const: Returns the minimum index of the range of this access.
IndexT IMax() const: Returns the maximum index of the range of this access.
const RealT & operator[](const IndexT i) const: Read-only access to the ('i'+1)-th element of the buffer.
RealT & operator[](const IndexT i): Read-write access to the ('i'+1)-th element of the buffer.
const SizeBufferAccessC<RealT> & SAccess(void) const: Returns this object. Logical functions -----------------
BooleanT IsEmpty() const: Returns TRUE if the size of the array is zero.
BooleanT Contains(const IndexT i) const: Returns TRUE if the array contains an item with the index 'i'. Modifications of the access ---------------------------
const BufferSizeC & ShrinkHigh(const SizeT k): Changes the number of elements by subtracting the last 'k' elements.
const SizeBufferAccessC<RealT> & Swap(SizeBufferAccessC<RealT> & a): Exchanges the contents of this buffer with buffer 'a'.
void Attach(const SizeBufferAccessC<RealT> & b): Changes this buffer access to have the same access rights as 'b'.
void Attach(const BufferAccessC<RealT> & b,const SizeT size): Changes this buffer access to have the access rights as 'b' limited for 'size' elements.
SizeBufferAccessC<RealT> operator+(const SizeT i) const: Creates the new access object shifted 'i' elements to the right (towards next elements). The size is descreased to fit the the original range of this access. Modifications of the buffer contents ------------------------------------
void Fill(const RealT & d): 'd' value is assigned to all elements of the buffer.
void CopyFrom(const SizeBufferAccessC<RealT> & oth): Copy contents of another buffer into this one.
NB. Buffers MUST be the same length.

Programmer:Kieron Messer, Documentation by CxxDoc: Tue Mar 20 10:48:08 2001

NetVectorC

Extension of VectorC class to add routines for neural networks

include	"amma/Num/NetVector.hh"
User Level:	Default
Library:	NumModelNeuralNet
Example:	NetTest.cc
Section:	default.Kieron Messer
In Scope:	std

Operators

Additional Methods