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...

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...

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]

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

dankeschön

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

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 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

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 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

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

?

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

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';
}

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