C++ gurus

[Bluga]

How can i set the main diagonal of a n*n Matrix to 1 and other elements to 0?

thanks alot.

 

[tweakmm]

hmm... do you want concept or code?

 

[tweakmm]

and which diagonal
'\' or '/'?

 

[Bluga]

ok i think i know how to set the "\" diagonal to one, but what about other elements? Can these be done in one step?

so far i have:

for (s=0; s<=n; i++)
for (j=0; j<=n, j++){
if s=j;
A[j] =1;
else
A[j]=0;
}

 

[Drekce]

create a nested loop that goes n^2 (n on the main loop, and n in the nested) times, and everytime through the loop set the value at [n][n] to 1 and every other value to zero

EX:

for( i=0 ; i<n ; i++ ) {

for (j = 0 ; j < n ; j++) {

VAR[j] = 0;

}

VAR = 1;
}


Should work.

 

[tweakmm]

for your matrix matrix[n][m]

int columncheck=0;

for(int i=0;i<n;i++)
{
for(int j =0;j<m;j++)
{
if (columcheck == j)
matrix[.I][j] = 1;
else
matrix[.I][j] = 0;
}
columcheck++;
}

EDIT:
sorry about the .Is, if I dont have those, the forums thinks that i want italics

 

[tweakmm]

i am almost positve that mine will work, i would double check though

 

[Cat]

int columns, rows;

int matrix[columns][rows];

memset( &matrix[0], 0, sizeof(int) * columns * rows);
Will zero out the matrix.

Then you can set the diagonals to 1 in a separate step.

 

[HigherGround]

Cat is right ( although the example he gave should have rows and columns as const ). You don't need nested loops to set the identity matrix, the following snippet of code declares and creates 6*6 identity matrix.


const int SIZE = 6;
int MATRIX[SIZE][SIZE];

memset(MATRIX, 0, sizeof(int)*SIZE*SIZE);
for(int k=0; k<SIZE; k++)
MATRIX[k][k] = 1;

 

[Rotorvator]

actuall, that won't work either - need to
#define SIZE x

const int will only work when dynamically allocating the array, and then only on one dimension.

 

[HigherGround]

<< actuall, that won't work either - need to
#define SIZE x

const int will only work when dynamically allocating the array, and then only on one dimension. >>



from the C++ ANSI schema ...

array declaration ...



<<
In a declaration T D where D has the form
D1 [constant-expressionopt]
and the type of the identifier in the declaration T D1 is "derived-
declarator-type-list T," then the type of the identifier of D is an
array type. T is called the array element type; this type shall not
be a reference type, the type void, a function type or an abstract
class type. If the constant-expression (_expr.const_) is present, it
shall be an integral constant expression and its value shall be
greater than zero. ...
>>



constant expression definition



<<
...
An integral constant-expression can involve only literals (_lex.lit-
eral_), enumerators, const variables or static data members of inte-
gral or enumeration types initialized with constant expressions
...
>>



with that in mind const int s = 5; is a constant expression, hence the array declaration int d is valid according to the ANSI C++ specs. I'm not event sure how you mixed in the "one dimension" component into this.

 

[Rotorvator]

Bear in mind I learned C++ prior to finalization of the ANSI std, and still work with an (more or less) ARM compiler.

Every now and then someone whips out a stroustrup book and whaps me upside the head with it, for which I am greatful

Prior to ansi you couldn't declare stack allocated arrays with a variable bound (const or otherwise).
i.e.
const int a = 8;
int b[a];
would break, but
int * b = new int[a];
would not.

Also, you could only do this in one dimension -
int * b = new int[a][a];
would not compile, but
int * b = new int[a][8];
would.

Which is why I suggested the #define