C++-ban érdemes az alapból megadott függvényeket használni, vagy gyorsabb, ha sajátot készítünk?

A beépített mindig jobb, az optimalizálva van.

A négyzetre emelésnél azért két szorzás gyorsabb, mert egy függvényhívásnak mindig érezhető költsége van.

Neked kell tudnod, hogy érdemes-e energiát befektetni, az mindenesetre tévedés, hogy a beépített függvények (úgy általánosságban) jobbak lennének.

Néhány esetben meg kifejezetten hulladékok. Nem c++-ról beszélek, hanem úgy általánosságban.

"A négyzetre emelésnél azért két szorzás gyorsabb, mert egy függvényhívásnak mindig érezhető költsége van."

C++ban nem. Mivel a szorzás az operator* függvény. Tehát a pow sokkal gyorsabb.

"nem csak C++-ban hanem a legtöbb nyelv esetén érdemes a két tényező szorzását használni."

Neked is ugyanazt tudom mondani. A szorzás is egy függvény semmivel sem jobb vagy gyorsabb. Ha négyzetre emelsz használd a pow() függvényt.

A szorzás nem függvény.

a négyzetre emelés meg nem is biztos, hogy szorzás lesz.

Én készséggel elfogadom amit mondasz, de megtennéd, hogy egy szimpla szorzást (mondjuk 4 x 4) kigeneráltatsz a fordítóddal, o2-n .asm kimenetre?

Nálam nincs fent cpp fordító. Segítségedet előre is köszönöm.

" A szorzás is egy függvény semmivel sem jobb vagy gyorsabb."

Ennek ellenkezőjét nem állítottam. Nem a szorzás függvénységéről és implementálásáról és a sebességről sem beszéltem. Annyit írtam, hogy az esetek jelentős részében a szorzás és a hatványozás más eljárással dolgozik. Ennek eredménye, hogy más az értelmezési tartománya is. Az, hogy a pow() végez egy ellenőrzést, hogy egész kitevős-e a hatvány (pl. ez eddig elkerülte a figyelmemet, ésezért elnézést kérek, most elolvastam még 1x a részletes doksit) az meg biztosan lassítja a végrehajtást. Arra most nem találtam semmit, hogy hogyan van implementálva a pow() de én innen biztos vagyok benne, hogy biztos, hogy gyorsabb lesz a szorzás.

Ugyanígy az eredmény pontossága is kérdéses még. A két tényező szorzása esetén nem kell külön kutakodni, hogy mennyire lesz pontos az eredmény. Ha a hatványozást használja az ember akkor utána kell nézni, hogy melyik közelítő eljárást használjak.

A legegyszerűbb az a^b=e^(b*ln(a)) forma, de találkoztam már (nem C++ esetén,mert ott nem mentem bele ennyire mélyen) 2^(b*log2(a)) megoldással is. Innen meg a kérdés, az e^x illetve a 2^x valamint a hozzá tartozó logaritmálás pontossága. Tudom nem mindenkit zavar ha a 13. 14. tizedes jegy környékén van már komoly eltérés, de nem egy esetben láttunk ennél nagyobb hibákat is (már nem emlékszem melyik rendszernél találtunk egy olyat, hogy a hatványozás csak 8 jegy pontos volt, míg általában 14 jegy pontos volt az aritmetika). /Tudom a kérdező a sebességet és a méretet kérdezte, de a hiba is fontos szempont lehet/. Nyilván a double (64 bit) és long double (80/96 bit). A float kb. 7 jegy pontos, a double 14. Jó matekozást kiszámolni a logaritmálás és az e^x hibáját ez esetben, de mindenképpen nagyobb lesz mint a kettős szorzás. Nyilván ha nem négyzetre emelésről van szó akkor más a helyzet, mert ott úgyse tudunk mást kitalálni.