Tekst źródłowy strony C/exp

=== Plik nagłówkowy ===

[[C/Biblioteka standardowa/Indeks tematyczny#math.h|math.h]]

==== [[w:Funkcja wykładnicza|Funkcje wykładnicze]] ====

 double      exp   (double      x);
 float       expf  (float       x);
 long double expl  (long double x);
 
 double      exp2  (double      x);
 float       exp2f (float       x);
 long double exp2l (long double x);
 
 double      expm1 (double      x);
 float       expm1f(float       x);
 long double expm1l(long double x);
 
 double      ldexp (double      x, int n);
 float       ldexpf(float       x, int n);
 long double ldexpl(long double x, int n);
 
 double      scalbn (double      x, int n);
 float       scalbnf(float       x, int n);
 long double scalbnl(long double x, int n);
 
 double      scalbln (double      x, long n);
 float       scalblnf(float       x, long n);
 long double scalblnl(long double x, long n);

==== [[w:Funkcja logarytmiczna|Funkcje logarytmiczne]] ====

 double      log (double      x);
 float       logf(float       x);
 long double logl(long double x);
 
 double      log10 (double      x);
 float       log10f(float       x);
 long double log10l(long double x);
 
 double      log1p (double      x);
 float       log1pf(float       x);
 long double log1pl(long double x);
 
 double      log2 (double      x);
 float       log2f(float       x);
 long double log2l(long double x);
 
 double      logb (double      x);
 float       logbf(float       x);
 long double logbl(long double x);
 
 int         ilogb (double      x);
 int         ilogbf(float       x);
 int         ilogbl(long double x);
 
 double      frexp (double      x, int *n);
 float       frexpf(float       x, int *n);
 long double frexpl(long double x, int *n);

==== Stałe ====

 #define FP_ILOGB0 ''watość''
 #define FP_ILOGBNAN ''wartość''

=== Argumenty ===
; x: argument funkcji
; n: wykładnik

=== Opis ===
Funkcje z przyrostkami "f" i "l" to inne wersje odpowiedniej funkcji bez przyrostka operujące na innych typach danych. Z tego powodu w poniższym opisie odwołanie do konkretnej funkcji będzie oznaczać odwołanie się do wszystkich 3 wersji.

Funkcje obliczają następujące wartości:
{| class="wikitable"
| <tt>exp</tt> || [[w:Eksponenta|eksponenta]] <tt>x</tt> || <math>\exp(x) \,</math> czyli <math>e^x \,</math>
|-
| <tt>exp2</tt> || dwa do potęgi <tt>x</tt> || <math>2^x \,</math>
|-
| <tt>expm1</tt> || eksponenta <tt>x</tt> pomniejszona o jeden || <math>e^x-1 \,</math>
|-
| <tt>ldexp</tt> || <tt>x</tt> razy dwa do potęgi <tt>n</tt> || <math>x \cdot 2^n \,</math>
|-
| <tt>scalbln</tt> i <tt>scalbn</tt> || <tt>x</tt> razy [[C/FLT_RADIX|FLT_RADIX]] do potęgi <tt>n</tt> || <math>x \cdot \mathrm{FLT\_RADIX}^n \,</math>
|-
| <tt>log</tt> || [[w:Funkcja logarytmiczna|logarytm]] naturalny z <tt>x</tt> || <math>\ln(x) \,</math> lub <math>\log_e(x) \,</math>
|-
| <tt>log10</tt> || logarytm dziesiętny z <tt>x</tt> || <math>\log_{10}(x) \,</math>
|-
| <tt>log1p</tt> || logarytm naturalny z jeden plus <tt>x</tt> || <math>\ln(1+x) \,</math>
|-
| <tt>log2</tt> || logarytm o podstawie dwa z <tt>x</tt> || <math>\log_2(x) \,</math>
|-
| <tt>logb</tt> || zwraca wykładnik podanego argumentu jako liczbę całkowitą ze znakiem, w taki sposób, że dla dodatniego skończonego argumentu zachodzi:  <math>1 \le x \cdot \mathrm{FLT\_RADIX}^{-logb(x)} < \mathrm{FLT\_RADIX}</math> ||
|-
| <tt>ilogb</tt> || jeżeli <tt>x</tt> jest równy zero wartość FP_ILOGB0; jeżeli jest równy nieskończoność - [[C/INT_MAX|INT_MAX]]; jeżeli jest to wartość NaN - FP_ILOGBNAN; w przeciwnym wypadku wartość zwracana przez logb zrzutowaną do typu int ||
|-
| <tt>frexp</tt> || zwraca znormalizowaną część liczby <tt>x</tt> z przedziału <tt><nowiki>[0,5; 1)</nowiki></tt>, a zmiennej wskazywanej przez <tt>n</tt> zapisuje wykładnik potęgi dwójki; jeżeli <tt>x</tt> jest równe zero obie części są równe zero ||
|}

Jeżeli <tt>x</tt> jest liczbą ujemną (mniejszą od -1) funkcje log, log10 i log2 ustawiają (funkcja log1p ustawia) zmienną [[C/errno|errno]] na [[C/EDOM|EDOM]].

Stała FP_ILOGB ma wartość [[C/INT_MIN|INT_MIN]] lub -[[C/INT_MAX|INT_MAX]], natomiast FP_ILOGBNAN wartość [[C/INT_MAX|INT_MAX]] lub [[C/INT_MIN|INT_MIN]].

=== Wartość zwracana ===
Wartości odpowiednich funkcji zgodnei z opisem powyżej.

Ponadto, jeżeli wystąpi nadmair funkcja zwraca w wyniku [[C/HUGE_VAL|HUGE_VAL]] z odpowiednim znakiem i ustawia wartość zmeinnej errno na [[C/ERANGE|ERANGE]]. Jeśli wystąpi niedomiar funkcja w wyniku zwraca zero, a to czy do zmiennej errno zostanie zapisana wartość ERANGE zależy od implementacji.

=== Przykład użycia ===

====Bezpieczne użycie====

Sprawdzanie zakresu zmiennej wejściowej przed użyciem funkcji :

<syntaxhighlight lang=c>

double x, r;

if (isnan(x) || islessequal(x, 0))

{ /* Deal with NaN / pole error / domain error */ }

r = log(x);

</syntaxhighlight>


====Czas rozpadu====


[[w:Czas połowicznego rozpadu|Czas połowicznego rozpadu]] pierwiastka to czas, po którym rozpadnie się połowa atomów pierwiastka promieniotwórczego. Poniższy program oblicza liczbę atomów pozostałych po podanym czasie zgodnie ze wzorem:<br>
<center><math>N = N_0 \cdot 2^{-\frac{t}{T_{1/2}}}</math></center>
gdzie <math>N_0</math> to początkowa liczba cząstek a <math>T_{1/2}</math> to czas połowicznego rozpadu.

<syntaxhighlight lang="c">
#include <math.h>
#include <stdio.h>
 
int main()
{
    double N0, T12, t, N;

#if __STDC_VERSION__ < 199901L
    // jesli uzywamy standardu C99
    double lambda;    
#endif
 
    printf("N_0 = ");
    if (scanf("%lf", &N0) != 1) return 1;
 
    printf("T_{1/2} = ");
    if (scanf("%lf", &T12) != 1) return 1;
 
    printf("t = ");
    if (scanf("%lf", &t) != 1) return 1;
 
#if __STDC_VERSION__ < 199901L
    // jesli uzywamy standardu C99
    lambda = log(2) / T12;
    N = N0 * exp(-lambda * t);
#else
    N = N0 * exp2(-t / T12);
#endif
 
    printf("N = %g\n", N);
    return 0;
}
</syntaxhighlight>


====log ====




<syntaxhighlight lang="c">
/*


 gcc i.c -Wall -Wextra -lm

 https://stackoverflow.com/questions/108318/how-can-i-test-whether-a-number-is-a-power-of-2
 (n>0 && ((n & (n-1)) == 0))

 https://stackoverflow.com/questions/160930/how-do-i-check-if-an-integer-is-even-or-odd
if (x % 2) {  } //  x is odd 
 An integer is even if it is a multiple of two, and odd if it is not.

*/


#include <stdio.h>
#include <stdlib.h>
#include <math.h>

int main(void)
{
	int n = 8;
	if (n % 2) 
		{ fprintf(stdout, "%d is even\n", n);}
		else { fprintf(stdout, "%d is odd\n", n);}
		
	if (n>0 && ((n & (n-1)) == 0))
		{ fprintf(stdout, "%d is power of 2 = 2^%d\n", n, (int) log2(n));}
		else { fprintf(stdout, "%d is not the power of t\n", n);}
	


	return 0;
}
</syntaxhighlight>	

wynik:

 8 is odd
 8 is power of 2 = 2^3

=== Uwagi ===
Wersje funkcji z przyroskiem "f" i "l" (tzn. wersje operujące na zmiennych typu float i long double) zostały wprowadzone dopiero w standardzie C99.  Również funkcje exp2, expm1, scalbn, scalbln, log2, log1p, logb oraz ilogb, a także stałe FP_ILOGB0 oraz FP_ILOGBNAN zosatły wprowadzone dopiero w standardzie C99.

W przypadku użycia funkcji matematycznych może zaistnieć konieczność podania odpowiedniego argumentu linkerowi, aby ten połączył program z biblioteką matematyczną. Np. na systemach GNU/Linux jest to <tt>-lm</tt>.


===Źródła===
* [http://www.codecogs.com/library/computing/c/math.h/log.php codecogs: log]