Iteracja na dużym zakresie liczb

Mam takie oto zadanko.

Zaimplementuj w języku „C/C++” algorytm obliczający przybliżone wartości funkcji
f(x) = [1 − exp(−x)]/x dla x ∈ [10 do potęgi −30, 10 do potęgi 9], korzystając z funkcji standardowej exp().

Kod który na razie zaimplementowałem:

double funkcja(int x)
{
	double f = ( 1 - exp (-x))/x;
	return f;
}

int main(int argc, char** argv) 
{
	return 0;
} 

Nie za bardzo wiem jak zrobić iteracje po tak dużym zakresie liczb, czy mógłby mnie ktoś nakierować jak to zrobić?

Normalnie, co za różnica… Nie trzymasz niczego w pamięci, więc nie trzeba specjalnie kombinować. Możesz sobie np. ustawić jakiś krok i zmieniać licznik odpowiednio, możesz wyznaczyć wartości dla każdej z potęg dziesiątki w zadanym zakresie… Jak lubisz.

zamiast dodawać, przemnażaj, wtedy będziesz miał stałe odległości na logscale:

for(double d = pow(10,-30); d <= 1000000000; d *= 1.5) {
    process(d);
}

Przy czym o ile dobrze pamiętam 10^-30 jest poza zasięgiem dokładności double'a na typowej architekturze.... Źle pamiętałem.

 #include <iostream>
#include <math.h>
#include <conio.h>

double funkcja(int x)
{
	double f = ( 1 - exp (-x))/x;
	return f;
}

using namespace std;

int main(int argc, char** argv) 
{
	for(double i = pow(10,30); i<=pow(10,9); i*= 1.5)
	{
		cout << funkcja(i) << endl;
	}
	getch();
	return 0;
}

Ten kod się kompiluje ale nic nie zwraca ... dlaczego?

10³⁰ i 10^-30 to zupełnie różne liczby.

Swoją drogą, przyjmowanie int przez funkcja pozbawia to rozwiązanie sensu. Użyj również double.

Zapomniałem że trzeba wykorzystywać liczby podwójnej precyzji, ale chyba z tego co rozumiem w tym zadaniu jest to wykorzystywane.

double jest nazywany po polsku liczbą zmiennoprzecinkową podwójnej precyzji. Trochę mylące, jako że potrafi być bardziej niż dwa razy dłuższy (np. niczym niezwykłym jest 32-bitowy float i 64- lub 80-bitowy double).

yardi1993 napisał(a):

Mam takie oto zadanko.

Zaimplementuj w języku „C/C++” algorytm obliczający przybliżone wartości funkcji
f(x) = [1 − exp(−x)]/x dla x ∈ [10 do potęgi −30, 10 do potęgi 9], korzystając z funkcji standardowej exp().

Kod który na razie zaimplementowałem:

double funkcja(int x)
{
	double f = ( 1 - exp (-x))/x;
	return f;
}

int main(int argc, char** argv) 
{
	return 0;
} 

Nie za bardzo wiem jak zrobić iteracje po tak dużym zakresie liczb, czy mógłby mnie ktoś nakierować jak to zrobić?

Prawdopodobnie jest tu pułapka na amatorów, pt. redukcja precyzji.

exp(x) = 1 + x + x^2/2 + ...

zatem wyrażenie: 1 - exp(-x) = 1 - (1 - x + o(x^2)) = x - o(x^2);

co chyba po podzieleniu przez x spowoduje redukcję - utratę precyzji, w pobliżu x=0;