enum CreateBodyFlagT { CreateBodyE } ;

Forward declarations.

enum NeighbourOrderT { NEIGH_RIGHT = 0, NEIGH_DOWN_RIGHT = 1, NEIGH_DOWN = 2, NEIGH_DOWN_LEFT = 3, NEIGH_LEFT = 4, NEIGH_UP_LEFT = 5, NEIGH_UP = 6, NEIGH_UP_RIGHT = 7, NEIGH_CENTER = 8 } ;

Directions on grid

enum GridMetricT { CITY_BLOCK, MAX_VALUE, SQUARE_EUCLID } ;

Grid metrics.

enum XMLTagOpsT { XMLEndTag, XMLContent, XMLIndent, XMLIndentDown, XMLEmptyTag, XMLBeginTag, XMLComment } ;

Exception issued when an parse error occurs.

enum JointT { JNULL, RX, RY, RZ, RXRY, RXRZ, RYRZ, RXRYRZ, TXTYTZRXRYRZ, TXTYTZRZRYRX } ;

Quaternion
Two quarternions may represent the same rotation q and -q, both are valid, but it can be convenient to keep q[0]>0. This code usually tries to keep q[0] positive. All the non trivial constructors build a quarternion with q[0]>=0. The multiply operation can exit with q[0]<0, this is necessary if the Rotate member function is to work.

There are many tricky conversions, and stability issues with rotations and the conversions. Be careful of angles in particular angles near 0 or PI. This affects some conversions as indicated

A "valid" quarternion has norm 1, however when a quarternion contains a vector it does not have norm 1. Be careful when using operations that may cause the quarternion not to be valid.

When a quarternion is read in it should always be normalised so that it obeys normalisation to full machine precision which is the normal state of affairs

In addition it is possible that small errors may creep in during repeated multiplication. The user should consider using the Normalize() function to correct this. It is NOT done automatically during multiplication.

enum CrackCodeT { CR_DOWN = 0, CR_RIGHT = 1, CR_UP = 2, CR_LEFT = 3, CR_NODIR = 4 } ;

Relative crackCode
Symbol names of crack code, ordered counter-clockwise.

enum RelativeCrackCodeT { CR_AHEAD = 0, CR_TO_LEFT = 1, CR_BACK = 2, CR_TO_RIGHT = 3, CR_RNODIR = 4 } ;

typedef int IntT;

Integer of at least 32 bits

typedef unsigned int UIntT;

Unsigned Integer of at least 32 bits

typedef double RealT;

Real value of at least 64 bits.

typedef float FloatT;

Real value of at least 32 bits.

typedef unsigned char ByteT;

Unigned byte of 8 bits

typedef unsigned char UByteT;

Unigned byte of 8 bits

typedef signed char SByteT;

Signed byte of 8 bits

typedef unsigned short UInt16T;

Unsigned int of 16 bits.

typedef short Int16T;

Signed int of 16 bits.

typedef __int64 Int64T;

64 bit signed integer.

typedef UIntT SizeT;

Type which can index any item in memory.

typedef UInt64T StreamOffsetT;

Type which can index any offset in a file.
This is used internally in RAVL.

typedef StreamOffsetT StreamSizeT;

Size of stream. This is seperate to allow large file support.

typedef RCHandleC<RCBodyVC> AbstractC;

Abstract object handle.
Note: Objects which used abstract handles MUST be derived from RCBodyVC.

typedef basic_ifdstream<char> ifdstream;

typedef basic_ofdstream<char> ofdstream;

typedef unsigned short RandomSeedT;

Seed for random number

typedef unsigned long ulong_t;

typedef ulong_t mode_t;

typedef long uid_t;

typedef uid_t gid_t;

#define S_IFMT 0xF000 /* type of file */ #define S_IFDIR 0x4000 /* directory */ #define S_IFREG 0x8000 /* regular */

const long int RandomIntMaxValue = ((UIntT)) - 1;

