IntSArray1dC - A simple 1 dimensional array of integers

User Documentation

Centre for Vision, Speech & Signal Processing

Comments:
The class IntSArray1dC is a simple container with a fixed number of integers which can accessed randomly using indexing. The class IntSArray1dC is a big object, eg. it has a reference counter.

Parent Classes:

SArray1dC

Derived Classes:

IntHistogram1dC

Methods:

IntSArray1dC(): Empty array
IntSArray1dC(const SizeT dim): A non-initialized array with the range <0, 'dim'-1>.
IntSArray1dC(const IntSArray1dC & vv): Another access to the array 'vv'.
IntSArray1dC(const SArray1dC<IntT> & vv): Another access to the array 'vv'.
IntSArray1dC(IntT * data,const SizeT dim): An array is created from the memory location 'data' with the range of access in <0, 'dim'-1>.
'data' is not deallocated during destructing of the array.
IntSArray1dC(istream & s): Creates the integer array from the input stream 's'.
IntSArray1dC Copy() const: Creates a new physical copy of the integer array.
Special operations. -------------------
void SetZero(): Sets all items of the array to be zero.
IntT MaxValue() const: Returns the maximum value saved in the array.
IndexT MinIndex() const: Finds the index of the minimal item.
IndexT MaxIndex() const: Finds the index of the maximal item.
IntT Sum() const: Returns the sum of all items of the array.
IntSArray1dC & SetBitReversalIndexes(): Sets the array as the bit reversal table.
IntSArray1dC & 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.
IntSArray1dC & 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.
IndexT Squeeze(): The array represents a look-up table for labels.
Each item contains a new label which can be the same as the index of the item or smaller. Such table contains a forest of labels, every tree of labels represents one component which should have the same label. It is valid that a root item of a tree has the same label value as the item index. The function returns the maximum label after the squeeze.

#include "amma/SArray1d.hh"

SArray1dC<StdTypeC::IntT> Copy() const: Creates a new physical copy of the array.
const SArray1dC<StdTypeC::IntT> & operator=(const SArray1dC<StdTypeC::IntT> & vv): Assigment, as for a BIG_OBJECT. Access to the object and its parts. -----------------------------------
const SArray1dC<StdTypeC::IntT> & SArray1d() const: Access to the whole constant array.
SArray1dC<StdTypeC::IntT> & SArray1d(): Access to the whole array. Modifications of the representation -----------------------------------
SArray1dC<StdTypeC::IntT> 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<StdTypeC::IntT> & Append(const SArray1dC<StdTypeC::IntT> & 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<StdTypeC::IntT> Join(const SArray1dC<StdTypeC::IntT> & 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<StdTypeC::IntT> & Buffer(): Access base data buffer.
Experts only.
const BufferRC<StdTypeC::IntT> & Buffer() const: Constant access base data buffer.
Experts only.

#include "amma/SBfAcc.hh"

const SizeBufferAccessC<StdTypeC::IntT> & operator=(StdTypeC::IntT * bp): Changes the reference element to the element pointed by 'bp'. Access to the object --------------------
StdTypeC::IntT * 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<StdTypeC::IntT> & Access(void) const: Returns this object.
StdTypeC::IntT * 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 StdTypeC::IntT & operator[](const IndexT i) const: Read-only access to the ('i'+1)-th element of the buffer.
StdTypeC::IntT & operator[](const IndexT i): Read-write access to the ('i'+1)-th element of the buffer.
const SizeBufferAccessC<StdTypeC::IntT> & 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<StdTypeC::IntT> & Swap(SizeBufferAccessC<StdTypeC::IntT> & a): Exchanges the contents of this buffer with buffer 'a'.
void Attach(const SizeBufferAccessC<StdTypeC::IntT> & b): Changes this buffer access to have the same access rights as 'b'.
void Attach(const BufferAccessC<StdTypeC::IntT> & b,const SizeT size): Changes this buffer access to have the access rights as 'b' limited for 'size' elements.
SizeBufferAccessC<StdTypeC::IntT> 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 StdTypeC::IntT & d): 'd' value is assigned to all elements of the buffer.
void CopyFrom(const SizeBufferAccessC<StdTypeC::IntT> & oth): Copy contents of another buffer into this one.
NB. Buffers MUST be the same length.

Programmer:Radek Marik, Documentation by CxxDoc: Tue Mar 20 10:48:08 2001

IntSArray1dC

A simple 1 dimensional array of integers

include	"amma/IntSArr1.hh"
User Level:	Default
Library:	MstdArr
Example:	exComplx.cc
Section:	Containers.Arrays.1-D Arrays.Specialized Arrays
In Scope:	std