IndexC - Index class for indexing 1D arrays: an integer class with modified rounding and other operations

Developer Documentation

RAVL, Recognition And Vision Library

USER

IndexC

Index class for indexing 1D arrays: an integer class with modified rounding and other operations

include	"Ravl/Index.hh"
Created:	2/1/1996
Source file:	Ravl/Core/Base/Index.hh
User Level:	Basic
Library:	RavlCore
Example:	exIndex.cc
In Scope:	RavlN

Comments:
The class IndexC is designed as a replacement for the built-in C int type, in an attempt to correct some of the perceived deficiencies of int:

Unsigned integers:: When combining signed and unsigned integers in a binary operation, C always converts the signed integer to unsigned, which can generate surprising results such as: (unsigned int) 4 / (-2) = 0.
Rounding:: With the int type, rounding is either towards zero (e.g. on conversion from floating point representations), or implementation-dependent (e.g. integer division operations). Where negative numbers are involved, this behaviour is often not what is required, particularly for indexing purposes.

The behaviour of IndexC therefore differs from that of int, to provide more consistent behaviour for indexing purposes, and to improve portability of code.

The major differences between IndexC and int are:

Unsigned integers:

Where relevant, unsigned integers are converted to signed before combining with IndexC.

Rounding:

Rounding is always to the nearest more negative integer. This affects:

Truncation of floating point values on conversion to IndexC.
Integer division operations involving IndexC, for which:
- if the divisor is negative, the signs of both divisor and dividend are reversed;
- if the divisor is positive, the quotient is always rounded towards the more negative nearest integer, regardless of the sign of the dividend.
Thus (IndexC) -4 / 3 yields -2, and (IndexC) -4 % 3 yields 2. With the int type, the results would probably be -1 and -1 respectively.

Modulo operator:

The modulo operator is always consistent with the divide operator, as per the C and C++ standards. It accordingly always returns a non-negative value.

Remember: IndexC is a class, not a built-in. So:

The type conversion rules are not necessarily the same as for int. For a class, the type of the first operand of binary operator determines the class member function used.
Because there is no implicit conversion from IndexC to int, you can't use IndexC everywhere you would use an int. In particular you can't use an IndexC object directly as an int function argument. You need to use the V() member function to achieve this. (We could have provided the implicit conversion, but it would then be very difficult sometimes to know which was actually being used.)

Access functions:

Conversions:

Arithmetical operations:

Modifications of indices:

Logical operators with integer numbers:

Logical operators with unsigned integer numbers:

Logical operators with double numbers:

Logical operators with another index:

Miscellaneous functions:

Special member functions: