Frage zur funktion pow

Bashar

chroots schrieb:

aber so gehts auch nicht:

y = 0.1 pow(x,3) - 2 pow(x,2) + 5;

Du hast den Multiplikationsoperator vergessen.

hab cmath includet.. aber geht trotzdem nur wenn ich x*x*x mache..

keine ahnung was ich falsch mache

Eisflamme

0.1 * pow(bla)

dot

mit cmath isses std::pow(). Trotzdem solltest du wie gesagt besser mit Multiplikationen arbeiten.

HighLigerBiMBam

Wie wäre es mit Fehlermeldung und Code... Oder lesen der FAQ?

geht auch nich -.-

y = 0.1 * pow(x,3) - 2 * pow(x,2) + 5;

theta

Troll...

naja danke für eure hilfe..

ich glaube ihr habt mir bissl weitergeholfen

dot schrieb:

mit cmath isses std::pow(). Trotzdem solltest du wie gesagt besser mit Multiplikationen arbeiten.

Warum?
1. ist es mir pow besser lesbar/wartbar
2. hat pow überladungen für int-exponenten. Und dreimal darfst du raten, was das macht...

asdfasd schrieb:

dot schrieb:

mit cmath isses std::pow(). Trotzdem solltest du wie gesagt besser mit Multiplikationen arbeiten.

Warum?
1. ist es mir pow besser lesbar/wartbar

das ist Ansichtssache. Besser lesbar/wartbar finde ich z.B.:

struct Horner
{
    explicit Horner( double x ) : m_x( x ) {}
    double operator()( double y, double ki ) const
    {
        return (y *= m_x) += ki;
    }
private:
    double m_x;
};

// ... und später
    double koeff[] = { 0.1, -2., 0., 5. };
    double y = std::accumulate( koeff, koeff + sizeof(koeff)/sizeof(*koeff), 0.0, Horner( x ) );

asdfasd schrieb:

2. hat pow überladungen für int-exponenten. Und dreimal darfst du raten, was das macht...

immer noch zu viel; verglichen mit dem Horner-Schema.

ipsec

Bei konstanten Exponenten ist noch die pow<n>(x) Templatefunktion aus boost.math erwähnenswert. Die generiert Code enthält nur ln2(x) Multiplikationen und ist damit meist effizienter als eine ausgeschriebene Multiplikation.
Beispiel: aus pow<8>(x) wird Code equivalent zu ((x*x)*(x*x))*((x*x)*(x*x)) , wobei jeder Term nur einmal ausgewertet wird, es also schlussendlich nur 3 Multiplikationen sind. Beim üblichen Ausschreiben x*x*x*x*x*x*x*x sind es 7, somit ist pow hier um mehr als den Faktor 2 schneller.