mathematische functies¶

getaltheoretische en representatiefuncties¶

math.ceil(x)¶

retourneer het plafond van x, het kleinste gehele getal groter dan of gelijk aan x.als x geen float is, delegeert u aan x.__ceil__(), wat eenIntegral waarde zou moeten geven.

math.comb(n, k)¶

geef het aantal manieren om K-items uit n-items te kiezen zonder herhaling en zonder volgorde.,

evalueert tot n! / (k! * (n - k)!) wanneer k <= n en evalueert tot nul wanneer k > n.

wordt ook de binomiale coëfficiënt genoemd omdat deze gelijk is aan de coëfficiënt van K-de term in de veeltermuitbreiding van de expressie (1 + x) ** n.

verhoogt TypeError als een van de argumenten geen gehele getallen zijn.Verhoogt ValueError als een van de argumenten negatief is.

math.copysign(x, y)¶math.fabs(x)¶

Return the absolute value of x.

math.factorial(x)¶

Return x factorial as an integer. Raises ValueError if x is not integral oris negative.

math.floor(x)¶math.fmod(x, y)¶

Return fmod(x, y), as gedefinieerd door de platform C bibliotheek. Merk op dat de thon expression x % y mogelijk niet hetzelfde resultaat geeft. De bedoeling van de C-Standaard is dat fmod(x, y) exact (wiskundig; tot infiniteprecisie) gelijk is aan x - n*y voor een geheel getal n zodanig dat het resultaat hetzelfde teken heeft als x en magnitude kleiner dan abs(y)., Python ‘ s x % ygeeft een resultaat terug met het teken y in plaats daarvan, en is mogelijk niet precies berekenbaar voor float argumenten. Bijvoorbeeld, fmod(-1e-100, 1e100) is -1e-100, maar het resultaat van Python ’s -1e-100 % 1e100 is 1e100-1e-100, die niet precies als float kan worden gepresenteerd, en rond de verrassende 1e100. Om deze reden heeft functie fmod() over het algemeen de voorkeur bij het werken met floats, terwijl Python ‘ s x % y de voorkeur heeft bij het werken met gehele getallen.,

math.frexp(x)¶math.fsum(iterable)¶

retourneer een accurate floating point som van waarden in de iterable. Vermijd precisieverlies door meerdere tussentijdse partiële sommen te volgen:

>>> sum()0.9999999999999999>>> fsum()1.0

de nauwkeurigheid van het algoritme hangt af van IEEE-754 rekenkundige garanties en het typische geval waarin de afrondingsmodus half-even is., Op sommige niet-Windowsbuilds, de onderliggende C bibliotheek maakt gebruik van extended precision additie en kan soms dubbel-ronde een tussenliggende Som waardoor het uit in zijn minst significante bit.

voor verdere discussie en twee alternatieve benaderingen, zie de ASPN cookbookrecipes voor accurate floating point sommation.

math.gcd(*gehele getallen)¶

geeft de grootste gemeenschappelijke deler van de opgegeven gehele getallen terug.Als een van de argumenten niet nul is, dan is de geretourneerde waarde het grootste positieve gehele getal dat een deler is van alle argumenten., Als alle argumenten nul zijn, dan is de geretourneerde waarde 0. gcd() zonder argumententerurns 0.

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)¶

Return True als de waarden a en b dicht bij elkaar liggen enFalse anders.,

of twee waarden als dichtbij worden beschouwd, wordt bepaald volgens de gegeven absolute en relatieve toleranties.

rel_tol is de relatieve tolerantie – het is het maximaal toegestane verschil tussen a en b, ten opzichte van de grotere absolute waarde van a of b.bijvoorbeeld, om een tolerantie van 5% in te stellen, geef rel_tol=0.05. De standaardtolerantieis 1e-09, wat ervoor zorgt dat de twee waarden gelijk zijn met ongeveer 9 decimale cijfers. rel_tol moet groter zijn dan nul.

abs_tol is de minimale absolute tolerantie-nuttig voor vergelijkingen in de buurt van nul., abs_tol moet ten minste nul zijn.

als er geen fouten optreden, zal het resultaat zijn:abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

de speciale IEEE 754-waarden van NaN, inf, en -inf worden behandeld volgens de IEEE-regels. In het bijzonder wordt NaN niet beschouwd onder een andere waarde, met inbegrip van NaN. inf en -inf worden alleen dicht bij zichzelf beschouwd.

math.isfinite(x)¶

Return True if x is neither an infinity nor a NaN, andFalse otherwise. (Note that 0.0 is considered finite.)

math.isinf(x)¶

Return True if x is a positive or negative infinity, andFalse otherwise.,

math.isnan(x)¶

geef True Als x een NaN is (geen getal), en False anders.

