Algorytm iteracyjny obliczający pewną wartość z zadaną dokładnością

Witam serdecznie, mam następujący problem z pewnym projektem. Mianowicie muszę obliczyć wartość liczby e z definicji (e jako granica ciągu) i z tym sobie już poradziłem. Jednak zadanie polega też na zaimplementowaniu algorytmu obliczającego wartość z zadaną dokładnością. Przedstawię poniżej jak rzeczony algorytm wygląda:

 
funkcja a( n : integer ) : double
{
return(pow ((1 + ( 1 / n )), n);)
}
 
 
funkcja ObliczE_wersja1( żądanaDokładność : double ) : double
{
dokładność = nieskończoność;
wartość_poprzednia = wartość_bieżąca = a(1);
i = 2;
dopóki ( dokładność > żądanaDokladność ) wykonuj
{
wartość_poprzednia = wartość_bieżąca;
wartość_bieżąca = a(i);
dokładność = | wartość_poprzednia – wartość_bieżąca |;
ASSERT „bieżąca dokładność < poprzednio obliczona dokładność”
i++;
}
return wartość_bieżąca;
}
 

tutaj zamieszczam mój kod:

 
#include <stdio.h>
#include <math.h>
#include <iostream>
 
 
using namespace std;
 
double a,b,c,n=1;
int i;
 
int main ()
{
  cout.precision(15);  
  for (i=0;i<100000000;i++,n++)
  {
  a = pow ((1 + ( 1 / n )), n);
  b = pow ((1 + ( 1 / n )), n-1);
  c=fabs(b-a);
 
 
  system("CLS");
  cout<<a<<endl;
  cout<<i<<endl;
  cout<<c;
  }
 
  system("PAUSE > null");
  return 0;
}

Moje pytanie brzmi jak to zrobić, bo przyznam się szczerze, że nie rozumiem tej koncepcji zadanej wartości przybliżonej - czy mógłby mi ktoś wyjaśnić o co tu chodzi ? jakieś wskazówki cokolwiek.

 
//obliczenie liczby e
#include<iostream>
#include <conio.h>
#include <math.h>
using namespace std;

int main()
{
  cout.precision(10);  
  cout.setf(ios::fixed,ios::floatfield); 
  double a,b,dokl=0.0000001;
  int n=1;  
  do
  {
    a= pow ((1 +  1 / double(n) ), n);  
    b= pow ((1 +  1 /double(n+1)), n+1);
   n++;
  } while((b-a)>dokl);
  
   cout<<"e= "<<b<<endl;  
getch();  
}

Dziękuje serdecznie za pomoc! Wyjaśniłeś mi kodem o co chodzi !

Teraz mam kolejne pytanie, zaimplementowałem w kodzie algorytm realizujący potęgowanie, który znalazłem w jednym z artykułów:
Potęgowanie
Dziła świetnie, tylko że pojawia się następujący problem gdy warunek w pętli for zwiększę np do 1000000 to wynik jest mniejszy niż być powinien.
Algorytm liczy granicę ciągu, który jest ściśle rosnący aż do liczby e. Wszystko działa ok ale dla mniejszych wartości np dla 100.000 e=2.721
a dla wspomnianego miliona 2.59.. czemu tak się dzieje ?

#include <iostream>

using namespace std;

float power2(float a, int b);
float c,d,n=1;

main(){
cout.precision(10);


for (int i=1;i<10000;i++,n++)
{
c=(1 + ( 1 / n ));
d=power2(c, i);
}
cout<<d;

system("PAUSE > null");

}
float power2(float a, int b) {
        float wynik = 1;
        float v = a;
        for (int i = b; i > 0; i /= 2) {
                if (i % 2 == 1) {
                        wynik = wynik * v;
                }
                v = v * v;
        }
        return wynik;
}