array um die x-achse spiegeln

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