math.isqrt(n)¶

geeft de gehele vierkantswortel van het nonnegatieve gehele getal n terug. Dit is de vloer van de exacte vierkantswortel van n, of gelijkwaardig de grootste integer zodanig dat a2 ≤ n.

voor sommige toepassingen kan het handiger zijn om de kleinste integer zodanig te hebben dat n ≤ a2, of in met andere woorden het plafond van de exacte vierkantswortel van n., Voor positieve n kan dit worden berekend meta = 1 + isqrt(n - 1).

math.lcm(*gehele getallen)¶

geeft het kleinste veelvoud van de opgegeven gehele getallen terug.Als alle argumenten niet nul zijn, dan is de geretourneerde waarde het kleinste positieve gehele getal dat een veelvoud van alle argumenten is. Als een van de argumenten nul is, dan is de geretourneerde waarde 0. lcm() zonder argumententerurns 1.

math.ldexp(x, i)¶

Return x * (2**i). Dit is in wezen de inverse van functiefrexp().

math.modf(x)¶

geeft de fractionele en gehele delen van x Terug. beide resultaten hebben het teken van x en zijn floats.

retourneer de volgende floating-point waarde na x naar y.

als x gelijk is aan y, retourneer y.

voorbeelden:

zie ook math.ulp().

math.perm(n, k=None)¶

geef het aantal manieren om K-items uit n-items te kiezen zonder herhaling en met volgorde.

evalueert tot n! / (n - k)! wanneer k <= n en evalueert tot nul wanneer k > n.

als k niet is opgegeven of geen is, dan staat k standaard op n en geeft de functie n!terug.

verhoogt TypeError als een van de argumenten geen gehele getallen zijn.Verhoogt ValueError als een van de argumenten negatief is.,

math.prod(iterable, *, start=1)¶

Bereken het product van alle elementen in de input iterable.De standaard startwaarde voor het product is 1.

als de iterable leeg is, geeft u de startwaarde terug. Deze functie is bedoeld specifiek voor gebruik met numerieke waarden en kan niet-numerieke types afwijzen.

math.remainder(x, y)¶

Geef de rest van x in IEEE 754-stijl terug met betrekking tot y., Voor eindige x en eindige niet-nul y is dit het verschil x - n*y,waarbij n het dichtst bij de exacte waarde van het quotiënt ligt x /y. Als x / y precies halverwege tussen twee opeenvolgende gehele getallen ligt, wordt het meest even gehele getal gebruikt voor n. De rest r = remainder(x,y) voldoet dus altijd aan abs(r) <= 0.5 * abs(y).,

speciale gevallen volgen IEEE 754: in het bijzonder remainder(x, math.inf) isx voor elke eindige x, en remainder(x, 0) enremainder(math.inf, x) raise ValueError voor elke niet-NaN x.als het resultaat van de restoperatie nul is

op platformen die IEEE 754 Binary floating-point gebruiken, is het resultaat van deze operatie altijd precies weer te geven: er wordt geen afrondingsfout geà ntroduceerd.

math.trunc(x)¶

Geef de Real waarde x afgekapt tot eenIntegral (meestal een geheel getal). Gedelegeerden naarx.__trunc__().

math.ulp(x)¶

retourneer de waarde van het minst significante bit van de float x:

• indien x een NaN is (geen getal), retourneer x.

• indien x negatief is, retourneer ulp(-x).

• als x een positieve oneindigheid is, geeft u x terug.,

• als x gelijk is aan nul, retourneer dan de kleinste positivedenormalized representable float (kleiner dan de minimum positivenormalized float, sys.float_info.min).

• als x gelijk is aan de grootste positieve representeerbare float,retourneer dan de waarde van het minst significante bit van x, zodanig dat de eerste float kleiner dan x x - ulp(x)is.

• anders (x is een positief eindig getal), retourneer de waarde van het minst significante bit van x, zodanig dat de eerste float groter is dan xis x + ulp(x).,

ULP staat voor”eenheid in de laatste plaats”.

zie ook math.nextafter() en sys.float_info.epsilon.

merk op dat frexp() en modf() een ander aanroep/retourpatroon hebben dan hun C-equivalenten: ze nemen een enkel argument en retourneren een paar waarden, in plaats van hun tweede retourwaarde terug te geven via een ‘outputparameter’ (zoiets bestaat niet in Python).,

voor de ceil(), floor(), en modf() functies, merk op dat allfloating-point getallen van voldoende grote magnitude exacte gehele getallen zijn.Python-drijvers hebben doorgaans niet meer dan 53 precisiebits (hetzelfde als het platformc double type), in welk geval elke float x met abs(x) >= 2**52noodzakelijkerwijs Geen fractionele bits heeft.