static const IntT RavlPreComputedFactorialSize = 64;

The number of precomputed factorials.

const char filenameSeperator = '\\';

const char filenameSeperator = '/';

StringC representing a filename.

void Swap(DataT & v1,DataT & v2)

Swap the values of two variables.

void SetZero(ByteT & x)

Set byte value to zero.

void SetZero(IntT & x)

Set integer value to zero.

void SetZero(UIntT & x)

Set unsigned integer value to zero.

void SetZero(RealT & x)

Set real value to zero.

void SetZero(SByteT & x)

Set signed byte value to zero.

void SetZero(FloatT & x)

Set float value to zero.

void SetZero(Int64T & x)

Set integer value to zero.

void SetZero(UInt64T & x)

Set unsigned integer value to zero.

K StdCopy(const K & dat)

Copy.

const char * StdCopy(const char * dat)

Copy constant 'C' style string.
No point in copying a constant string. If otherwise you should use StringC intead.

long double StdCopy(long double x)

Copy long double.

double StdCopy(double x)

Copy double.

float StdCopy(float x)

Copy float.

bool StdCopy(bool x)

Copy bool.

short StdCopy(short x)

Copy short.

unsigned short StdCopy(unsigned short x)

Copy short.

int StdCopy(int x)

Copy int.

unsigned int StdCopy(unsigned int x)

Copy unsigned int.

long StdCopy(long x)

Copy long

unsigned long StdCopy(unsigned long x)

Copy unsigned long.

char StdCopy(char x)

Copy char.

char StdCopy(unsigned char x)

Copy unsigned char.

Int64T StdCopy(Int64T x)

Copy 64 bit int.

UInt64T StdCopy(UInt64T x)

Copy unsigned 64 bit int.

bool AssertThrowException()

Test if an exception on an assertion failure.

bool SetAssertThrowException(bool val)

Throw an exception on an assertion failure.
Note this may failed if exceptions are not supported, in which case it will return false.

void AssertFailed(char * file,int lineNo)

Called if assertion failed.
This will either cause the program to trap to the debugger or thow an 'ExceptionAssertionFailedC'

void AssertFailed(char * file,int lineNo,char * msg)

Called if assertion failed, with message.
This will either cause the program to trap to the debugger or thow an 'ExceptionAssertionFailedC'

void IssueError(char * file,int lineNo,char * msg,...)

Call when program encounters an error.
This will either cause the program to trap to the debugger or thow an 'ExceptionAssertionFailedC'

void IssueWarning(char * file,int lineNo,char * msg,...)

Call when program encounters an a unexpected occurance.
this prints the message and continues.

ostream & operator<<(ostream & s,const PairC<DataC> & p)

Prints the pair 'p' into the stream 's'.

istream & operator>>(istream & s,PairC<DataC> & p)

Assigns the values into the pair 'p'.

bool UsingRavlMain()

Are we using RAVL_ENTRY_POINT.
Used to decide how to handle some internal errors.

int RavlMain(int argc,char * argv[],int (*func)(int argc,char * argv[]) )

Call through function.

istream & operator >>(istream & s,IndexC & r)

Read information from the intput stream 's' and sets the index 'r' according obtained data.

ostream & operator <<(ostream & s,const IndexC & r)

Saves the index 'r' into the output stream 's'. Operations of integer numbers and indices -----------------------------------------

IndexC operator +(IntT i,const IndexC & j)

Returns the integer number constructed as addition of integer number 'i' and index value 'j'.

IndexC operator -(IntT i,const IndexC & j)

Returns the integer number constructed as subtraction of index value 'j' from integer number 'i'.

IndexC operator *(IntT i,const IndexC & j)

Returns the integer number constructed as multiplication of integer number 'i' and index value 'j'.

IndexC operator /(IntT i,const IndexC & j)

Returns the integer number constructed as division of integer number 'i' and index value 'j'.

const IntT & operator +=(IntT & i,const IndexC & j)

Adds index value 'j' to integer number 'i'.

