Zum Inhalt springen

„Math.h“ – Versionsunterschied

aus Wikipedia, der freien Enzyklopädie
[gesichtete Version][gesichtete Version]
Inhalt gelöscht Inhalt hinzugefügt
Zeichensetzung; C99 erklärt
K Weblinks: https
 
(36 dazwischenliegende Versionen von 21 Benutzern werden nicht angezeigt)
Zeile 1: Zeile 1:
{{SEITENTITEL:math.h}}
'''math.h''' ist eine [[Header-Datei]] in der [[Standard C Library]] der [[C (Programmiersprache)|Programmiersprache C]]. Sie wurde für mathematische Funktionen entwickelt. Die [[C (Programmiersprache)|Programmiersprache C++]] benutzt die Funktionen ebenfalls, um die Kompatibilität von C zu C++ zu gewährleisten und deklariert sie in der Header-Datei '''cmath''' (dort ohne die [[Dateinamenserweiterung]] „.h“ verwendet).
'''math.h''' ist eine [[Header-Datei]] in der [[Standard C Library]] der [[C (Programmiersprache)|Programmiersprache C]]. Sie wurde für mathematische Funktionen entwickelt. Die [[C++|Programmiersprache C++]] benutzt die Funktionen ebenfalls, um die Kompatibilität von C zu C++ zu gewährleisten, und deklariert sie in der Header-Datei '''cmath''' (dort ohne die [[Dateinamenserweiterung]] „.h“ verwendet).


Alle Funktionen, die einen Winkel einlesen oder ausgeben, arbeiten mit [[Radiant]].
Alle Funktionen, die einen Winkel einlesen oder ausgeben, arbeiten mit [[Radiant (Einheit)|Radiant]]. Die meisten Funktionen arbeiten mit [[Gleitkommazahlen]]. Mathematische Funktionen, die mit ganzzahligen Werten ([[Integer (Datentyp)|Integer]]) arbeiten, wie abv, labs, div oder ldiv, sind stattdessen in der Header-Datei [[stdlib.h]] vertreten.
Die meisten Funktionen arbeiten mit [[Gleitkommazahlen]].
Mathematische Funktionen, die mit ganzzahligen Werten ([[Integer (Datentyp)|Integer]]) arbeiten, wie abv, labs, div oder ldiv, sind stattdessen in der Header-Datei [[stdlib.h]] vertreten.


