matek – Matematikai funkciók ś

Szám-elméleti, illetve képviseleti funkciók ś

math.ceil(x) ś

Vissza a mennyezet x, a legkisebb egész szám nagyobb vagy egyenlő x-szel.Ha x nem egy úszó, küldöttek, hogy a x.__ceil__(), amelyeket vissza kell egyIntegral érték.

math.comb(n, k)¶

visszaadja a K elemek n elemekből történő kiválasztásának módjait ismétlődés nélkülés megrendelés nélkül.,

n! / (k! * (n - k)!) whenk <= n ésk > n.

binomiális együtthatónak is nevezik, mert a (1 + x) ** npolinom expanziós együtthatójának megfelelő.

emelTypeError ha valamelyik argumentum nem egész szám.Emel ValueError, ha valamelyik argumentum negatív.

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), a platform C könyvtár meghatározása szerint. Vegye figyelembe, hogy a x % y kifejezés nem adhatja vissza ugyanazt az eredményt. A Cstandard szándéka az, hogy fmod(x, y) pontosan (matematikailag; a végtelenre) egyenlő: x - n*y néhány N egész szám esetében, hogy az eredménynek ugyanaz a jele legyen, mint x és nagysága kisebb, mint abs(y)., A Python x % yegy Y jelű eredményt ad vissza, és nem biztos, hogy pontosan kiszámítható az úsztatott argumentumokhoz. Például fmod(-1e-100, 1e100) is -1e-100, de a Python -1e-100 % 1e100 eredménye 1e100-1e-100, amely nem lehet pontosan lebegőpontos, és a meglepő 1e100. Ennek oka, funkció fmod() általában előnyös, ha dolgozik withfloats, míg a Python x % y előnyös, ha dolgozik, egész számok.,

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

visszaadja az értékek pontos lebegőpontos összegét az iterábilisben. Avoidsloss a precíz nyomon követésével több köztes részösszegeket:

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

Az algoritmus pontossága attól függ, IEEE-754 számtani garanciát thetypical esetben, ha a kerekítési mód fél is., Néhány nem Windowsbuild esetében a mögöttes C könyvtár kiterjesztett precíziós összeadást használ, és előfordulhat, hogy egy közbenső összeg kétszerese, ami miatt a legkisebb jelentős bitben ki van kapcsolva.

további megbeszélés és két alternatív megközelítés, lásd az ASPN cookbookrecipes pontos lebegőpontos összegzés.

math.gcd(*egészek)¶

adja vissza a megadott egész argumentumok legnagyobb közös osztóját.Ha bármelyik argumentum nem nulla, akkor a visszaküldött érték a legnagyobbpozitív egész szám, amely az összes argumentum osztója., Ha minden érv nulla, akkor a visszaküldött érték 0. gcd()argumentsreturns 0.

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

Return True ha az A és b értékek közel vannak egymáshoz ésFalse egyébként.,

hogy két érték közelinek tekinthető-e vagy sem, az abszolút és relatív tűréshatárok alapján határozható meg.

rel_tol a relatív tolerancia – ez a megengedett legnagyobb különbségaz a és b között, az A vagy b nagyobb abszolút értékéhez viszonyítva.például 5% – os tolerancia beállításához, pass rel_tol=0.05. A defaulttolerancia 1e-09, amely biztosítja, hogy a két érték ugyanazkörülbelül 9 tizedes jegyben. rel_tol nagyobbnak kell lennie, mint nulla.

abs_tol a minimális abszolút tolerancia-hasznos összehasonlítások nearzero., az abs_tolnak legalább nullának kell lennie.

ha nincs hiba, az eredmény:abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

az IEEE 754 speciális értéke NaN, inf, és -inf lesz behandled szerint IEEE szabályok. Pontosabban, NaN nem tekinthetőközel más értékhez, beleértve a NaN. inf és -inf csak közel állnak egymáshoz.

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)¶

Return True ha x NaN (nem szám), és False egyébként.

math.isqrt(n)¶

adja vissza a nemnegatív egész szám egész négyzetgyökét n. ez az n pontos négyzetgyökének padlója, vagy egyenértékűen a legnagyobb integrera, úgy, hogy A2 ≤ n.