const IntT & operator -=(IntT & i,const IndexC & j)

Subtracts index value 'j' from integer number 'i'.

const IntT & operator *=(IntT & i,const IndexC & j)

Multiplies index value 'j' by integer number 'i'.

const IntT & operator /=(IntT & i,const IndexC & j)

Divides index value 'j' by integer number 'i'.

bool operator ==(IntT i,const IndexC & j)

Returns true if the value of index 'j' is equal to the integer number 'i'.

bool operator !=(IntT i,const IndexC & j)

Returns true if the values of index 'j' is not equal to the integer number 'i'.

bool operator <(IntT i,const IndexC & j)

Returns true if the integer number 'i' is smaller than the value of index 'j' .

bool operator <=(IntT i,const IndexC & j)

Returns true if the integer number 'i' is smaller than or equal to the value of index 'j' .

bool operator >(IntT i,const IndexC & j)

Returns true if the integer number 'i' is greater than the value of index 'j' .

bool operator >=(IntT i,const IndexC & j)

Returns true if the integer number 'i' is greater than or equal to the value of index 'j' . Operations of unsigned integer numbers and indices --------------------------------------------------

IndexC operator +(const UIntT i,const IndexC & j)

Returns the integer number constructed as addition of integer number 'i' and index value 'j'.

IndexC operator -(const UIntT i,const IndexC & j)

Returns the integer number constructed as subtraction of index value 'j' from integer number 'i'.

IndexC operator *(const UIntT i,const IndexC & j)

Returns the integer number constructed as multiplication of integer number 'i' and index value 'j'.

IndexC operator /(const UIntT i,const IndexC & j)

Returns the integer number constructed as division of integer number 'i' and index value 'j'.

const UIntT & operator +=(UIntT & i,const IndexC & j)

Adds index value 'j' to integer number 'i'.

const UIntT & operator -=(UIntT & i,const IndexC & j)

Subtracts index value 'j' from integer number 'i'.

const UIntT & operator *=(UIntT & i,const IndexC & j)

Multiplies index value 'j' by integer number 'i'.

const UIntT & operator /=(UIntT & i,const IndexC & j)

Divides index value 'j' by integer number 'i'.

bool operator ==(const UIntT i,const IndexC & j)

Returns true if the value of index 'j' is equal to the integer number 'i'.

bool operator !=(const UIntT i,const IndexC & j)

Returns true if the values of index 'j' is not equal to the integer number 'i'.

bool operator <(const UIntT i,const IndexC & j)

Returns true if the integer number 'i' is smaller than the value of index 'j' .

bool operator <=(const UIntT i,const IndexC & j)

Returns true if the integer number 'i' is smaller than or equal to the value of index 'j' .

bool operator >(const UIntT i,const IndexC & j)

Returns true if the integer number 'i' is greater than the value of index 'j' .

bool operator >=(const UIntT i,const IndexC & j)

Returns true if the integer number 'i' is greater than or equal to the value of index 'j' . Operations of byte (unsigned char) numbers and indices -------------------------------------------------- ByteT binary operators omitted, as I don't feel they make much sense (maybe wrong)

const UByteT & operator +=(UByteT & i,const IndexC & j)

Adds index value 'j' to byte number 'i'.

const UByteT & operator -=(UByteT & i,const IndexC & j)

Subtracts index value 'j' from byte number 'i'.

const UByteT & operator *=(UByteT & i,const IndexC & j)

Multiplies index value 'j' by byte number 'i'.

const UByteT & operator /=(UByteT & i,const IndexC & j)

Divides index value 'j' by byte number 'i'.

bool operator ==(const UByteT i,const IndexC & j)

Returns true if the value of index 'j' is equal to the byte number 'i'.

bool operator !=(const UByteT i,const IndexC & j)

Returns true if the values of index 'j' is not equal to the byte number 'i'.

bool operator <(const UByteT i,const IndexC & j)

Returns true if the byte number 'i' is smaller than the value of index 'j' .

bool operator <=(const UByteT i,const IndexC & j)

Returns true if the byte number 'i' is smaller than or equal to the value of index 'j' .

bool operator >(const UByteT i,const IndexC & j)

Returns true if the byte number 'i' is greater than the value of index 'j' .

bool operator >=(const UByteT i,const IndexC & j)

Returns true if the byte number 'i' is greater than or equal to the value of index 'j' . Operations of double numbers and indices ----------------------------------------

RealT operator +(RealT i,const IndexC & j)

Returns the double number constructed as addition of double number 'i' and index value 'j'.

RealT operator -(RealT i,const IndexC & j)

Returns the double number constructed as subtraction of index value 'j' from double number 'i'.

RealT operator *(RealT i,const IndexC & j)

Returns the double number constructed as multiplication of double number 'i' and index value 'j'.

RealT operator /(RealT i,const IndexC & j)

Returns the double number constructed as division of double number 'i' and index value 'j'.

const RealT & operator +=(RealT & i,const IndexC & j)

Adds double number 'i' to index value 'j'.

const RealT & operator -=(RealT & i,const IndexC & j)

Subtracts index value 'j' from double number 'i'.

const RealT & operator *=(RealT & i,const IndexC & j)

Multiplies index value 'j' by double number 'i'.

const RealT & operator /=(RealT & i,const IndexC & j)

Divides index value 'j' by double number 'i'.

bool operator ==(RealT i,const IndexC & j)

Returns true if the value of index 'j' is equal to the double number 'i'.

bool operator !=(RealT i,const IndexC & j)

Returns true if the values of index 'j' is not equal to the double number 'i'.

bool operator <(RealT i,const IndexC & j)

Returns true if the double number 'i' is smaller than the value of index 'j' .

bool operator <=(RealT i,const IndexC & j)

Returns true if the double number 'i' is smaller than or equal to the value of index 'j' .

bool operator >(RealT i,const IndexC & j)

Returns true if the double number 'i' is greater than the value of index 'j' .

bool operator >=(RealT i,const IndexC & j)

Returns true if the double number 'i' is greater than or equal to the value of index 'j' .

BinOStreamC & operator <<(BinOStreamC & out,const StringC & str)

Write a string to a binary stream.

BinOStreamC & operator <<(BinOStreamC & out,const SubStringC & str)

Write a substring to a binary stream.

BinIStreamC & operator >>(BinIStreamC & in,StringC & str)

Read a string from a binary stream.

int compare(const StringC & x,const StringC & y)

Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const StringC & x,const SubStringC & y)

Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const StringC & x,const char * y)

Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const SubStringC & x,const StringC & y)

Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const SubStringC & x,const SubStringC & y)

Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int compare(const SubStringC & x,const char * y)

Compair two strings
Returns 0 if equal, and +ve or -ve value depending on alphabetic order.

int readline(istream & s,StringC & x,char terminator,int discard_terminator)

Read a line of text from a stream.
///

void cat(const StringC & x,const StringC & y,StringC & r)

void cat(const StringC & x,const SubStringC & y,StringC & r)

void cat(const StringC & x,const char * y,StringC & r)

void cat(const StringC & x,char y,StringC & r)

void cat(const SubStringC & x,const StringC & y,StringC & r)

void cat(const SubStringC & x,const SubStringC & y,StringC & r)

void cat(const SubStringC & x,const char * y,StringC & r)

void cat(const SubStringC & x,char y,StringC & r)

void cat(const char * x,const StringC & y,StringC & r)

void cat(const char * x,const SubStringC & y,StringC & r)

void cat(const char * x,const char * y,StringC & r)

void cat(const char * x,char y,StringC & r)

void cat(const StringC & a,const StringC & x,const StringC & y,StringC & r)

void cat(const StringC & a,const StringC & x,const SubStringC & y,StringC & r)

void cat(const StringC & a,const StringC & x,const char * y,StringC & r)