== Funktionen bis C95 ==
== Funktionen bis C95 ==
In den Normen bis einschließlich [[C95]] waren die folgenden Funktionen [[Deklaration (Programmierung)|deklariert]].
In den Normen bis einschließlich [[C95]] waren die folgenden Funktionen [[Deklaration (Programmierung)|deklariert]].
{| class="wikitable"
{| class="wikitable"
! Name !! Beschreibung
! Name !! Beschreibung !! Mathematische Formulierung
|-
|-
|<code>acos</code> || [[Arkuskosinus]]
|<code>acos</code> || [[Arkuskosinus]] || <math>\arccos x</math>
|-
|-
|<code>asin</code> || [[Arkussinus]]
|<code>asin</code> || [[Arkussinus]] || <math>\arcsin x</math>
|-
|-
|<code>atan</code> || [[Arkustangens]], mit einem Argument
|<code>atan</code> || [[Arkustangens]] || <math>\arctan x</math>
|-
|-
|<code>atan2</code> || [[Arkustangens]], mit zwei Argumenten
|<code>atan2</code> ||[[Arctan2|„Arkustangens“ mit zwei Argumenten]]||<math>\operatorname{atan2}(y, x)</math>
|-
|-
|<code>ceil</code> || [[Aufrundungsfunktion]]
|<code>ceil</code> || [[Aufrundungsfunktion]] || <math>\lceil x \rceil</math>
|-
|-
|<code>cos</code> || [[Kosinus]]
|<code>cos</code> || [[Kosinus]] || <math>\cos x</math>
|-
|-
|<code>cosh</code> || [[Kosinus Hyperbolicus]]
|<code>cosh</code> || [[Kosinus hyperbolicus]] || <math>\cosh x</math>
|-
|-
|<code>exp</code> || [[Exponentialfunktion]]
|<code>exp</code> || [[Exponentialfunktion]] || <math>e^x</math>
|-
|-
|<code>fabs</code> || [[Betragsfunktion]]
|<code>fabs</code> || [[Betragsfunktion]] || <math>|x|</math>
|-
|-
|<code>floor</code> || [[Ganzteilfunktion]]
|<code>floor</code> || [[Ganzteilfunktion]] || <math>\lfloor x \rfloor</math>
|-
|-
|<code>fmod</code> || Führt die [[Modulo]] Funktion für Gleitkommazahlen durch
|<code>fmod</code> || Führt die [[Modulo]]-Funktion für Gleitkommazahlen durch || <math>x \bmod y</math>
|-
|-
|<code>frexp</code> || Teilt eine Gleitkommazahl in Faktor und Potenz mit der Basis 2 auf
|<code>frexp</code> || Teilt eine Gleitkommazahl in Faktor und Potenz mit der Basis 2 auf ||
|-
|-
|<code>ldexp</code> || Multipliziert die eingegebene Faktor mit 2 um den Exponent potenziert, ''f'' · 2 <sup>''exp''</sup>
|<code>ldexp</code> || Multipliziert den ersten Parameter mit 2 um den zweiten Parameter potenziert || <math>x 2^y</math>
|-
|-
|<code>log</code> || [[Natürlicher Logarithmus]]
|<code>log</code> || [[Natürlicher Logarithmus]] || <math>\ln x</math>
|-
|-
|<code>log10</code> || [[Logarithmus| Logarithmus zur Basis 10]]
|<code>log10</code> || [[Logarithmus]] zur Basis 10 || <math>\log_{10} x</math>
|-
|-
|<code>modf(''x'',''p'')</code> || Teilt eine Gleitkommazahl in zwei Zahlen auf vor und nach dem Komma
|<code>modf</code> || Teilt eine Gleitkommazahl in zwei Zahlen auf, vor und nach dem Komma ||
|-
|-
|<code>pow(''x'',''y'')</code> || Potenziert ''x'' mit dem Exponent ''y'', ''x<sup>y</sup>''
|<code>pow</code> || Potenziert ersten mit dem zweiten Parameter || <math>x^y</math>
|-
|-
|<code>sin</code> || [[Sinus]]
|<code>sin</code> || [[Sinus]] || <math>\sin x</math>
|-
|-
|<code>sinh</code> || [[Sinus Hyperbolicus]]
|<code>sinh</code> || [[Sinus hyperbolicus]] || <math>\sinh x</math>
|-
|-
|<code>sqrt</code> || [[Quadratwurzel]]
|<code>sqrt</code> || [[Quadratwurzel]] || <math>\sqrt x</math>
|-
|-
|<code>tan</code> || [[Tangens]]
|<code>tan</code> || [[Tangens]] || <math>\tan x</math>
|-
|-
|<code>tanh</code> || [[Tangens Hyperbolicus]]
|<code>tanh</code> || [[Tangens hyperbolicus]] || <math>\tanh x</math>
|}
|}


