array um die x-achse spiegeln

hallo,
ich habe ein array mit fixer größe was ein koordinatensystem repräsentiert.
(die länge der x achse ist bekannt) also repräsentieren alle x elemente des arrays eine zeile im koordinatensystem.

die erter position (array[0]) ist repräsentiert im koordinaten system die linke untere ecke...

ich möchte mein array so spiegeln dass wenn ich einen punkt z.b. (0,0) im array ableg dies nicht die linke untere sondern die linke obere ecke repräsentiert. das wäre dann bei einem array der länge 25 die position array[20].

hat jemand eine idee wie ich das bewerkstelligen kann?
müsste nur von der position im "normalen" array soundso viel positionen dazuaddieren um auf die position im gespiegelten fall zu kommen...

Nexus

c87 schrieb:

die erter position (array[0]) ist repräsentiert im koordinaten system die linke untere ecke...

ich möchte mein array so spiegeln dass wenn ich einen punkt z.b. (0,0) im array ableg dies nicht die linke untere sondern die linke obere ecke repräsentiert. das wäre dann bei einem array der länge 25 die position array[20].

Bei einem Array der Länge 25 der Index 20? Wie kommst du denn darauf? Ist das nicht mit einfacher Subtraktion vom maximalen Index zu lösen?

Ansonsten beschreib dein Problem genauer, und achte ein wenig auf die Formulierung...

volkard

statt
arr[y*sizeX+x]
nimm
arr[(sizeY-y)*sizeX+x]
und gespiegelt ist es.

ich habe ein array. Nehmen wir als größe mal 25.
der erste wert im array ist im koordinaten system (0,0) an der linken unteren ecke. Das ist fix.

Ich möchte aber den koordinatenursprung an der linken oberen ecke haben. das heißt ich muss mir ausrechnen welche position im array diese obere linke ecke darstellt. das wär bei bei dem array die pos 20.

20x x x x   array[20-24]
x x x x     array[15-19]
x x x x x   array[10-14]
x x x x x   array[5-9]
0 x x x x   array[0-4]

volkard schrieb:

statt
arr[y*sizeX+x]
nimm
arr[(sizeY-y)*sizeX+x]
und gespiegelt ist es.

volkard schrieb:

statt
arr[y*sizeX+x]
nimm
arr[(sizeY-y)*sizeX+x]
und gespiegelt ist es.

das funktioniert leider auch nicht:
bei array der länge 25: einfügen: (2,1)

position im array: 7:
position gespiegelt: sollte 17 sein

x x 22x x 
x x * x x
x x x x x
x x 7 x x
x x x x x

(5-1)*5 +2 = 22 falsch

volkard

arr[((sizeY-1)-y)*sizeX+x]?

hab bissl rumprobiert.
so hauts hin:
(sizeY-(y+1)) * sizeX + x

dankeschön

unskilled

c87 schrieb:

so hauts hin:
(sizeY-(y+1)) * sizeX + x

das hatte volkard doch bereits geschrieben...
btw:
(sizeY-y-1) * sizeX + x

man muss nich überall klammern setzen ;o)

bb

volkard

unskilled schrieb:

btw:
(sizeY-y-1) * sizeX + x
man muss nich überall klammern setzen ;o)