void cat(const StringC & a,const StringC & x,char y,StringC & r)

void cat(const StringC & a,const SubStringC & x,const StringC & y,StringC & r)

void cat(const StringC & a,const SubStringC & x,const SubStringC & y,StringC & r)

void cat(const StringC & a,const SubStringC & x,const char * y,StringC & r)

void cat(const StringC & a,const SubStringC & x,char y,StringC & r)

void cat(const StringC & a,const char * x,const StringC & y,StringC & r)

void cat(const StringC & a,const char * x,const SubStringC & y,StringC & r)

void cat(const StringC & a,const char * x,const char * y,StringC & r)

void cat(const StringC & a,const char * x,char y,StringC & r)

void cat(const char * a,const StringC & x,const StringC & y,StringC & r)

void cat(const char * a,const StringC & x,const SubStringC & y,StringC & r)

void cat(const char * a,const StringC & x,const char * y,StringC & r)

void cat(const char * a,const StringC & x,char y,StringC & r)

void cat(const char * a,const SubStringC & x,const StringC & y,StringC & r)

void cat(const char * a,const SubStringC & x,const SubStringC & y,StringC & r)

void cat(const char * a,const SubStringC & x,const char * y,StringC & r)

void cat(const char * a,const SubStringC & x,char y,StringC & r)

void cat(const char * a,const char * x,const StringC & y,StringC & r)

void cat(const char * a,const char * x,const SubStringC & y,StringC & r)

void cat(const char * a,const char * x,const char * y,StringC & r)

void cat(const char * a,const char * x,char y,StringC & r)

operator versions

StringC operator +(const StringC & x,const StringC & y)

StringC operator +(const StringC & x,const SubStringC & y)

StringC operator +(const StringC & x,const char * y)

StringC operator +(const StringC & x,char y)

StringC operator +(const SubStringC & x,const StringC & y)

StringC operator +(const SubStringC & x,const SubStringC & y)

StringC operator +(const SubStringC & x,const char * y)

StringC operator +(const SubStringC & x,char y)

StringC operator +(const char * x,const StringC & y)

StringC operator +(const char * x,const SubStringC & y)

StringC reverse(const StringC & x)

StringC upcase(const StringC & x)

StringC downcase(const StringC & x)

StringC capitalize(const StringC & x)

StringC operator +(const StringC & x,const IndexC & y)

StringC operator +(const StringC & x,const IntT & y)

StringC operator +(const StringC & x,const UIntT & y)

StringC operator +(const StringC & x,const RealT & y)

ostream & operator <<(ostream & s,const StringC & x)

a zillion comparison operators

bool operator ==(const StringC & x,const StringC & y)

bool operator !=(const StringC & x,const StringC & y)

bool operator >(const StringC & x,const StringC & y)

bool operator >=(const StringC & x,const StringC & y)

bool operator <(const StringC & x,const StringC & y)

bool operator <=(const StringC & x,const StringC & y)

bool operator ==(const StringC & x,const SubStringC & y)

bool operator !=(const StringC & x,const SubStringC & y)

bool operator >(const StringC & x,const SubStringC & y)

bool operator >=(const StringC & x,const SubStringC & y)

bool operator <(const StringC & x,const SubStringC & y)

bool operator <=(const StringC & x,const SubStringC & y)

bool operator ==(const StringC & x,const char * t)

bool operator !=(const StringC & x,const char * t)

bool operator >(const StringC & x,const char * t)

bool operator >=(const StringC & x,const char * t)

bool operator <(const StringC & x,const char * t)

bool operator <=(const StringC & x,const char * t)

bool operator ==(const SubStringC & x,const StringC & y)

bool operator !=(const SubStringC & x,const StringC & y)

bool operator >(const SubStringC & x,const StringC & y)

bool operator >=(const SubStringC & x,const StringC & y)

bool operator <(const SubStringC & x,const StringC & y)

bool operator <=(const SubStringC & x,const StringC & y)

