ich programmiere an einem Tool, dass mit GPS Koordinaten umgehen soll und dabei müssen natürlich auch negative Koordinaten berücksichtigt werden.
Allerdings ist dies in meiner Unterfunktion nicht so einfach möglich und daher gibt diese nur positive Koordinanten aus. Daher dachte ich mir, ich könnte diese einfach umdrehen, aber irgendwie scheint das nicht zu funktionieren.

Ich hatte mir das ungefähr so gedacht:

if(arr_long[1] < 0)
	{
		for(int iy=1; iy!=iy+10; ++iy)
			arr_curve_long[iy] = arr_curve_long[iy]*-1;
	}

Zur Erklärung: Es wird überprüft ob die Ausgangskoordinate (arr_long) negative ist und wenn ja dann sollen die entsprechenden Ergebnisskoordinaten (arr_curve_long) auch negativ werden. Allerdings tut das so nicht.
Was mache ich falsch? Den mathematisch müsste es doch richtig sein...

Vielen Dank schon mal.

Gruß,
Sebastian

if(arr_long[1] < 0)
    std::transform(arr_curve_long+1,arr+10,arr_curve_long+1,std::negate<int>());

Der zweite Parameter wäre eines Überdenkens wert ;-), aber sonst wäre das auch die von mir bevorzugte Variante.

allerdings kann ich mich auch irren.

ich denke diese std::funktion zu verwenden ist ineffektiv

Nein, aber vielleicht meinst du ineffizient.

- man nur ein *= -1 eingeben muss.

ein unäres Minus reicht ( -a ), aber genau das tut std::negate

- vermutlich jedesmal ein kontruktor aufgerufen wird, der das ganze unfassbar verlangsamt, ohne nennenswerten mehrwert.

Wird wegoptimiert.

- höhere compilerzeit, höherer speicherverbrauch, mehr code

Compilierzeit ist in der Tat höher, der Rest ist eine Frage der Optimierung.

Ich würd den Code aber trotzdem nicht so schreiben :p

for(int ix = 0; ix != koordinaten_anzahl-2; ++ix)
	{
		if(arr_long[ix+1] < 0)
		{
			int iz = 10*ix;
			for(int iy = iz+1; iy != iz+11; ++iy)
			{
				arr_curve_long[iy] = -arr_curve_long[iy];
			}
		}
	}

Es funktioniert sehr gut, auch von der Zeit merke ich keinen Unterscheid.

Nochmals Danke.

vermutlich jedesmal ein kontruktor aufgerufen wird, der das ganze unfassbar verlangsamt, ohne nennenswerten mehrwert.
allerdings kann ich mich auch irren.

Schon was von inline gehört ?
Sonst kannst du ruhig assembler listings vergleichen.

dgrat schrieb:

- höhere compilerzeit,

richtig , templates ...

dgrat schrieb:

höherer speicherverbrauch

Nein

dgrat schrieb:

mehr code

hmm, weis nicht ob das objekt in std::transform einfach so wegoptimiert wird, wenns das tut wärs ganz nett. aber allgemein wurde mir immer gesagt, dass der aufruf von memberfunktionen allgemein langsamer ist und in negate steckt wohl ungefähr so etwas:

T operator()(const T& x) const { return -x; }

1.) inline ist nur ne empfehlung und wird meist automatisch gemacht

Na also, brauchst du es nicht mal hinzuschreiben.

1.) inline ist nur ne empfehlung und wird meist automatisch gemacht

hmm, weis nicht ob das objekt in std::transform einfach so wegoptimiert wird, wenns das tut wärs ganz nett. aber allgemein wurde mir immer gesagt, dass der aufruf von memberfunktionen allgemein langsamer ist und in negate steckt wohl ungefähr so etwas:

T operator()(const T& x) const { return -x; }

ich will mal den compiler sehen, der die fkt nicht wegoptimieren kann...
auch das objekt an sich kann bedenkenlos wegoptimiert werden - wird ja nicht wirklich gebraucht...
und das die fkt durch -x ersetzt werden kann, sollte wohl auch offensichtlich sein

bb