== C99-Funktionen ==
== C99-Funktionen ==
Mit der Norm [[C99]] wurde math.h um die folgenden Funktionen erweitert.
Mit der Norm [[Varianten der Programmiersprache C#C99|C99]] wurde math.h um die folgenden Funktionen erweitert.
{| class="wikitable"
{| class="wikitable"
! Name !! Beschreibung
! Name !! Beschreibung !! Mathematische Formulierung
|-
|-
|<code>acosh</code> || [[Areakosinus Hyperbolicus]]
|<code>acosh</code> || [[Areakosinus hyperbolicus]] || <math>\operatorname{arcosh} x</math>
|-
|-
|<code>asinh</code> || [[Areakosinus Hyperbolicus ]]
|<code>asinh</code> || [[Areasinus hyperbolicus]] || <math>\operatorname{arsinh} x</math>
|-
|-
|<code>atanh</code> || [[Areatangens Hyperbolicus]]
|<code>atanh</code> || [[Areatangens hyperbolicus]] || <math>\operatorname{artanh} x</math>
|-
|-
|<code>cbrt</code> || [[Kubikwurzel]]
|<code>cbrt</code> || [[Kubikwurzel]] || <math>\sqrt[3]x</math>
|-
|-
|<code>copysign(''x'',''y'')</code> || gibt den Wert von ''x'' mit dem Vorzeichen von ''y'' zurück
|<code>copysign(''x'',''y'')</code> || gibt den Wert von ''x'' mit dem [[Vorzeichen (Zahl)|Vorzeichen]] von ''y'' zurück || <math>|x|\cdot \operatorname{sgn} y</math>
|-
|-
|<code>erf</code> || [[Fehlerfunktion]]
|<code>erf</code> || [[Fehlerfunktion]] || <math>\operatorname{erf} x</math>
|-
|-
|<code>erfc</code> || Gibt den Komplementärfehler von ''x'' zurück
|<code>erfc</code> || Gibt den Komplementärfehler von ''x'' zurück || <math>\operatorname{erfc} x</math>
|-
|-
|<code>exp2(''x'')</code> || Potenziert 2 mit ''x'', 2<sup>''x''</sup>
|<code>exp2(''x'')</code> || Potenziert 2 mit dem übergebenen Parameter || <math>2^x</math>
|-
|-
|<code>expm1(''x'')</code> || Liefert den wert von ''exp()-1 '' zurück, ''e<sup>x</sup>'' &minus; 1
|<code>expm1(''x'')</code> || Liefert den Wert von ''exp()-1'' zurück || <math>e^x-1</math>
|-
|-
|<code>fdim(''x'',''y'')</code> || Positive differenz zwischen ''x'' and ''y'', fmax (''x''&minus;''y'', 0)
|<code>fdim(''x'',''y'')</code> || Positive Differenz || <math>\max(0, x-y)</math>
|-
|-
|<code>fma(''x'',''y'',''z'')</code> || Multipliziert und Addiert, (''x'' * ''y'') + ''z''
|<code>fma(''x'',''y'',''z'')</code> || Multipliziert und Addiert || <math>xy+z</math>
|-
|-
|<code>fmax(''x'',''y'')</code> || Maximum
|<code>fmax(''x'',''y'')</code> || Maximum || <math>\max(x, y)</math>
|-
|-
|<code>fmin(''x'',''y'')</code> || Minimunm
|<code>fmin(''x'',''y'')</code> || Minimum || <math>\min(x, y)</math>
|-
|-
|<code>hypot(''x'',''y'')</code> || [[Hypotenuse]], sqrt (''x''<sup>2</sup> + ''y''<sup>2</sup>)
|<code>hypot(''x'',''y'')</code> || [[Hypotenuse]] || <math>\sqrt{(x^2+y^2)}</math>
|-
|-
|<code>ilogb</code> ||der Exponent einer Gleitkommazahl wird ein <code>int</code> zurückgegeben
|<code>ilogb</code> ||wie <code>logb</code>, gibt allerdings <code>int</code> zurück || <code>(int)logb(x)</code>
|-
|-
|<code>lgamma</code> || [[Gammafunktion]]
|<code>lgamma</code> || Logarithmus der [[Gammafunktion]] || <math>\ln|\Gamma(x)|</math>
|-
|-
|<code>llrint</code> || Rundungsfunktion
|<code>llrint</code> || Rundungsfunktion ||
|-
|-
|<code>lrint</code> || Rundungsfunktion
|<code>lrint</code> || Rundungsfunktion ||
|-
|-
|<code>llround</code> || Rundungsfunktion
|<code>llround</code> || Rundungsfunktion ||
|-
|-
|<code>lround</code> || Rundungsfunktion
|<code>lround</code> || Rundungsfunktion ||
|-
|-
|<code>log1p(''x'')</code> || [[Natürlicher Logarithmus]] von 1 + ''x''
|<code>log1p(''x'')</code> || [[Natürlicher Logarithmus]] von 1 + ''x'' || <math>\ln(1+x)</math>
|-
|-
|<code>log2</code> || [[Logarithmus]] zur Basis 2
|<code>log2</code> || [[Logarithmus]] zur Basis 2 || <math>\operatorname{lb} x</math>
|-
|-
|<code>logb</code> || Liefert den ganzzahligen Exponenten einer Gleitpunktzahl
|<code>logb</code> || Liefert den ganzzahligen Exponenten einer Gleitkommazahl als Gleitkommazahl || <math>\operatorname{rint}(\log_{\mathrm{FLT\_RADIX}}|x|)</math>
|-
|-
|<code>nan(''s'')</code> || Ein [[NaN]] erzeugen
|<code>nan(''s'')</code> || Ein [[NaN]] erzeugen || <math>0/0</math>
|-
|-
|<code>nearbyint</code> || Rundet Gleitkommazahlen zum nächsten Integer
|<code>nearbyint</code> || Rundet Gleitkommazahlen zum nächsten Integer ||
|-
|-
|<code>nextafter(''x'',''y'')</code> || Gibt die nächst darstellbare Zahl nach ''x'' (Richtung ''y'') zurück
|<code>nextafter(''x'',''y'')</code> || Gibt die nächst darstellbare Zahl nach ''x'' (Richtung ''y'') zurück ||
|-
|-
|<code>nexttoward(''x'',''y'')</code> || Genauso wie <code>nextafter</code>, bis auf ''y'' wird immer als <code>long double</code> zurückgegeben
|<code>nexttoward(''x'',''y'')</code> || Wie <code>nextafter</code>, außer dass ''y'' als <code>long double</code> übergeben wird ||
|-
|-
|<code>remainder(''x'',''y'')</code> || Rest einer Division
|<code>remainder(''x'',''y'')</code> || Rest einer Division ||
|-
|-
|<code>remquo(''x'',''y'',''p'')</code> || Genauso wie <code>remainder</code>, speichert jedoch den Quotienten (als <code>int</code>) als Ziel des Zeigers ''p''
|<code>remquo(''x'',''y'',''p'')</code> || Genauso wie <code>remainder</code>, speichert jedoch den Quotienten (als <code>int</code>) als Ziel des Zeigers ''p'' ||
|-
|-
|<code>rint</code> || Rundet zum Integer
|<code>rint</code> || Rundet je nach Rundungsmodus zum nächsten Integer, gibt eine Gleitkommazahl zurück ||
|-
|-
|<code>round</code> || Rundungsfunktion
|<code>round</code> || kaufmännische Rundungsfunktion || <math>\lfloor x + 0{,}5\rfloor</math>
|-
|-
|<code>scalbln(''x'',''n'')</code> || ''x'' * <code>FLT_RADIX</code><sup>''n''</sup> (''n'' ist <code>long</code>)
|<code>scalbln(''x'',''y'')</code> || ''x'' * <code>FLT_RADIX</code><sup>''y''</sup> (''y'' ist <code>long</code>) || <math>x\cdot\mathrm{FLT\_RADIX}^y</math>
|-
|-
|<code>scalbn(''x'',''n'')</code> || ''x'' * <code>FLT_RADIX</code><sup>''n''</sup> (''n'' ist <code>int</code>)
|<code>scalbn(''x'',''y'')</code> || ''x'' * <code>FLT_RADIX</code><sup>''y''</sup> (''y'' ist <code>int</code>) || <math>x\cdot\mathrm{FLT\_RADIX}^y</math>
|-
|-
|<code>tgamma</code> || [[Gammafunktion]]
|<code>tgamma</code> || [[Gammafunktion]] || <math>\Gamma(x)</math>
|-
|-
|<code>trunc</code> || Trunktiert eine Gleitkommazahl
|<code>trunc</code> || Beschneidet eine Gleitkommazahl, d.&nbsp;h. rundet „Richtung Null“ || <math>\begin{cases}
\lfloor x \rfloor, & x\ge 0\\
\lceil x \rceil, & x<0
\end{cases}</math>
|}
|}


== Beispiel ==
== Beispiel ==


<source lang="c">
<syntaxhighlight lang="c" line="1">
#include <stdlib.h>
#include <stdio.h>
#include <math.h>
#include <math.h>


int main()
int main() {
double a = 5, b = 4;
{
float a = 5, b = 4, c;
double c = pow(a, b);
printf("%f hoch %f ist %f\n", a, b, c);

c = pow(a, b);

return EXIT_SUCCESS;
}
}
</syntaxhighlight>
</source>


== Weblinks ==
== Weblinks ==
* {{Internetquelle|url=http://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf|titel=Rationale for International Standard – Programming Languages – C|zugriff=2011-09-04|kommentar=pdf/ C99}}
* {{Internetquelle|url=https://www.open-std.org/jtc1/sc22/wg14/www/C99RationaleV5.10.pdf|titel=Rationale for International Standard – Programming Languages – C|zugriff=2011-09-04|kommentar=C99|format=PDF, 898&nbsp;kB}}
* [https://cplusplus.com/reference/cmath/ Beschreibung auf cplusplus.com] (englisch)
* {{Internetquelle|url=http://www2.hs-fulda.de/~klingebiel/c-stdlib/math.htm|titel=C Standard-Bibliothek: math.h|zugriff=2011-09-04}}
* {{Webarchiv | url=http://www.dinkumware.com/manuals/default.aspx?manual=compleat&page=math.html | wayback=20100221150215 | text=Dokumentation von math.h auf dinkumware.com}}

[[Kategorie:Programmiersprache C]]


[[Kategorie:C (Programmiersprache)]]
[[cs:Math.h]]
[[en:Math.h]]
[[es:Math.h]]
[[it:Math.h]]
[[ko:Math.h]]
[[pt:Math.h]]
[[ru:Math.h]]
[[sk:Math.h]]
[[tr:Math.h]]
[[uk:Math.h]]

Aktuelle Version vom 16. Oktober 2023, 22:00 Uhr

math.h ist eine Header-Datei in der Standard C Library der Programmiersprache C. Sie wurde für mathematische Funktionen entwickelt. Die Programmiersprache C++ benutzt die Funktionen ebenfalls, um die Kompatibilität von C zu C++ zu gewährleisten, und deklariert sie in der Header-Datei cmath (dort ohne die Dateinamenserweiterung „.h“ verwendet).

Alle Funktionen, die einen Winkel einlesen oder ausgeben, arbeiten mit Radiant. Die meisten Funktionen arbeiten mit Gleitkommazahlen. Mathematische Funktionen, die mit ganzzahligen Werten (Integer) arbeiten, wie abv, labs, div oder ldiv, sind stattdessen in der Header-Datei stdlib.h vertreten.

Funktionen bis C95

[Bearbeiten | Quelltext bearbeiten]

In den Normen bis einschließlich C95 waren die folgenden Funktionen deklariert.

Name Beschreibung Mathematische Formulierung
acos Arkuskosinus
asin Arkussinus
atan Arkustangens
atan2 „Arkustangens“ mit zwei Argumenten
ceil Aufrundungsfunktion
cos Kosinus
cosh Kosinus hyperbolicus
exp Exponentialfunktion
fabs Betragsfunktion
floor Ganzteilfunktion
fmod Führt die Modulo-Funktion für Gleitkommazahlen durch
frexp Teilt eine Gleitkommazahl in Faktor und Potenz mit der Basis 2 auf
ldexp Multipliziert den ersten Parameter mit 2 um den zweiten Parameter potenziert
log Natürlicher Logarithmus
log10 Logarithmus zur Basis 10
modf Teilt eine Gleitkommazahl in zwei Zahlen auf, vor und nach dem Komma
pow Potenziert ersten mit dem zweiten Parameter
sin Sinus
sinh Sinus hyperbolicus
sqrt Quadratwurzel
tan Tangens
tanh Tangens hyperbolicus

Mit der Norm C99 wurde math.h um die folgenden Funktionen erweitert.

Name Beschreibung Mathematische Formulierung
acosh Areakosinus hyperbolicus
asinh Areasinus hyperbolicus
atanh Areatangens hyperbolicus
cbrt Kubikwurzel
copysign(x,y) gibt den Wert von x mit dem Vorzeichen von y zurück
erf Fehlerfunktion
erfc Gibt den Komplementärfehler von x zurück
exp2(x) Potenziert 2 mit dem übergebenen Parameter
expm1(x) Liefert den Wert von exp()-1 zurück
fdim(x,y) Positive Differenz
fma(x,y,z) Multipliziert und Addiert
fmax(x,y) Maximum
fmin(x,y) Minimum
hypot(x,y) Hypotenuse
ilogb wie logb, gibt allerdings int zurück (int)logb(x)
lgamma Logarithmus der Gammafunktion
llrint Rundungsfunktion
lrint Rundungsfunktion
llround Rundungsfunktion
lround Rundungsfunktion
log1p(x) Natürlicher Logarithmus von 1 + x
log2 Logarithmus zur Basis 2
logb Liefert den ganzzahligen Exponenten einer Gleitkommazahl als Gleitkommazahl
nan(s) Ein NaN erzeugen
nearbyint Rundet Gleitkommazahlen zum nächsten Integer
nextafter(x,y) Gibt die nächst darstellbare Zahl nach x (Richtung y) zurück
nexttoward(x,y) Wie nextafter, außer dass y als long double übergeben wird
remainder(x,y) Rest einer Division
remquo(x,y,p) Genauso wie remainder, speichert jedoch den Quotienten (als int) als Ziel des Zeigers p
rint Rundet je nach Rundungsmodus zum nächsten Integer, gibt eine Gleitkommazahl zurück
round kaufmännische Rundungsfunktion
scalbln(x,y) x * FLT_RADIXy (y ist long)
scalbn(x,y) x * FLT_RADIXy (y ist int)
tgamma Gammafunktion
trunc Beschneidet eine Gleitkommazahl, d. h. rundet „Richtung Null“
#include <stdio.h>
#include <math.h>

int main() {
    double a = 5, b = 4;
    double c = pow(a, b);
    printf("%f hoch %f ist %f\n", a, b, c);
}