bool operator ==(const SubStringC & x,const SubStringC & y)

bool operator !=(const SubStringC & x,const SubStringC & y)

bool operator >(const SubStringC & x,const SubStringC & y)

bool operator >=(const SubStringC & x,const SubStringC & y)

bool operator <(const SubStringC & x,const SubStringC & y)

bool operator <=(const SubStringC & x,const SubStringC & y)

bool operator ==(const SubStringC & x,const char * t)

bool operator !=(const SubStringC & x,const char * t)

bool operator >(const SubStringC & x,const char * t)

bool operator >=(const SubStringC & x,const char * t)

bool operator <(const SubStringC & x,const char * t)

bool operator <=(const SubStringC & x,const char * t)

ostream & operator <<(ostream & strm,const RCHandleC<BodyT> & obj)

istream & operator >>(istream & strm,RCHandleC<BodyT> & obj)

Base class for all reference counted objects
This holds a count of the number of handles that are available for this object.

istream & operator >>(istream &,RCBodyC & obj)

Input body.
No-op.

ostream & operator <<(ostream &,const RCBodyC & obj)

Output body.
No-op.

Signal Event handle

CallFunc0C<RetT> Trigger(RetT (*nfunc)() )

CallFunc1C<DataT,RetT> Trigger(RetT (*nfunc)(DataT & dat) ,const DataT & dat)

CallFunc2C<Data1T,Data2T,RetT> Trigger(RetT (*nfunc)(Data1T &,Data2T &) ,const Data1T & dat1,const Data2T & dat2)

