ich habe ein Problem bei einer Aufgabe die ich in Informatik erledigen muss.

Wir sollen eine Reihe berechnen und das nur durch Arithmetik und Logik einer While for schleife.

Die Reihe die berechet werden soll:
http://www.abload.de/img/reihe3oka.jpg

Aufgaben stellung:
Erstellen Sie je ein Schleifen-Programm zur Berechnung der Reihe. Hierzu verwenden Sie bitte nur die elementare Arithmetik und Logik, keine mathematischen Funktionen.

Das Endkriterium für Programm 1 ist die Anzahl der Schleifendurchläufe. Hierzu wählen sie n 530947. Zum Nachweis der Korektheit zeigen Se das Ergebnis der ersten drei Teilsummen und das Ergebnis für n.

Ich würde mich sehr über Hilfe freuen.

LG Koebbe

Ich würde mich sehr über Hilfe freuen.

Ich helfe dir mal, Hilfe zu finden:
Du brauchst Hilfe?
Warum dir keiner helfen will.

#include<iostream>
#include<numeric>

class Addend
{
private:
  unsigned int n;
public:
  Addend(unsigned int n):n(n){}
  double operator*()
  {
    return 1./((2*n+1)*(2*n+1));
  }
  Addend& operator++()
  {
    ++n;
    return *this;
  }
  friend bool operator!=(Addend lhs, Addend rhs);
};

bool operator!=(Addend lhs, Addend rhs)
{
  return lhs.n != rhs.n;
}

const unsigned max_n = 530947;

int main()
{
  std::cout << "Von n=0 bis n=" << max_n << ": " << std::accumulate(Addend(0), Addend(max_n + 1), 0.) << std::endl;
}

Nur ich habe derzeit das Problem das ich nicht den Richtigen ausdruck für
meine Schleife finde.
for(m= 0; m <= n; m++)
s = 1/(2*m+1)*(2m+1);
das habe ich gemacht aber damit habe ich nicht annähernd das gewünschte ergebniss

Es soll ja keiner behaupten, dass ich nie helfen würde:

