array um die x-achse spiegeln
-
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 seinx 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
-
arr[((sizeY-1)-y)*sizeX+x]?
-
hab bissl rumprobiert.
so hauts hin:
(sizeY-(y+1)) * sizeX + xdankeschön
-
c87 schrieb:
so hauts hin:
(sizeY-(y+1)) * sizeX + xdas hatte volkard doch bereits geschrieben...
btw:
(sizeY-y-1) * sizeX + xman muss nich überall klammern setzen ;o)
bb
-
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.
-
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
-
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.
-
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
-
und mit
double const sizeY=5; double const sizeX=5;?
-
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
-
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'; }
-
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