CallFunc3C<Data1T,Data2T,Data3T,RetT> Trigger(RetT (*nfunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3)

CallFunc4C<Data1T,Data2T,Data3T,Data4T,RetT> Trigger(RetT (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4)

CallFunc5C<Data1T,Data2T,Data3T,Data4T,Data5T,RetT> Trigger(RetT (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4,const Data5T & dat5)

Labotimized version for Visual C++. Doesn't template on return types.

CallFunc0C<bool> Trigger(bool (*nfunc)() )

CallFunc1C<DataT,bool> Trigger(bool (*nfunc)(DataT & dat) ,const DataT & dat)

CallFunc2C<Data1T,Data2T,bool> Trigger(bool (*nfunc)(Data1T &,Data2T &) ,const Data1T & dat1,const Data2T & dat2)

CallFunc3C<Data1T,Data2T,Data3T,bool> Trigger(bool (*nfunc)(Data1T &,Data2T &,Data3T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3)

CallFunc4C<Data1T,Data2T,Data3T,Data4T,bool> Trigger(bool (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4)

CallFunc5C<Data1T,Data2T,Data3T,Data4T,Data5T,bool> Trigger(bool (*nfunc)(Data1T &,Data2T &,Data3T &,Data4T &,Data5T &) ,const Data1T & dat1,const Data2T & dat2,const Data3T & dat3,const Data4T & dat4,const Data5T & dat5)

int MTThreadID()

Get current thread id.

Lock system for reading.

istream & operator >>(istream & is,bool & b)

Fix for Visual C++'s lack of a bool stream operator.

ostream & operator <<(ostream & os,bool b)

Fix for Visual C++'s lack of a bool stream operator.

bool EnableURLMapper()

Enable url mapping of filenames.
With the expection of 'file:' specifications this enabled the changing of URL's to a RAVL special files. i.e. 'http:' becomes '@http:' This allows us to implement handlers in seperate libraries which can link in as required. If the 'file:' if found not to have a domain specifier then the 'file:' is stripped off and the file is treated normally.

Note: At the moment the URL handling mechanism may not handle relative filenames correctly as it uses the program current working directory as a start point. If this becomes a problem some optional data maybe added to StreamC which holds a current directory.

bool DisableURLMapper()

Dissable url mapping of filenames.

bool IsURLMappingEnabled()

Test if URL mapping enabled.
Returns true if it is.

Reference counter IO stream base class.

short bswap_16(const short & buf)

Swap bytes of a 16 bit number.

int bswap_32(const int & buf)

Swap bytes of a 32 bit number.

Machine independant binary input stream.

BinIStreamC & operator >>(BinIStreamC & s,IndexC & ind)

BinOStreamC & operator <<(BinOStreamC & s,const IndexC & ind)

BinOStreamC & operator <<(BinOStreamC & out,const TFVectorC<DataT,N> & dat)

BinIStreamC & operator >>(BinIStreamC & in,TFVectorC<DataT,N> & dat)

bool IsInside(IndexC i,const IndexRangeC & range)

1D index range of array
The class IndexRangeC is a representation of an interval of one dimensional index.

istream & operator >>(istream & s,IndexRangeC & r)

Read information from the intput stream 's' and sets the index range according obtained data.

ostream & operator <<(ostream & s,const IndexRangeC & r)

Saves the index range 'r' into the output stream 's'.

BinOStreamC & operator <<(BinOStreamC & s,const IndexRangeC & ir)

BinIStreamC & operator >>(BinIStreamC & s,IndexRangeC & ir)

ostream & operator <<(ostream & s,const IndexRange2dC & ir)

istream & operator >>(istream & s,IndexRange2dC & ir)

BinOStreamC & operator <<(BinOStreamC & s,const IndexRange2dC & ir)

BinIStreamC & operator >>(BinIStreamC & s,IndexRange2dC & ir)

/////////////////////////////////////////////////////

ostream & operator <<(ostream & strm,const RCWrapC<DataT> & data)

ostream operator.

istream & operator >>(istream & strm,RCWrapC<DataT> & data)

istream operator.

NeighbourOrderT Reverse(NeighbourOrderT at)

Get the opposite direction.
==================================================================== ======= Index2dC =================================================== ====================================================================

ostream & operator <<(ostream & out,const IntC & x)

istream & operator >>(istream & in,IntC & x)

BinOStreamC & operator <<(BinOStreamC & out,const IntC & x)

BinIStreamC & operator >>(BinIStreamC & in,IntC & x)

unsigned integer with a default constructor that assigns it a value of 0.
Its main feature is the default constructor sets its value to zero. Usefull in things like histograms.

int operator -(int v1,UIntC v2)

Subtraction.
This is included to avoid some confusing type casts which can lead to odd results.

ostream & operator <<(ostream & out,const UIntC & x)

istream & operator >>(istream & in,UIntC & x)

BinOStreamC & operator <<(BinOStreamC & out,const UIntC & x)

BinIStreamC & operator >>(BinIStreamC & in,UIntC & x)

istream & operator >>(istream & in,TFVectorC<DataT,N> & dat)

ostream & operator <<(ostream & in,const TFVectorC<DataT,N> & dat)

TFVectorC<DataT,2> TFVector2(const DataT & v1,const DataT & v2)

Create a 2d vector.
Helper function to make creation of fixed size vectors easier.

TFVectorC<DataT,3> TFVector3(const DataT & v1,const DataT & v2,const DataT & v3)

Create a 3d vector.
Helper function to make creation of fixed size vectors easier.

TFVectorC<DataT,4> TFVector4(const DataT & v1,const DataT & v2,const DataT & v3,const DataT & v4)

Create a 3d vector.
Helper function to make creation of fixed size vectors easier.

void SetZero(TFVectorC<DataT,N> & x)

Set vector to zero.

TFVectorC<DataT,N> operator *(const DataT & alpha,const TFVectorC<DataT,N> & data)

ostream & operator <<(ostream & out,const TFVectorC<ByteT,N> & dat)

Specialise byte vectors so they're treated as numerical values.

istream & operator >>(istream & in,TFVectorC<ByteT,N> & dat)

Specialise byte vectors so they're treated as numerical values.

ostream & operator <<(ostream & out,const TFVectorC<SByteT,N> & dat)

Specialise byte vectors so they're treated as numerical values.

istream & operator >>(istream & in,TFVectorC<SByteT,N> & dat)

Specialise byte vectors so they're treated as numerical values.

ostream & operator <<(ostream & out,const EmptyC &)

istream & operator >>(istream & in,EmptyC &)

BinOStreamC & operator <<(BinOStreamC & out,const EmptyC &)

BinIStreamC & operator >>(BinIStreamC & in,EmptyC &)

Basic algebraic functions

DataT Abs(const DataT & a)

Returns the absolute value of 'a'

unsigned char Abs(unsigned char a)

Returns the absolute value of 'a'
Used to avoid warnings.

unsigned short Abs(unsigned short a)

Returns the absolute value of 'a'
Used to avoid warnings.

unsigned int Abs(unsigned int a)

Returns the absolute value of 'a'
Used to avoid warnings.

unsigned long Abs(unsigned long a)

Returns the absolute value of 'a'
Used to avoid warnings.

DataT Sign(const DataT & a)

Returns the sign of the real number 'a'.

RealT Sign(RealT a,RealT b)

Returns the value 'a' with a sign of 'b'.

IntT Round(RealT x)

Returns the value x rounded to the nearest integer.

IntT Floor(RealT x)

Returns the greatest integral value less than or equal to 'x'.

void SetToZero(DataT & dat)

Set 'dat' to zero.
In cases where this doesn't work, a specialised version should be provided.

DataT Sqr(const DataT & x)

Returns the square of 'x'.

RealT Sqrt(RealT x)

Returns the square root of 'x'.

DataT Min(const DataT & a,const DataT & b)

Returns the smaller value from 'a' and 'b'.

DataT Max(const DataT & a,const DataT & b)

Returns the bigger value from 'a' and 'b'.

RealT Log(RealT r)

Returns log(r).

RealT Pow(RealT x,RealT y)

Returns 'x' raised to the power 'y'.

RealT Pow(RealT x,IntT y)

Returns 'x' raised to the power 'y' where y is an integer..

RealT Exp(RealT r)

Returns safe exp(r).

IntT ILog2(IntT i)

Interger Log 2
"i" = 2 ^ "mex", "mex" = ?

RealT Sin(RealT x)

Returns the sine of 'x'.

RealT ASin(RealT x)

Returns the arc sine of 'x'.

RealT Cos(RealT x)

Returns the cosine of 'x'.

RealT ACos(RealT x)

Returns the arc cosine of 'x'.

RealT ATan(RealT x)

Returns the arc tangent of 'x' in the range -pi/2 .. +pi/2.

RealT ATan2(RealT y,RealT x)

Returns the arc tangent of 'y/x' in the range -pi .. +pi.

RealT Sinh(RealT x)

Returns the sine of 'x'.

RealT Cosh(RealT x)

Returns the cosine of 'x'.

RealT Pythag(RealT a,RealT b)

Computes sqrt(sqr(a)+sqr(b)) without destructive overflow or underflow.

bool IsSmall(RealT a,RealT norm = 1,RealT isSmall = 1 e - 8)

Is a small relative to 'norm' ?
This code does the following test 'Abs(a/norm)) < isSmall'.

This code used to be as follows, but it was changed because using x==y for floats is a bad idea, and eventually caused trouble on Visual C++. (AJS) float b = (float) ((double) Abs(a) + norm); return (b == (float) norm);

bool IsAlmostZero(RealT v,RealT threshold = 1.0e-12)

Test is a real value is near zero.
Use with care.

DataT MinComponent(DataT a)

Returns the smallest component from 'a'.

DataT MaxComponent(DataT a)

Returns the Biggest component from 'a'.

DataT ScaleMin(DataT a,DataT b)

Returns the argument which has the smallest component from 'a' and 'b'.
In a manner suitable for scaling operations.

DataT ScaleMax(DataT a,DataT b)

Returns the argument which has the largest component from 'a' and 'b'.
In a manner suitable for scaling operations.