ich hab mir mithilfe eines Arrays eine Matrix angelegt. Nun will ich die mit Werten befüllen. Dabei sollen aber die Werte gespiegelt eingetragen werden. Also (2,1) soll auch (1,2) mit dem selben Wert belegen.

void set(int x, int y, int val)
{
    if(x!=y)
    {
        array[x*N+y] = val; // N ist die Ausdehnung
        array[y*N+x] = val;
    }
    else
    {
        array[x*N+y] = val;
    }
}

Das ist aber Mordslangsam, wenn ich den zweiten Zugriff (y*N+x) weglasse ist es akzeptabel.
Jemand eine Idee wieso?

Danke im Voraus

Evtl. bist Du sogar schneller, wenn Du die Diagonalwerte doppelt schreibst.
Das erspart die Sprungvorhersage. Das geht aber auch sicher anders besser...

Wie könnte es denn anders gehen?
get(2,5) muss einfach das gleiche ergeben wie get(5,2)

Vielleicht wär

void set( int x, int y, int val )
{
  if (x < y) {
    array[((x*(x+1))/2)+y] = val;
  } else {
    array[((y*(y+1))/2)+x] = val;
  }
}

was für dich?

Ja, teste die Release Version.

Ja, langsam ist relativ, und zwar so:

for( int i = 0; i < N; ++i )
{
    for( int j = 0; j < N; ++j )
    {
        set( i, j, Zufallszahl );
    }
}

Mit

void set( int x, int y, int val )
{
    array[y*N+x] = val;
}

ist es relativ langsamer als mit

void set( int x, int y, int val )
{
    array[x*N+y] = val;
}

und zwar mehr als 2x (keine Einheit :p)

finix, zu dem Schluss bin ich dann auch gekommen.
Aber deine Berechnung des Array Index kapier ich nicht
Machs jetzt so:

for( int i = 0; i < N; ++i )
{
    for( int j = 0; j <= i; ++j )
    {
        set( i, j, Zufallszahl );
    }
}

void set( int x, int y, int val )
{
    array[x*N+y] = val;
}
int get( int x, int y )
{
    if( x <= y )
        return array[x*N+y];
    else
        return array[y*N+x];
}

Der Rest der Matrix liegt brach, aber ich glaub ist einfacher so, als eine halbe zu implementieren.

Danke euch allen
und tschüss

finix, zu dem Schluss bin ich dann auch gekommen.
Aber deine Berechnung des Array Index kapier ich nicht

Du kannst deine Spiegelmatrix einfach mit Hilfe einer Dreiecksmatrix implementieren.

Statt

{ v11, v12, v13,
  v21, v22, v23,
  v31, v32, v33 }

speicherst du nur

{ v11,
  v21, v22,
  v31, v32, v33 }