Knihovna math.h

• Výčet funkcí
• Příklad použití

Standardní knihovna <math.h> obsahuje spoustu funkcí, které vykonávají běžné matematické operace. Jejich parametry i návratové hodnoty jsou většinou typu double. Kromě funkcí v této knihovně také naleznete užitečná makra, jako M_PI jež je hodnotou pí.

V systémech UNIX bude možná potřeba překladači předat argument -lm, který zajistí použití sdílené matematické knihovny systému UNIX. Tento parametr je zkratkou pro /usr/lib/libm.a.

Příkaz překladu z příkazové řádky pak může vypadat nějak takto:

gcc -o program kod.c -lm -Wall

Výčet funkcí

double sin(double x);

Vrací sinus argumentu.

double cos(double x);

Vrací kosinus argumentu.

double tan(double x);

Vrací tangens argumentu.

double asin(double x);

Vrací arcu ssinus argumentu.

double acos(double x);

Vrací arkus kosinus argumentu.

double atan(double x);

Vrací arkus tangens argumentu.

double atan2(double y, double x);

Funkce atan2() počítá arkus tangens dvou proměnných x a y. Výpočet je podobný výpočtu arkus tangens y / x, kromě toho, že znaménka obou argumentů jsou použita pro určení kvadrantu, ve kterém se nachází výsledná hodnota. Funkce atan2() vrací výsledek v radiánech, který je mezi -PI a PI včetně.

int abs(int j);

Vrací absolutní hodnotu argumentu typu int. Tato funkce není kupodivu definována v <math.h> ale <stdlib.h>. Přesto jsem si ji sem dovolil zařadit.

double fabs(double j);

Vrací absolutní hodnotu argumentu typu double.

double aceil(double x);

Zaokrouhlí argument na nejmenší „vyšší“ celé číslo.

double floor (double x);

Zaokrouhlí argument na nejbližší „nižší“ celé číslo.

double round(double x);

Zaokrouhlí číslo na nejbližší celé číslo.

double exp(double x);

Vrací hodnotu e (základ přirozených algoritmů) umocněnou na x.

double log(double x);

Vrací hodnotu přirozeného algoritmu x.

double log10(double x);

Vrací hodnotu desítkového logaritmu x

double pow(double x, double y);

Vrací hodnotu x na y (2^3=8).

double sqrt(double x);

Vrací odmocninu z čísla x.

double fmod(double x, double y);

Funkce fmod() počítá hodnotu zbytku podílu x děleno y. Návratová hodnota je x - n * y, kde n je podíl x / y, zaokrouhlený směrem k nule na celé číslo. Jinak řečeno, vrací celočíselný zbytek po celočíselném dělení.

double modf(double x, double *iptr);

Vrátí desetinnou část x a celou část uloží tam, kam ukazuje iptr.

Příklad použití

Použití těchto funkcí se mi zdá natolik triviální, že snad není k příkladu třeba žádného komentáře.

  1: /*------------------------------------------------*/
  2: /* matika.c                                       */
  3: #include <stdio.h>
  4: #include <math.h>

  6: int main(void)
  7: {
  8:     int ia;
  9:     float fa;
 10:     double da;
 11:     /* kresleni sinusove vlny */
 12:     for (fa = 0.0; fa < 2.0 * M_PI; fa += M_PI / 13) {
 13:         ia = 40 + 20.0 * sin(fa);
 14:         printf("%*c\n", ia, '*');
 15:     }

 17:     printf("ceil(%f)=%f\tfloor(%f)=%f\n", 5.9, ceil(5.9), 5.9, floor(5.9));
 18:     printf("ceil(%f)=%f\tfloor(%f)=%f\n", 5.1, ceil(5.1), 5.1, floor(5.1));

 20: #define MODF 5.5
 21:     fa = modf(MODF, &da);
 22:     printf("fmod(%4.2f,%4.2f)=%4.2f\nmodf(%4.2f,&y)=%4.2f --> y=%4.2f\n",
 23:            100.0, 3.0, fmod(100.0, 3.0), MODF, fa, da);

 25:     return 0;
 26: }

 28: /*------------------------------------------------*/

Výstup z programu:

                                       *
                                           *
                                                *
                                                    *
                                                       *
                                                         *
                                                          *
                                                          *
                                                         *
                                                       *
                                                    *
                                                *
                                           *
                                      *
                                  *
                             *
                         *
                      *
                    *
                   *
                   *
                    *
                      *
                         *
                             *
                                  *
ceil(5.900000)=6.000000 floor(5.900000)=5.000000
ceil(5.100000)=6.000000 floor(5.100000)=5.000000
fmod(100.00,3.00)=1.00
modf(5.50,&y)=0.50 --> y=5.00