ich überlege gerade, wie ich mittels std::accumulate eine Potenzreihe ausrechnen kann. Sagen wir ich habe gegeben

$S = \sum_{i=0}^n \, a_i \, T^i$

Die Koeffizienten $a_i$ kann ich bequem in einem vector std::vector<double> coef speichern, d.h. ich könnte zu einem gegebenen T ansetzen

double T; // irgendein Wert
std::accumulate(coef.begin(), coef.end(), 0.0,
  [T](double sum, double a){ return sum + a * T; }

Das Problem ist nun, dass T derart potentziert werden muss, je nachdem an welcher Stelle das Aufsummieren im Vektor coef gerade steht. Mit iterator - Arithmetik wäre die Potenz gerade iter - coef.begin() .

Lässt sich das einbauen, also auf den verwendeten Iterator zugreifen?

Oder gibt es ganz andere elegante Ansätze - ich sehe es gerade als Programmierübung.

Gruß,
-- Klaus.

Der Accululator ist einfach ein Paar aus Summe und Index, also <sum, index>.

Meinst du damit std::pair ?

Gruß,
-- Klaus.

class S_functor
{
public:
  // Konstruktor

  double operator()(double sum, double coef)
  {
     auto t = std::pow(base_t_, i_++);
     return sum + coef * t;
  }

private:
  double base_t_;
  size_t i_ = 0;
};

Oder gibt es ganz andere elegante Ansätze - ich sehe es gerade als Programmierübung.

Manche haben sowas wie integer-ranges oder -iteratoren. Damit und mit inner_product könnte es auch klappen.

double coef[] = { 1, -4, -5 };
    for( double x; cin >> x; )
        cout << "f(" << x << ") = " 
            << accumulate( begin(coef), end(coef), 0.0, [x]( double sum, double a_i )->double { return sum * x + a_i; } ) 
            << endl;

oder?

// T gegeben

double power_series = 0.0;

for(unsigned int = 0; i < coef.size(); ++i)
  power_series += coef[ i ] * boost::units::pow<i>( T );

Nur jetzt knirscht es bei Boost, dass i nicht konstant wäre? Muss ich aus dem i in jedem Durchlauf eine Konstante basteln?

Gruß,
-- Klaus.

boost::units::pow ist für Potenzierung zur Compiletime gedacht.
Nimm std::pow für variable Potenzen.

Okay, verstehe. Ich dache ich könnte gleich die 'schnellere' Variante von boost nehmen.

Gruß,
-- Klaus.

Nathan schrieb:

boost::units::pow ist für Potenzierung zur Compiletime gedacht.
Nimm std::pow für variable Potenzen.

Okay, verstehe. Ich dache ich könnte gleich die 'schnellere' Variante von boost nehmen.

Die ist nur schneller, wenn der Wert zur Compilezeit feststeht.
Aus pow<2>(x) macht sie nämlich x*x und so für alle kleineren (?) Potenzen.
Das geht aber nicht, wenn das eine Variable ist.

Ich dache ich könnte gleich die 'schnellere' Variante von boost nehmen.

Die wäre auch nicht schneller als das simple Horner Schema (s. 12:57:58) - eher im Gegenteil!

Aus pow<2>(x) macht sie nämlich x*x und so für alle kleineren (?) Potenzen.

Das geht mit TMP fuer alle Exponenten. Zumindest seit C++11.

Horner-Schema ist hier aber ein Muss.

Aus pow<2>(x) macht sie nämlich x*x und so für alle kleineren (?) Potenzen.

Das geht mit TMP fuer alle Exponenten. Zumindest seit C++11.

Das ist mir klar, dass das mit allen geht.
Ich hab mich nur gefragt, ob es eventuell bei pow<1000>(x) oder so, vielleicht effizienter wäre, das mit einer Schleife zu machen.

Arcoth schrieb:

Aus pow<2>(x) macht sie nämlich x*x und so für alle kleineren (?) Potenzen.

Das geht mit TMP fuer alle Exponenten. Zumindest seit C++11.

Das ist mir klar, dass das mit allen geht.
Ich hab mich nur gefragt, ob es eventuell bei pow<1000>(x) oder so, vielleicht effizienter wäre, das mit einer Schleife zu machen.

Na ja - bei einer Schleife wären es wahrscheinlich 999 Multiplikationen und wie ich die boost-people kenne, schafft es pow<1000>(x) mit ca. einem Dutzend Multiplikationen.

Ich hab mich nur gefragt, ob es eventuell bei pow<1000>(x) oder so, vielleicht effizienter wäre, das mit einer Schleife zu machen.

Auf gar keinen Fall. Square and Multiply wenden die an.

Ich hab mich nur gefragt, ob es eventuell bei pow<1000>(x) oder so, vielleicht effizienter wäre, das mit einer Schleife zu machen.

Auf gar keinen Fall. Square and Multiply wenden die an.

Auf gar keinen Fall! Für doubles nehmen die den ensprechenden Opcode.

Also ich bin es mal ohne std::accumulate mit einer for Schleife angegangen, vielleicht muss ich nicht immer mit Kanonen auf Spatzen schießen:

D.h. du hast das Beispiel von Werner nicht verstanden.