egyes alkalmazások esetében kényelmesebb lehet, ha a legkisebb integrera van, hogy n ≤ n ≤ n A2, vagy más szóval a mennyezetaz n pontos négyzetgyöke., Pozitív n esetén ezt aa = 1 + isqrt(n - 1)segítségével lehet kiszámítani.

math.lcm(*egészek)¶

adja vissza a megadott egész argumentumok legkisebb közös többszörösét.Ha az összes argumentum nem nulla, akkor a visszaküldött érték a legkisebbpozitív egész szám, amely az összes argumentum többszöröse. Ha bármelyik érv nulla, akkor a visszaküldött érték 0. lcm() argumentsreturns 1.

math.ldexp(x, i)¶

Return x * (2**i). Ez lényegében afrexp()függvény inverze.

math.modf(x)¶

adja vissza az X törtrészeit és egész részeit. mindkét eredmény az x jelét hordozza és úszik.

adja vissza a következő lebegőpontos értéket x után y felé.

Ha x egyenlő y-vel, térjen vissza y.

példák:

Lásd még: math.ulp().

math.perm(n, k=None)¶

visszaadja a K elemek n itemswithout ismétlés és megrendelés.

n! / (n - k)! whenk <= n and evaluatesto zero whenk > n.

Ha k nincs megadva, vagy nincs megadva, akkor k alapértelmezés szerint nés a függvény n!értéket ad vissza.

emelTypeError ha valamelyik argumentum nem egész szám.Emel ValueError, ha valamelyik argumentum negatív.,

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

Számítsa ki a bemeneti iterable összes elemének szorzatát.A termék alapértelmezett kezdőértéke 1.

Ha az iterable üres, adja vissza a start értéket. Ez a funkció kifejezetten numerikus értékekhez használható, és elutasíthatja a nem numerikus típusokat.

math.remainder(x, y)¶

visszaadja az IEEE 754 stílusú fennmaradó X-et y-hoz képest., Forfinite x véges nulla y, ez a különbség x - n*y,ahol a n a legközelebbi egész számra kerekítve, hogy a pontos értéket a hányados x /y. Ha x / y pontosan félúton van két egymást követő egész szám között, akkor n. A maradék r = remainder(x,y) így mindig megfelel abs(r) <= 0.5 * abs(y).,

különleges esetek követik IEEE 754: különösen, remainder(x, math.inf) ISX bármely véges x, és remainder(x, 0) ésremainder(math.inf, x) raise ValueError. ha a fennmaradó művelet eredménye nulla, akkor ez a nulla leszugyanaz a jel, mint x.

az IEEE 754 bináris lebegőpontot használó platformokon, ennek eredményea művelet mindig pontosan reprezentálható: nincs kerekítési hiba.

math.trunc(x)¶

visszaadja a Real érték x csonka egyIntegral (általában egész szám). Küldöttekx.__trunc__().

math.ulp(x)¶

visszaadja az úszó legkevésbé jelentős bitjének értékét x:

• Ha x NaN (nem szám), térjen vissza x.

• Ha x negatív, vissza ulp(-x).

• Ha x pozitív végtelenség, térjen vissza x.,

• Ha x egyenlő nulla, vissza a legkisebb positivedenormalized reprezentálható úszó (kisebb, mint a minimális positivenormalized úszó, sys.float_info.min).

• Ha x egyenlő a legnagyobb ábrázolható pozitív úszó,visszatérési értéke a legkisebb szignifikáns kis x, oly módon, hogy a firstfloat kisebb, mint x x - ulp(x).

• egyébként (x egy pozitív véges szám), visszaadja a leastsignificant bit x értékét, úgy, hogy az első float nagyobb, mint xis x + ulp(x).,

az ULP jelentése “Egység Az utolsó helyen”.

Lásd még: math.nextafter() és sys.float_info.epsilon.

Megjegyezzük, hogy a frexp() vagy modf() van egy másik hívás/vissza patternthan a C-egyenérték: egy, egyetlen érv vissza egy pár ofvalues, ahelyett, hogy visszatért a második visszatérési érték egy ‘outputparameter’ (nincs olyan dolog, Python).,

a ceil(), floor() és modf() funkciók esetén vegye figyelembe, hogy a kellően nagy horderejű allfloating-point számok pontos egész számok.Python úszik általában nem több, mint 53 bit pontossággal (ugyanaz, mint aplatform C kettős Típus), ebben az esetben minden float x abs(x) >= 2**52szükségszerűen nincs frakcionált bit.