Thread: Indexes of arrays in C starting with 1

Hey all,

I'm programming a scientific application, namely, a Finite Element solver in ANSI C. The Finite Element research community is totally addicted to Fortran codes, due to some reasons; for instance its ability and ease when dealing with matrices/vectors and also its flexibility in the indexes of the arrays, since you can use every set of integers as indices.

In this kind of application, one must carry several loops over the elements and nodes of a mesh (basically a triangulation of a domain), and the numbering of these entities starts with one ! So, when programming Finite Element in C, I must every time concern with subtracting 1 to access the positions of my array, when in Fortran I would just use the numbering of the nodes directly as indexes.

The question is: Is there anyway to mask the indexing of vectors in C? I first thought about just providing a function double* AllocateVector(int n) that would actually allocate a (n+1) components vector and set the 0 component to 0 and remain it unused, since only one component more for each vector is not a problem. But this is not valid for matrices, sice an (nxn) matrix would have (2n+1) more entries, and this could represent a great amount of memory more.

Or maybe there is some way to "overload the operator ()" without actually using operator overloading (since the program is C, and not C++) and when I write A(i,j), it converts to A[i-1][j-1].

Is there some way to do this ? I hope you could understand my problem.

Thanks in Advance,
Rafael March.

This is not what I would call an useful reply.

I do understand that the numbering of arrays in C has its advantages, but to this kind of application it can be really inconvenient. It can introduce several bugs, since you have always to wonder wether you have or haven't to subtract 1 to the index.

What do you suggest ? That I give up writing my code in C, a language that I really feel confortable with, and surrender to Fortran ? I hope there is another way...

Waiting for suggestions.

Regards,
Rafael.

Yeah, the solution your proposed was just I thought (and wrote) first. But, as I also wrote, an nxn matrix will have 2n+1 more entries, so a 100.000x100.000 matrix would have 200.001 more entries. This can represent a gross amount of memory extra available.

Let's change my question a little bit. For a specific matrix A, i could write:

#define B(i,j) B[i-1][j-1]

This is a way that I could achieve this. Now I have the flexibility to use the "operator" (..,..) when I want. Is there a way to do this for ALL the matrices ?

Regards,
Rafael.

First of all, let me say that in most applications 0-indices are easiest. I rarely have to "subtract one", but I often had to "add one" in 1-based indices. The only reason you'd have to commonly subtract one is because some data uses 1-based indices. I've had it with certain 3D mesh file formats. I prefer to just subtract one from everything, then.

If you really, really want what you were talking about, use C++ and create a class or write your own "C-style" type: a structure with an init and destroy function and accessing functions. Like:
matrix_init(&matrix);
matrix_get(&matrix, 1, 1);
matrix_destroy(&matrix);

That's the best way to do such a thing in C, in my opinion.

Can you not simply pre-decrement the base address of the vector or array? I.e. make it point to -1. If it's 2-dimensional, then the matrix should be n (rows) of pre-decremented pointers to the rows. I don't know off hand any way to do this in a contiguous multi dimensional array though.

double array[10];
double *array_base = &array[-1]

use array_base[1] ... index 1 based

Originally Posted by nonoob

Can you not simply pre-decrement the base address of the vector or array? I.e. make it point to -1. If it's 2-dimensional, then the matrix should be n (rows) of pre-decremented pointers to the rows. I don't know off hand any way to do this in a contiguous multi dimensional array though.

double array[10];
double *array_base = &array[-1]

use array_base[1] ... index 1 based

I don't think that's defined behavior, and if it "worked" you might overwrite some other variable's memory doing that.

Originally Posted by whiteflags

I don't think that's defined behavior, and if it "worked" you might overwrite some other variable's memory doing that.

Yes, it _is_ undefined. 1 after the end(not to work with it, but to point to it), ok, 1 before the beginning, ??.

Originally Posted by whiteflags

I don't think that's defined behavior, and if it "worked" you might overwrite some other variable's memory doing that.

Why would it be undefined? I disagree. Unless the address underflows, which may happen but is fairly unlikely in common processors, it's probably defined just fine.

Code:

double *ptr = &array[-1];
double *ptr = (double*)(((char*)array) - sizeof(double*));

Is the same. So while we get the pointer to point before the actually array, we don't actually change something until we dereference ptr. If we dereference ptr[1], and never ptr[0], we simply change array[0]. Why would this be undefined?

Well, like I said, if array has an address of less than sizeof(double*), the subtraction would underflow which results in undefined behaviour... But why would it, in other cases?

Question 6.17