Reihe berechnen nur mit Arithmetik und Logik

brotbernd

SeppJ schrieb:

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;
}

SeppJ

Schöne Verbesserungen . Eine habe ich auch noch:
Der Operator++(int) sollte besser so aussehen:

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

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

Koebbe

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

Da kann ich auch verstehen warum eure Programme anders sind

volkard

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

volkard

Koebbe schrieb:

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.

brotbernd

SeppJ schrieb:

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;
}

Koebbe

Ja danke ich versuche mein bestes

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

Sorry für die umstände

SeppJ

volkard schrieb:

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.

pumuckl

SeppJ schrieb:

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)

Da ich in dem Selben Semester mit dir an der FH D studiere habe ich auch noch eine kleine Frage zum Thema.

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!

volkard

Die Antwort auf die 0 steht bereits in diesem Thread.
int geteilt durch int ergibt int.

Michael E.

DisasterMaster schrieb:

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

Lies dir die erste Seite des Threads durch.

Dummerweise schnall ich es trotzdem nicht. Was muss ich denn jetzt genau machen?

#include<stdio.h>

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

int m,n,k;
double p,f;

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){
f=1.0/k;
p+=f;
break;
}
}
printf("\nDas Ergebnis lautet: %d\n",p);
}

So zeigt es mir zwar keine 0 mehr an, dafür aber ganz unrealistische Zahlen.

SeppJ

Du hast auch sonst noch sehr viele Grundlagenfehler drin:

void main()
Auch in C heißt dies int main() .

k*3;
Dies berechnet was k*3 ist und verwirft den Wert dann. Es wird nicht der Wert von k verdreifacht!

m+1;
dito.

`

printf("\nDas Ergebnis lautet: %d\n",p); `
%d ist der Formatstring für Integer, p ist ein double.

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

Was macht das break dort wohl?

So ich hoffe ich hab die Kritikpunkte richtig verstanden und umgesetzt, jedoch komm jetzt immer 1 raus

#include<stdio.h>

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

int m,n,k,t;
double p,f;

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

k=3;
t=1;
p=1;
for(m=t ; m<=n ; m++){

t=1+1;

for(k=3; m<=n ; m++){

f=1/k;
p=p+f;
k=3*k;
}
}
printf("\nDas Ergebnis lautet: %f\n",p);
}
}

Michael E.

Dann halt zum dritten Mal: 1/k = 0. Auch sonst solltest du nochmal überlegen, wie viele Variablen du brauchst und was die genau machen sollen.

SeppJ

Außerdem ist deine Klammerung glaube ich falsch. Da du es aber selbst beim dritten Anlauf noch nicht hinbekommen hast, deinen Code vernünftig zu formatieren (Benutze den C/C++-Knopf links unter den Smileys), mag ich mir das gerade nicht genauer ansehen.

unskilled

DisasterMaster schrieb:

#include<stdio.h>

int main()
{
  int m,n,k,t;
  double p,f;

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

  k=3;
  t=1;
  p=1;
  for(m=t ; m<=n ; m++)
  { 
    t=1+1;
    for(k=3; m<=n ; m++)
    {
      f=1/k;
      p=p+f;
      k=3*k;
    }
  }
  printf("\nDas Ergebnis lautet: %f\n",p);
}

sind keine fehler korrigiert außer die } zu viel.
aber vll guckt es sich jz wer an, wo man es auch lesen kann...
was nen "copyright" in so nem post sucht, werd ich wohl auch niemals verstehen...
naja - vll falls der lehrer googelt sieht er wenigstens, dass es keine fertig-lösung war...

for(m=t ; m<=n ; m++)
  { 
    t=1+1;
    for(k=3; m<=n ; m++)

das sieht beim ersten drübergucken aber mehr als falsch aus

bb

Ich glaube ich habe es geschafft. juhu
Vielen Dank für die große Hilfe!

Werner Salomon

Hallo .. ein kleiner Programmier Contest mit SeppJ und Volkard, da darf mein Beitrag nicht fehlen:

#include <iostream>
#include <cmath> // std::acos (nur zur Kontrolle)
#include <numeric> // accumulate

#include <boost/iterator/iterator_adaptor.hpp>

// --   Folge: 1/(2*m+1)^2
class A : public boost::iterator_adaptor< A, int, double, boost::bidirectional_traversal_tag, const double >
{
public:
    explicit A( int m = 0 ) 
        : iterator_adaptor_( m )
    {}
    double dereference() const 
    { 
        int z = 2 * base() + 1;
        return 1.0 / (double(z) * z); // double(z) sonst integer-overflow!
    }
};

namespace { const double PI = std::acos(-1.0); }

int main () 
{
    using namespace std;

    cout.precision( 8 ); // zeigt den Unterschied zwischen s[n] und s[unendlich]
    const int nn[] = { 0, 1, 2, /*n=*/ 530947 }; // .. zeigen Se das Ergebnis der ersten drei Teilsummen und das Ergebnis für n
    double sum = 0;
    A a(0);
    for( const int* n = nn; n != nn+sizeof(nn)/sizeof(*nn); a = A(*n++ + 1) )
        cout << "n=" << *n << "; sum=" << (sum = accumulate( a, A(*n + 1), sum )) << endl;

    cout << "n=unendlich; sum = " << (PI*PI/8) << endl;
    return 0;
}

Gruß
Werner