matemática – funções Matemáticas¶

Número-teórico e funções de representação¶

math.ceil(x)¶

Retornar o teto de x, o menor inteiro maior do que ou igual a x.Se x não é um float, os delegados x.__ceil__(), que deve retornar umIntegral valor.

math.comb(n, k)¶

Retornar o número de maneiras de escolher k itens de n itens, sem repetitionand sem fim.,

Avalia n! / (k! * (n - k)!) quando k <= n e evaluatesto zero quando k > n.

também chamado de coeficiente binomial porque é equivalente ao coeficiente de K-ésimo termo na expansão polinomial da expressão (1 + x) ** n.

levanta TypeError se qualquer dos argumentos não são inteiros.Raises ValueError if either of the arguments are negative.

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

Voltar fmod(x, y), tal como definido pela plataforma C biblioteca. Note – se que a expressão de python x % y pode não retornar o mesmo resultado. A intenção do Bestandarte é que fmod(x, y) ser exatamente (matematicamente; a infiniteprecision) igual a x - n*y para algum inteiro n tal que o resultado conta com mesmo sinal como x e a magnitude menor do que abs(y)., Python’s x % yretorna um resultado com o sinal de y em vez disso, e pode não ser exatamente computável para argumentos flutuantes. Por exemplo, fmod(-1e-100, 1e100) é -1e-100, masa resultado de Python -1e-100 % 1e100 é 1e100-1e-100, que não pode berepresented exatamente como um float, e arredonda para o surpreendente 1e100. Por esta razão, a função fmod() é geralmente preferida quando se trabalha com flutuadores, enquanto que Python x % y é preferível quando se trabalha com inteiros.,

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

Retornar uma precisão de ponto flutuante soma dos valores no iterable. Avoidsloss de precisão pelo acompanhamento de vários intermediários somas parciais:

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

O do algoritmo a exatidão depende do IEEE-754 aritmética garantias e thetypical caso em que o modo de arredondamento é a metade mesmo., Em algumas construções Não-Windowsbuilds, a biblioteca C subjacente usa uma adição de precisão estendida e pode ocasionalmente dobrar uma soma intermediária fazendo com que ela esteja fora em seu bit mais significativo.

para mais discussão e duas abordagens alternativas, consulte o ASPN cookbookrecipes para obter uma soma precisa de vírgula flutuante.

math.gcd(*inteiros)¶

Return the greatest common divisor of the specified integer arguments.Se algum dos argumentos é nonzero, então o valor retornado é o maior inteiro positivo que é um divisor de todos os argumentos., If all arguments are zero, then the returned value is 0. gcd() sem argumentsreturns 0.

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

Voltar True se os valores de a e b são próximos uns dos outros eFalse caso contrário.,se dois valores são ou não considerados próximos, é determinado de acordo com as tolerâncias relativas e absolutas togiven.

rel_tol é a relativa tolerância – é o máximo permitido differencebetween a e b, em relação ao maior valor absoluto de a ou b.Por exemplo, para definir uma tolerância de 5%, pass rel_tol=0.05. A defaulttolerância é 1e-09, o que garante que os dois valores são os mesmos com cerca de 9 dígitos decimais. rel_tol deve ser superior a zero.

abs_tol é a tolerância absoluta mínima-útil para comparações com nearzero., abs_tol deve ser, pelo menos, zero.

Se não ocorrerem erros, o resultado será:abs(a-b) <= max(rel_tol * max(abs(a), abs(b)), abs_tol).

the IEEE 754 special values of NaN, inf, and -inf will behandled according to IEEE rules. Especificamente, NaN não é consideredclose para qualquer outro valor, incluindo NaN. inf e -inf são onlyconsidered perto de si.

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 if x is a NaN (not a number), and False de outra forma.

math.isqrt(n)¶

Retornar o número inteiro raiz quadrada de número inteiro não negativo n. Este é thefloor da mesma raiz quadrada de n, ou equivalentemente o maior integera tais que a2 ≤ n.