... std::accumulate(Addend(0), ...

Ich weiß gar nicht wie das im Standard geregelt ist, aber im DEBUG braucht z.B. der vc für accumulate die typedefs wie iterator_category usw. Für eigene Iteratoren, die ich mit der STL benutzen möchte definiere ich mir die aus Gründen der Portablilität daher immer mit. Ich glaube dafür gibt es auch eine boost::iterator_facade oder so ähnlich.

SeppJ schrieb:

Es soll ja keiner behaupten, dass ich nie helfen würde:

... std::accumulate(Addend(0), ...

Ich weiß gar nicht wie das im Standard geregelt ist, aber im DEBUG braucht z.B. der vc für accumulate die typedefs wie iterator_category usw. Für eigene Iteratoren, die ich mit der STL benutzen möchte definiere ich mir die aus Gründen der Portablilität daher immer mit. Ich glaube dafür gibt es auch eine boost::iterator_facade oder so ähnlich.

Ahh, das erklärt die ganzen Fehlermeldungen als ich versucht habe, die partial_sums zu berechnen. War mir gar nicht bewusst, dass dies für Iteratoren zum Pflichtprogramm gehört und war ganz erstaunt, als es ohne nicht ging.

Werde ich gleich mal ausbessern.

#include<iostream>
#include<numeric>

class Addend
{
private:
    unsigned n;
public:
    Addend(unsigned n):n(n) {}
    double operator*()
    {
        return 1./((2*n+1)*(2*n+1));
    }
    Addend operator++()
    {
        ++n;
        return *this;
    }
    friend bool operator!=(Addend lhs, Addend rhs)
    {
        return lhs.n != rhs.n;
    }
};

const unsigned max_n = 530947;

int main()
{
    std::cout.precision(10);
    std::cout << std::accumulate(Addend(0), Addend(1), 0.) << '\n';
    std::cout << std::accumulate(Addend(0), Addend(2), 0.) << '\n';
    std::cout << std::accumulate(Addend(0), Addend(3), 0.) << '\n';
    std::cout << std::accumulate(Addend(0), Addend(max_n + 1), 0.) << '\n';
}

#include<iostream>
#include<numeric>
#include<iterator>
#include<algorithm>
#include<vector>

class Addend: public std::iterator<std::input_iterator_tag, double>
{
private:
  unsigned int n;
public:
  Addend(unsigned int n=0):n(n){}
  double operator*()
  {
    return 1./((2*n+1)*(2*n+1));
  }
  Addend& operator++()
  {
    ++n;
    return *this;
  }
  Addend operator++(int)
  {
    Addend old(*this);
    ++n;
    return old;
  }
  friend bool operator!=(Addend lhs, Addend rhs)
  {
    return lhs.n != rhs.n;
  }
  friend bool operator==(Addend lhs, Addend rhs)
  {
    return lhs.n == rhs.n;
  }
};

const unsigned max_part = 3;
const unsigned max_n = 530947;

int main()
{
  std::vector<double> partial_sums(max_part);
  std::partial_sum(Addend(0), Addend(max_part), partial_sums.begin());
  std::ostream_iterator<double> double_out(std::cout, "\n");
  std::cout << "Die ersten " << max_part <<" Teilsummen:\n";
  std::copy(partial_sums.begin(), partial_sums.end(), double_out);
  std::cout << "Summe von n=0 bis n=" << max_n << ": " << std::accumulate(Addend(0), Addend(max_n + 1), 0.) << std::endl;
}

So kann man es abgeben. Absolut glaubwürdig als eigenes Werk.

Ich frage mich, ob man noch ein paar typedefs einführen sollte. Das Wort double kommt für meinen Geschmack recht häufig vor, was wenn man später mal genaueres möchte?
Außerdem könnte man noch eine Ausgabeklasse schreiben, welche die ersten n Teilsummen und die Summe bis m berechnet und ausgibt. Die main ist jetzt nämlich ein bisschen unaufgeräumt.

Nur haben wir bis jetzt noch nicht mit

#include <iostream>
#include<numeric>
#include<iterator>
#include<algorithm>
#include<vector>
gearbeitet

normal machen wir alles mit
#include <stdio.h>

Ich frage mich, ob man noch ein paar typedefs einführen sollte. Das Wort double kommt für meinen Geschmack recht häufig vor, was wenn man später mal genaueres möchte?

Jo, ich schlage mal vor, die wichtige Funktion per Template-Parameter mit den Typen zu versorgen.

#include<iostream>
#include<numeric>
#include<iterator>
#include<algorithm>
#include<vector>

template<typename numtype,typename counttype>
class Addend: public std::iterator<std::input_iterator_tag, double>
{
private:
    counttype n;
public:
    Addend(counttype n=0):n(n) {}
    numtype operator*()
    {
        return numtype(1)/numtype((2*n+1)*(2*n+1));
    }
    Addend& operator++()
    {
        ++n;
        return *this;
    }
    Addend operator++(int)
    {
        Addend old(*this);
        ++n;
        return old;
    }
    friend bool operator!=(Addend lhs, Addend rhs)
    {
        return lhs.n != rhs.n;
    }
    friend bool operator==(Addend lhs, Addend rhs)
    {
        return lhs.n == rhs.n;
    }
};

template<typename numtype,typename counttype>
void solve(counttype max_part=3,counttype max_n=530947)
{
    typedef Addend<numtype,counttype> Ad;
    std::vector<numtype> partial_sums(max_part);
    std::partial_sum(Ad(), Ad(max_part), partial_sums.begin());
    std::ostream_iterator<numtype> double_out(std::cout, "\n");
    std::cout << "Die ersten " << max_part <<" Teilsummen:\n";
    std::copy(partial_sums.begin(), partial_sums.end(), double_out);
    std::cout << "Summe von n=0 bis n=" << max_n << ": " << std::accumulate(Ad(), Ad(max_n + 1), numtype(0)) << std::endl;
}

int main()
{
    solve<double,unsigned int>();
}

normal machen wir alles mit
#include <stdio.h>

Also lernt ihr C und nicht C++?

hört sich erstmal alles ganz nett an.

Nur haben wir bis jetzt noch nicht mit

#include <iostream>
#include<numeric>
#include<iterator>
#include<algorithm>
#include<vector>
gearbeitet

normal machen wir alles mit
#include <stdio.h>

Bist du sicher, dass du eine C++ und keine C Vorlesung besuchst?

So, mit volkards und brotbernds Anmerkungen hier eine neue Version.

Wenn du das Ergebnis von partial_sum nicht für das anschließende accumulate, benutzt, kannst du doch für partial_sum gleich deinen double_out benutzen.

template<typename numtype,typename counttype>
void solve(counttype max_part=3,counttype max_n=530947)
{
    typedef Addend<numtype,counttype> Ad;
    std::ostream_iterator<numtype> double_out(std::cout, "\n");
    std::cout << "Die ersten " << max_part <<" Teilsummen:\n";
    std::partial_sum(Ad(), Ad(max_part), double_out);
    std::cout << "Summe von n=0 bis n=" << max_n << ": " << std::accumulate(Ad(), Ad(max_n + 1), numtype(0)) << std::endl;
}

Addend operator++(int)
  {
    Addend old(*this);
    ++(*this);
    return old;
  }

Dann ist das robust gegen Änderungen an der Inkrementierungsfunktionalität der Klasse.

Da kann ich auch verstehen warum eure Programme anders sind

Hmm ne jetzt bin ich mir grade nicht sicher. Bin leider nicht der Fitteste im Programmieren. Habe grade noch einmal geschaut, aber wie ihr es euch denken könnt es ist C

Dann stell die Frage nochmal im C-Forum. Und schreib dazu, was Du schon hast. Je mehr Du schon hast, desto hilfreicher werden die Antworten.

Eine habe ich auch noch:

Auch noch einen

friend bool operator!=(Addend lhs, Addend rhs)
{
  return !(lhs == rhs);
}
friend bool operator==(Addend lhs, Addend rhs)
{
 return lhs.n == rhs.n;
}

Aber danke euch trotzdem für die schnelle und doch recht Großen Hilfsversuche

Sorry für die umstände

Da hat sich ja schon wieder ein std::endl eingeschlichen.

Dieses Mal meine ich es auch. Am Ende will ich, dass der Puffer geflusht wird.

edit: Wobei ich nicht technisch begründen kann, wieso. Jetzt wo ich drüber nachdenke macht es keinen Sinn, da das cout-Objekt am Programmende ja zerstört werden sollte und dabei geflusht wird.

Eine habe ich auch noch:
Der Operator++(int) sollte besser so aussehen:

Addend operator++(int)
  {
    Addend old(*this);
    ++(*this);
    return old;
  }

brotbernd schrieb:

Auch noch einen

friend bool operator!=(Addend lhs, Addend rhs)
{
  return !(lhs == rhs);
}
friend bool operator==(Addend lhs, Addend rhs)
{
 return lhs.n == rhs.n;
}

Oder kurz:

class Addend : public boost::input_iterator_helper<Addend, double>
{
private:
  unsigned int n;
public:
  Addend(unsigned int n=0):n(n){}
  double operator*()
  {
    return 1./((2*n+1)*(2*n+1));
  }
  Addend& operator++()
  {
    ++n;
    return *this;
  } 
  friend bool operator==(Addend lhs, Addend rhs)
  {
    return lhs.n == rhs.n;
  }
};

- das template von dem abgeleitet wird definiert op!=, op++(int), op-> und die typedefs des std::iterator, die benötigt werden.
siehe http://www.boost.org/doc/libs/1_39_0/libs/utility/operators.htm#iterator
und magazin (http://magazin.c-plusplus.net/artikel/�berladung von Operatoren in CPlusPlus (Teil 3) - boost%3A%3Aoperators f�r Fortgeschrittene)

meine Reihe sieht so aus :
http://www.bilder-hochladen.net/files/1a0a-7.jpg

und ich bin so weit:

#include<stdio.h>

void main()
{
	printf("*************************************\n");
	printf("*         Schleifenaufgabe          *\n");
	printf("*        Autor: Yannik Baus         *\n");
	printf("*************************************\n\n");

	int m,n,k;
	double p;

	printf("Bitte geben Sie n an:\t");
	scanf_s("%i", &n);

		m=0;
		p=1;
		k=0;

		while(m<=n)	
		{
		p=p+1/k;
		k*3;
		m+1;
		}

	printf("\nDas Ergebnis lautet: %d\n",p);
}

BZW. so weit:

#include<stdio.h>

void main()
{
printf("*************************************\n");
printf("* Schleifenaufgabe *\n");
printf("* Autor: DisasterMaster *\n");
printf("*************************************\n\n");

int m,n,k;
double p;

printf("Bitte geben Sie n an:\t");
scanf_s("%i", &n);

p=1;

for(m=1 ; m<=n ; m++)

for(k=3 ; k>0 ; k=k*3){
p+=1/k;
break;
}

printf("\nDas Ergebnis lautet: %d\n",p);
}

Ich kriege jedoch immer nur eine 0 als antwort.
Bitte schnell um Hilfe.

/edit pumuckl: cpp-Tags. Demnächst bitte selbst machen!