Frage zur funktion pow

Hallo.. kann ich die zeile

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

auch anders schreiben ? das mit den x*x*x ist ja nun nicht gerade schön

mir schwebt folgendes vor, nur leider geht das nicht

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

kann mir viell. jemand helfen ?

SeppJ

Syntaxgrundlagen?

So sehen Funktionsaufrufe aus: pow(x,3)

dot

Wenn du einfach nur ganzzahlige Exponenten willst würd ich aber mit Multiplikationen arbeiten wie dus da oben tust. pow() ist in dem Fall unnötig und um Größenordnungen langsamer...

SeppJ schrieb:

Syntaxgrundlagen?

So sehen Funktionsaufrufe aus: pow(x,3)

Ja ich weiss..

aber so gehts auch nicht:

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

Ich denke, er wusste nichts von der Funktion und hielt es für ein Sprachmittel.
Dafür braucht man jedoch den Header cmath .

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.