meine klammer bei [((sizeY-1)-y war ein wink mit dem zaunpfahl an den compiler, daß er (sizeY-1) gefälligst zu optimieren hat. passiert irgendwie von allein beim tippen.

unskilled

volkard schrieb:

unskilled schrieb:

btw:
(sizeY-y-1) * sizeX + x
man muss nich überall klammern setzen ;o)

meine klammer bei [((sizeY-1)-y war ein wink mit dem zaunpfahl an den compiler, daß er (sizeY-1) gefälligst zu optimieren hat. passiert irgendwie von allein beim tippen.

Wie ich immer wieder sage: ich vertraue meinem Compiler da eh blind - und vll will er ja lieber y-1 optimieren und nich sizeX-1
Ich finds auf jeden Fall hässlich, ne Gleichnung mit so vielen Klammern zu haben - (in dem Fall) zwar nicht gleich total unleserlich, aber au nich besser ^^ und bei dir war mir das scho klar, dass du weist, welche klammern gebraucht werden und welche nich

bb

volkard

unskilled schrieb:

Wie ich immer wieder sage: ich vertraue meinem Compiler da eh blind - und vll will er ja lieber y-1 optimieren und nich sizeX-1

bei integers kannste dem gerne vertrauen.
bei doubles würde ich davon abstand nehmen.

unskilled

volkard schrieb:

unskilled schrieb:

Wie ich immer wieder sage: ich vertraue meinem Compiler da eh blind - und vll will er ja lieber y-1 optimieren und nich sizeX-1

bei integers kannste dem gerne vertrauen.
bei doubles würde ich davon abstand nehmen.

ich wollts ja gerade mal ausprobieren - aber meine asm-kenntnisse sind zu schlecht, um das richtig deuten zu können ^^

int main()
{
	double sizeY;
	std::cin >> sizeY;
	double y;
	std::cin >> y;
	double sizeX;
	std::cin >> sizeX;
	double x;
	std::cin >> x;

	double R = (sizeY-y-1) * sizeX + x; //1
	double R = (sizeY-(y+1)) * sizeX + x; //2
	std::cout << R;
}

1:

00C7104D  fld         qword ptr [esp+20h] 
00C71051  fsub        qword ptr [esp+28h] 
00C71055  mov         ecx,dword ptr [__imp_std::cout (0C72044h)] 
00C7105B  sub         esp,8 
00C7105E  fsub        qword ptr [__real@3ff0000000000000 (0C72118h)] 
00C71064  fmul        qword ptr [esp+38h] 
00C71068  fadd        qword ptr [esp+40h] 
00C7106C  fstp        qword ptr [esp]

2:

00E1104D  fld         qword ptr [esp+20h] 
00E11051  fadd        qword ptr [__real@3ff0000000000000 (0E12118h)] 
00E11057  mov         ecx,dword ptr [__imp_std::cout (0E12044h)] 
00E1105D  sub         esp,8 
00E11060  fsubr       qword ptr [esp+30h] 
00E11064  fmul        qword ptr [esp+38h] 
00E11068  fadd        qword ptr [esp+40h] 
00E1106C  fstp        qword ptr [esp]

sieht aber so aus, als ob es sich nix nehmen würde^^

bb

volkard

und mit

double const sizeY=5;
double const sizeX=5;

?

unskilled

volkard schrieb:

und mit

double const sizeY=5;
double const sizeX=5;

?

Deine Variante:

008F102B  fld         qword ptr [esp+30h] 
008F102F  fadd        qword ptr [__real@3ff0000000000000 (8F2120h)] 
008F1035  mov         ecx,dword ptr [__imp_std::cout (8F2044h)] 
008F103B  fld         qword ptr [__real@4014000000000000 (8F2118h)] 
008F1041  sub         esp,8 
008F1044  fld         st(0) 
008F1046  fsubrp      st(2),st 
008F1048  fmulp       st(1),st 
008F104A  fadd        qword ptr [esp+40h] 
008F104E  fstp        qword ptr [esp] 
008F1051  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (8F2040h)]

Die "normale" Variante (also die ohne klammern):

0111102B  fld         qword ptr [__real@4014000000000000 (1112120h)] 
01111031  fld         qword ptr [esp+30h] 
01111035  mov         ecx,dword ptr [__imp_std::cout (1112044h)] 
0111103B  fsubr       st,st(1) 
0111103D  sub         esp,8 
01111040  fsub        qword ptr [__real@3ff0000000000000 (1112118h)] 
01111046  fmulp       st(1),st 
01111048  fadd        qword ptr [esp+40h] 
0111104C  fstp        qword ptr [esp] 
0111104F  call        dword ptr [__imp_std::basic_ostream<char,std::char_traits<char> >::operator<< (1112040h)]

vorhin konnte ich ja zumindest noch raten, was was heißt - aber jz wirst du wohl mal nen paar worte dazu sagen müssen - bitte

bb

volkard

ich habe ein bißchen Zeiten gemessen mit

int main()
{
	clock_t start=clock();
	double sum=0;
	double t=0;
	double const sizeYm=4;
	for(unsigned int i=0;i<4000000000u;++i){
		double y=++t;
		double x=++t;
//		sum+= (sizeY-y-1)*sizeX+x;
//		sum+= ((sizeY-1)-y)*sizeX+x;
		sum+= (sizeYm-y)*sizeX+x;
	}
	clock_t end=clock();
    cout << sum << '\n';
    cout << (end-start)/double(CLOCKS_PER_SEC) << '\n';
}

und stelle fest: ich kann keinen zeitunterschied feststellen.

trotdem bleibe ich vermutlich dabei, hin und wieder theoretisch notzlose klammen zu setzen.

int main()
{
    double a=1e20;
    cout << (1+a-a) << '\n';
    cout << (a+1-a) << '\n';
    cout << (a-a+1) << '\n';
}

unskilled

volkard schrieb:

int main()
{
    double a=1e20;
    cout << (1+a-a) << '\n';
    cout << (a+1-a) << '\n';
    cout << (a-a+1) << '\n';
}

ok - nur, dass es darum gerade nich ging ^^ ;P

bb