Para algumas aplicações, pode ser mais conveniente para o menor integera tal que n ≤ a2, ou, em outras palavras, o teto da exata raiz quadrada de n., For positive n, this can be computed using.

math.lcm(*inteiros)

Devolve o múltiplo menos comum dos argumentos inteiros especificados.Se todos os argumentos são não-zero, então o valor retornado é o pequeno número inteiro positivo que é um múltiplo de todos os argumentos. Se algum dos argumentsis zero, então o valor retornado é 0. lcm() sem argumentsreturns 1.

math.ldexp(x, i)¶

Voltar x * (2**i). Isto é essencialmente o inverso da funçãofrexp().

math.modf(x)¶

Return the fractional and integer parts of X. Both results carry the signof x and are floats.

Retornar o próximo valor de ponto flutuante depois de x para y.

Se x é igual a y, retornar y.

Exemplos:

Veja também: math.ulp().

math.perm(n, k=nenhuma)¶

Return the number of ways to choose K items from N itemswithout repetition and with order.

Avalia n! / (n - k)! quando k <= n e evaluatesto zero quando k > n.

Se k não é especificado ou não é nenhum, então k é por omissão nand a função devolve n!.

levanta TypeError se qualquer dos argumentos não são inteiros.Raises ValueError if either of the arguments are negative.,

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

Calcular o produto de todos os elementos na entrada iterable.O valor inicial padrão para o produto é 1.

Quando o iterável estiver vazio, devolve o valor inicial. Esta função é concebida especificamente para uso com valores numéricos e pode rejeitar tipos não-numéricos.

math.remainder(x, y)¶

Return the IEEE 754-style remainder of x with respect to Y., Forfinite x and finite nonzero y, this is the difference x - n*y,where is the closest integer to the exact value of the quocient x /y. If x / y is exactly halfway between two consecutive integers, thenearest even integer is used for . The remainder r = remainder(x,y) thus always satisfies abs(r) <= 0.5 * abs(y).,

casos Especiais siga IEEE 754: em particular, remainder(x, math.inf) isx para qualquer finito x, e remainder(x, 0) eremainder(math.inf, x) aumentar ValueError para qualquer não-NaN x.Se o resultado do restante da operação é zero, zero vai havethe mesmo sinal que x.

Em plataformas usando IEEE 754 binária de ponto flutuante, o resultado de thisoperation é sempre exatamente representáveis: não há erro de arredondamento é introduzido.

math.trunc(x)¶

Voltar Real valor de x truncado para umIntegral (geralmente um número inteiro). Delegates tox.__trunc__().

math.ulp(x)¶

Retornar o valor do bit menos significativo do float x:

• Se x é um NaN (não é um número), return x.

• Se x for negativo, o retorno ulp(-x).

• Se x for um infinito positivo, retorne X.,

• Se x for igual a zero, devolve o menor flutuador representado positivenormalizado (menor que o flutuador positivenormalizado mínimo, sys.float_info.min).

• Se x for igual ao maior float representável positivo, devolva o valor do bit menos significativo de x, de modo que o primeiro filat menor que x seja x - ulp(x).

• Caso contrário (x é um número finito positivo), devolve o valor do bit menor significativo de x, de modo que o primeiro vetor maior que xis x + ulp(x).,

ULP significa “unidade no último lugar”.

Ver também esys.float_info.epsilon.

Note que frexp() e modf() diferente de chamada/retorno patternthan sua C equivalentes: eles tomam um único argumento e retorna um par ofvalues, ao invés de retornar para seu segundo valor de retorno através de um ‘outputparameter’ (não há tal coisa em Python).,

Para o ceil() floor() e modf() funções, observe que allfloating números de ponto suficientemente grande magnitude, são exata de números inteiros.Os flutuadores de Python normalmente não possuem mais de 53 bits de precisão (o mesmo que o tipo duplo C doplatform), no qual qualquer float x COM abs(x) >= 2**52necessariamente não tem bits fraccionais.