doc/info/pt_BR/Number.texi

   1 @c Language: Brazilian Portuguese, Encoding: iso-8859-1
   2 @c /Number.texi/1.23/Sat Jun  2 00:12:58 2007/-ko/
   3 @c end concepts Number Theory
   4 @menu
   5 * Funções e Variáveis Definidas para Teoria dos Números::
   6 @end menu
   7
   8 @node Funções e Variáveis Definidas para Teoria dos Números,  , Teoria dos Números, Teoria dos Números
   9 @section Funções e Variáveis Definidas para Teoria dos Números
  10
  11 @deffn {Função} bern (@var{n})
  12 Retorna o @var{n}'ésimo número de Bernoulli para o inteiro @var{n}.
  13 @c WELL, ACTUALLY bern SIMPLIFIES, LIKE FACTORIAL -- DO WE WANT TO GET INTO THAT ???
  14 @c OR JUST PRETEND IT'S "RETURNED" ???
  15 Números de Bernoulli iguais a zero são suprimidos se @code{zerobern} for @code{false}.
  16
  17 Veja também @code{burn}.
  18
  19 @example
  20 (%i1) zerobern: true$
  21 (%i2) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
  22                   1  1       1      1        1
  23 (%o2)       [1, - -, -, 0, - --, 0, --, 0, - --]
  24                   2  6       30     42       30
  25 (%i3) zerobern: false$
  26 (%i4) map (bern, [0, 1, 2, 3, 4, 5, 6, 7, 8]);
  27             1  1    1   5     691   7    3617  43867
  28 (%o4) [1, - -, -, - --, --, - ----, -, - ----, -----]
  29             2  6    30  66    2730  6    510    798
  30 @end example
  31
  32 @end deffn
  33
  34 @deffn {Função} bernpoly (@var{x}, @var{n})
  35 Retorna o @var{n}'ésimo polinômio de Bernoulli na
  36 variável @var{x}.
  37
  38 @end deffn
  39
  40 @deffn {Função} bfzeta (@var{s}, @var{n})
  41 Retorna a função zeta de Riemann para o argumento @var{s}.
  42 O valor de retorno é um grande inteiro em ponto flutuante (bfloat);
  43 @var{n} é o número de dígitos no valor de retorno.
  44
  45 @code{load ("bffac")} chama essa função.
  46
  47 @end deffn
  48
  49 @deffn {Função} bfhzeta (@var{s}, @var{h}, @var{n})
  50 Retorna a função zeta de Hurwitz para os argumentos @var{s} e @var{h}.
  51 O valor de retorno é um grande inteiro em ponto flutuante (bfloat);
  52 @var{n} é o números de dígitos no valor de retorno.
  53
  54 A função zeta de Hurwitz é definida como
  55
  56 @example
  57 sum ((k+h)^-s, k, 0, inf)
  58 @end example
  59
  60 @code{load ("bffac")} chama essa função.
  61
  62 @end deffn
  63
  64 @deffn {Função} binomial (@var{x}, @var{y})
  65 O coeficiente binomial @code{@var{x}!/(@var{y}! (@var{x} - @var{y})!)}.
  66 Se @var{x} e @var{y} forem inteiros, então o valor numérico do coeficiente
  67 binomial é calculado.
  68 Se @var{y}, ou @var{x - y}, for um inteiro,
  69 o the coeficiente binomial é expresso como um polinômio.
  70
  71 Exemplos:
  72
  73 @c ===beg===
  74 @c binomial (11, 7);
  75 @c 11! / 7! / (11 - 7)!;
  76 @c binomial (x, 7);
  77 @c binomial (x + 7, x);
  78 @c binomial (11, y);
  79 @c ===end===
  80 @example
  81 (%i1) binomial (11, 7);
  82 (%o1)                          330
  83 (%i2) 11! / 7! / (11 - 7)!;
  84 (%o2)                          330
  85 (%i3) binomial (x, 7);
  86         (x - 6) (x - 5) (x - 4) (x - 3) (x - 2) (x - 1) x
  87 (%o3)   -------------------------------------------------
  88                               5040
  89 (%i4) binomial (x + 7, x);
  90       (x + 1) (x + 2) (x + 3) (x + 4) (x + 5) (x + 6) (x + 7)
  91 (%o4) -------------------------------------------------------
  92                                5040
  93 (%i5) binomial (11, y);
  94 (%o5)                    binomial(11, y)
  95 @end example
  96
  97 @end deffn
  98
  99 @deffn {Função} burn (@var{n})
 100 Retorna o @var{n}'ésimo número de Bernoulli para o inteiro @var{n}.
 101 @code{burn} pode ser mais eficitente que @code{bern} para valores grandes e isolados de @var{n}
 102 (talvez @var{n} maior que 105 ou algo parecido), @c CLAIM MADE IN bffac.usg !!!
 103 como @code{bern} calcula todos os números de Bernoulli até o índice @var{n} antes de retornar.
 104
 105 @c STATEMENTS ABOUT TIMING NEED VERIFICATION !!!
 106 @c CAN'T VERIFY NOW AS burn IS BROKEN IN 5.9.1 AND CVS BUILD AT PRESENT !!!
 107 @c (BERN(402) takes about 645 secs vs 13.5 secs for BURN(402).
 108 @c The time to compute @code{bern} is approximately exponential,
 109 @c while the time to compute @code{burn} is approximately cubic.
 110 @c But if next you do BERN(404), it only takes 12 secs,
 111 @c since BERN remembers all in an array, whereas BURN(404) will take
 112 @c maybe 14 secs or maybe 25, depending on whether Maxima needs to
 113 @c BFLOAT a better value of %PI.)
 114
 115 @code{burn} explora a observação que números de Bernoulli (racionais) podem ser
 116 aproximados através de zetas (transcendentes) com eficiência tolerável.
 117
 118 @code{load ("bffac")} chama essa função.
 119
 120 @end deffn
 121
 122 @deffn {Função} cf (@var{expr})
 123 Converte @var{expr} em uma fração contínua.
 124 @var{expr} é uma expressão
 125 compreendendo frações contínuas e raízes quadradas de inteiros.
 126 Operandos na expressão podem ser combinados com operadores aritméticos.
 127 Com excessão de frações contínuas e raízes quadradas,
 128 fatores na expressão devem ser números inteiros ou racionais.
 129 Maxima não conhece operações sobre frações contínuas fora de @code{cf}.
 130
 131 @code{cf} avalia seus argumentos após associar @code{listarith} a @code{false}.
 132 @code{cf} retorna uma fração contínua, representada como uma lista.
 133
 134 Uma fração contínua @code{a + 1/(b + 1/(c + ...))}
 135 é representada através da lista @code{[a, b, c, ...]}.
 136 Os elementos da lista @code{a}, @code{b}, @code{c}, ... devem avaliar para inteiros.
 137 @var{expr} pode também conter @code{sqrt (n)} onde @code{n} é um inteiro.
 138 Nesse caso @code{cf} fornecerá tantos
 139 termos de fração contínua quantos forem o valor da variável
 140 @code{cflength} vezes o período.
 141
 142 Uma fração contínua pode ser avaliada para um número
 143 através de avaliação da representação aritmética
 144 retornada por @code{cfdisrep}.
 145 Veja também @code{cfexpand} para outro caminho para avaliar uma fração contínua.
 146
 147 Veja também @code{cfdisrep}, @code{cfexpand}, e @code{cflength}.
 148
 149 Exemplos:
 150
 151 @itemize @bullet
 152 @item
 153 @var{expr} é uma expressão compreendendo frações contínuas e raízes quadradas de inteiros.
 154
 155 @example
 156 (%i1) cf ([5, 3, 1]*[11, 9, 7] + [3, 7]/[4, 3, 2]);
 157 (%o1)               [59, 17, 2, 1, 1, 1, 27]
 158 (%i2) cf ((3/17)*[1, -2, 5]/sqrt(11) + (8/13));
 159 (%o2)        [0, 1, 1, 1, 3, 2, 1, 4, 1, 9, 1, 9, 2]
 160 @end example
 161
 162 @item
 163 @code{cflength} controla quantos períodos de fração contínua
 164 são computados para números algébricos, números irracionais.
 165
 166 @example
 167 (%i1) cflength: 1$
 168 (%i2) cf ((1 + sqrt(5))/2);
 169 (%o2)                    [1, 1, 1, 1, 2]
 170 (%i3) cflength: 2$
 171 (%i4) cf ((1 + sqrt(5))/2);
 172 (%o4)               [1, 1, 1, 1, 1, 1, 1, 2]
 173 (%i5) cflength: 3$
 174 (%i6) cf ((1 + sqrt(5))/2);
 175 (%o6)           [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]
 176 @end example
 177
 178 @item
 179 Um fração contínua pode ser avaliado através da avaliação da representação aritmética
 180 retornada por @code{cfdisrep}.
 181
 182 @example
 183 (%i1) cflength: 3$
 184 (%i2) cfdisrep (cf (sqrt (3)))$
 185 (%i3) ev (%, numer);
 186 (%o3)                   1.731707317073171
 187 @end example
 188
 189 @item
 190 Maxima não conhece operações sobre frações contínuas fora de @code{cf}.
 191
 192 @example
 193 (%i1) cf ([1,1,1,1,1,2] * 3);
 194 (%o1)                     [4, 1, 5, 2]
 195 (%i2) cf ([1,1,1,1,1,2]) * 3;
 196 (%o2)                  [3, 3, 3, 3, 3, 6]
 197 @end example
 198
 199 @end itemize
 200 @end deffn
 201
 202 @c NEEDS CLARIFICATION -- MAKE EXPLICIT HOW list IS RELATED TO a, b, c, ...
 203 @c ALSO, CAN list CONTAIN ANYTHING OTHER THAN LITERAL INTEGERS ??
 204 @deffn {Função} cfdisrep (@var{list})
 205 Constrói e retorna uma expressão aritmética comum
 206 da forma @code{a + 1/(b + 1/(c + ...))}
 207 a partir da representação lista de uma fração contínua @code{[a, b, c, ...]}.
 208
 209 @example
 210 (%i1) cf ([1, 2, -3] + [1, -2, 1]);
 211 (%o1)                     [1, 1, 1, 2]
 212 (%i2) cfdisrep (%);
 213                                   1
 214 (%o2)                     1 + ---------
 215                                     1
 216                               1 + -----
 217                                       1
 218                                   1 + -
 219                                       2
 220 @end example
 221
 222 @end deffn
 223
 224 @deffn {Função} cfexpand (@var{x})
 225 Retorna uma matriz de numeradores e denominadores dos
 226 último (columa 1) e penúltimo (columa 2) convergentes da fração contínua @var{x}.
 227
 228 @example
 229 (%i1) cf (rat (ev (%pi, numer)));
 230
 231 `rat' replaced 3.141592653589793 by 103993/33102 = 3.141592653011902
 232 (%o1)                  [3, 7, 15, 1, 292]
 233 (%i2) cfexpand (%);
 234                          [ 103993  355 ]
 235 (%o2)                    [             ]
 236                          [ 33102   113 ]
 237 (%i3) %[1,1]/%[2,1], numer;
 238 (%o3)                   3.141592653011902
 239 @end example
 240
 241 @end deffn
 242
 243 @defvr {Variável de opção} cflength
 244 Valor padrão: 1
 245
 246 @code{cflength} controla o número de termos da fração
 247 contínua que a função @code{cf} fornecerá, como o valor de @code{cflength} vezes o
 248 período.  Dessa forma o padrão é fornecer um período.
 249
 250 @example
 251 (%i1) cflength: 1$
 252 (%i2) cf ((1 + sqrt(5))/2);
 253 (%o2)                    [1, 1, 1, 1, 2]
 254 (%i3) cflength: 2$
 255 (%i4) cf ((1 + sqrt(5))/2);
 256 (%o4)               [1, 1, 1, 1, 1, 1, 1, 2]
 257 (%i5) cflength: 3$
 258 (%i6) cf ((1 + sqrt(5))/2);
 259 (%o6)           [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2]
 260 @end example
 261
 262 @end defvr
 263
 264 @deffn {Função} divsum (@var{n}, @var{k})
 265 @deffnx {Função} divsum (@var{n})
 266
 267 @code{divsum (@var{n}, @var{k})} retorna a adição dos divisores de @var{n}
 268 elevados à @var{k}'ésima potência.
 269
 270 @code{divsum (@var{n})} retorna a adição dos divisores de @var{n}.
 271
 272 @example
 273 (%i1) divsum (12);
 274 (%o1)                          28
 275 (%i2) 1 + 2 + 3 + 4 + 6 + 12;
 276 (%o2)                          28
 277 (%i3) divsum (12, 2);
 278 (%o3)                          210
 279 (%i4) 1^2 + 2^2 + 3^2 + 4^2 + 6^2 + 12^2;
 280 (%o4)                          210
 281 @end example
 282
 283 @end deffn
 284
 285 @deffn {Função} euler (@var{n})
 286 Retorna o @var{n}'ésimo número de Euler para o inteiro @var{n} não negativo.
 287
 288 Para a constante de Euler-Mascheroni, veja @code{%gamma}.
 289
 290 @example
 291 (%i1) map (euler, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 292 (%o1)    [1, 0, - 1, 0, 5, 0, - 61, 0, 1385, 0, - 50521]
 293 @end example
 294
 295 @end deffn
 296
 297 @defvr {Constante} %gamma
 298 @ifinfo
 299 @vrindex Constante de Euler-Mascheroni
 300 @end ifinfo
 301 A constante de Euler-Mascheroni, 0.5772156649015329 ....
 302 @c DOUBTLESS THERE IS MORE TO SAY HERE.
 303
 304 @end defvr
 305
 306 @deffn {Função} factorial (@var{x})
 307 Representa a função fatorial. Maxima trata @code{factorial (@var{x})} da mesma forma que @code{@var{x}!}.
 308 Veja @code{!}.
 309
 310 @end deffn
 311
 312 @deffn {Função} fib (@var{n})
 313 Retorna o @var{n}'ésimo número de Fibonacci.
 314 @code{fib(0)} igual a 0 e @code{fib(1)} igual a 1,
 315 e
 316 @code{fib (-@var{n})} igual a @code{(-1)^(@var{n} + 1) * fib(@var{n})}.
 317
 318 Após chamar @code{fib},
 319 @code{prevfib} é iguala @code{fib (@var{x} - 1)},
 320 o número de Fibonacci anterior ao último calculado.
 321
 322 @example
 323 (%i1) map (fib, [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
 324 (%o1)         [0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]
 325 @end example
 326
 327 @end deffn
 328
 329 @deffn {Função} fibtophi (@var{expr})
 330 Expressa números de Fibonacci que aparecem em @var{expr} em termos da constante @code{%phi},
 331 que é @code{(1 + sqrt(5))/2}, aproximadamente 1.61803399.
 332
 333 Exemplos:
 334
 335 @c ===beg===
 336 @c fibtophi (fib (n));
 337 @c fib (n-1) + fib (n) - fib (n+1);
 338 @c fibtophi (%);
 339 @c ratsimp (%);
 340 @c ===end===
 341
 342 @example
 343 (%i1) fibtophi (fib (n));
 344                            n             n
 345                        %phi  - (1 - %phi)
 346 (%o1)                  -------------------
 347                            2 %phi - 1
 348 (%i2) fib (n-1) + fib (n) - fib (n+1);
 349 (%o2)          - fib(n + 1) + fib(n) + fib(n - 1)
 350 (%i3) fibtophi (%);
 351             n + 1             n + 1       n             n
 352         %phi      - (1 - %phi)        %phi  - (1 - %phi)
 353 (%o3) - --------------------------- + -------------------
 354                 2 %phi - 1                2 %phi - 1
 355                                           n - 1             n - 1
 356                                       %phi      - (1 - %phi)
 357                                     + ---------------------------
 358                                               2 %phi - 1
 359 (%i4) ratsimp (%);
 360 (%o4)                           0
 361 @end example
 362
 363 @end deffn
 364
 365 @deffn {Função} ifactors (@var{n})
 366 Para um inteiro positivo @var{n} retorna a fatoração de @var{n}. Se
 367 @code{n=p1^e1..pk^nk} for a decomposição de @var{n} em fatores
 368 primos, @code{ifactors} retorna @code{[[p1, e1], ... , [pk, ek]]}.
 369
 370 Os métodos de fatoração usados são divisões triviais por primos até 9973,
 371 o método rho de Pollard e o método da curva elíptica.
 372
 373 @example
 374 (%i1) ifactors(51575319651600);
 375 (%o1)     [[2, 4], [3, 2], [5, 2], [1583, 1], [9050207, 1]]
 376 (%i2) apply("*", map(lambda([u], u[1]^u[2]), %));
 377 (%o2)                        51575319651600
 378 @end example
 379
 380 @end deffn
 381
 382 @deffn {Função} inrt (@var{x}, @var{n})
 383 Retorna a parte inteira da @var{n}'ésima raíz do valor absoluto de @var{x}.
 384
 385 @example
 386 (%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
 387 (%i2) map (lambda ([a], inrt (10^a, 3)), l);
 388 (%o2) [2, 4, 10, 21, 46, 100, 215, 464, 1000, 2154, 4641, 10000]
 389 @end example
 390
 391 @end deffn
 392
 393 @deffn {Função} inv_mod (@var{n}, @var{m})
 394 Calcula o  inverso de @var{n} módulo @var{m}.
 395 @code{inv_mod (n,m)} retorna @code{false},
 396 se @var{n} modulo @var{m} for zero.
 397
 398 @example
 399 (%i1) inv_mod(3, 41);
 400 (%o1)                           14
 401 (%i2) ratsimp(3^-1), modulus=41;
 402 (%o2)                           14
 403 (%i3) inv_mod(3, 42);
 404 (%o3)                          false
 405 @end example
 406
 407 @end deffn
 408
 409 @deffn {Função} jacobi (@var{p}, @var{q})
 410 Retorna símbolo de Jacobi de @var{p} e @var{q}.
 411
 412 @example
 413 (%i1) l: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]$
 414 (%i2) map (lambda ([a], jacobi (a, 9)), l);
 415 (%o2)         [1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0]
 416 @end example
 417
 418 @end deffn
 419
 420 @deffn {Função} lcm (@var{expr_1}, ..., @var{expr_n})
 421 Retorna o menor múltiplo comum entre seus argumentos.
 422 Os argumentos podem ser expressões gerais também inteiras.
 423
 424 @code{load ("functs")} chama essa função.
 425
 426 @end deffn
 427
 428 @deffn {Função} minfactorial (@var{expr})
 429 Examina @var{expr} procurando por ocorrências de dois fatoriais
 430 que diferem por um inteiro.
 431 @code{minfactorial} então converte um em um polinômio vezes o outro.
 432
 433 @c I CAN'T TELL WHAT THIS IS SUPPOSED TO MEAN. !!!
 434 @c minfactorial DOESN'T SEEM TO DO ANYTHING binomial DOESN'T DO BY ITSELF !!!
 435 @c LOOKING AT THE minfactorial CODE DOESN'T HELP !!!
 436 @c If exp involves binomial coefficients then they will be
 437 @c converted into ratios of factorials.
 438
 439 @example
 440 (%i1) n!/(n+2)!;
 441                                n!
 442 (%o1)                       --------
 443                             (n + 2)!
 444 (%i2) minfactorial (%);
 445                                 1
 446 (%o2)                    ---------------
 447                          (n + 1) (n + 2)
 448 @end example
 449
 450 @end deffn
 451
 452 @deffn {Função} next_prime (@var{n})
 453 Retorna o menor primo maior que @var{n}.
 454
 455 @example
 456 (%i1) next_prime(27);
 457 (%o1)                       29
 458 @end example
 459
 460 @end deffn
 461
 462 @deffn {Função} partfrac (@var{expr}, @var{var})
 463 Expande a expressão @var{expr} em frações parciais
 464 com relação à variável principal @var{var}.  @code{partfrac} faz uma decomposição
 465 completa de fração parcial.  O algorítmo utilizado é baseado no
 466 fato que os denominadores de uma expansão de fração parcial (os
 467 fatores do denominador original) são relativamente primos.  Os
 468 numeradores podem ser escritos como combinação linear dos denominadores, e
 469 a expansão acontece.
 470
 471 @example
 472 (%i1) 1/(1+x)^2 - 2/(1+x) + 2/(2+x);
 473                       2       2        1
 474 (%o1)               ----- - ----- + --------
 475                     x + 2   x + 1          2
 476                                     (x + 1)
 477 (%i2) ratsimp (%);
 478                                  x
 479 (%o2)                 - -------------------
 480                          3      2
 481                         x  + 4 x  + 5 x + 2
 482 (%i3) partfrac (%, x);
 483                       2       2        1
 484 (%o3)               ----- - ----- + --------
 485                     x + 2   x + 1          2
 486                                     (x + 1)
 487 @end example
 488
 489 @end deffn
 490
 491 @deffn {Função} power_mod (@var{a}, @var{n}, @var{m})
 492 Usa um algorítmo modular para calcular @code{a^n mod m}
 493 onde @var{a} e @var{n} são inteiros e @var{m} é um inteiro positivo.
 494 Se @var{n} for negativo, @code{inv_mod} é usada para encontrar o inverso modular.
 495
 496 @example
 497 (%i1) power_mod(3, 15, 5);
 498 (%o1)                          2
 499 (%i2) mod(3^15,5);
 500 (%o2)                          2
 501 (%i3) power_mod(2, -1, 5);
 502 (%o3)                          3
 503 (%i4) inv_mod(2,5);
 504 (%o4)                          3
 505 @end example
 506
 507 @end deffn
 508
 509 @deffn {Função} primep (@var{n})
 510 Teste de primalidade. Se @code{primep (n)} retornar @code{false}, @var{n} é um
 511 número compostro e se esse teste retornar @code{true}, @var{n} é um número primo
 512 com grande probabilidade.
 513
 514 Para @var{n} menor que 3317044064679887385961981 uma versão deterministra do teste de
 515 Miller-Rabin é usada. Se @code{primep (n)} retornar @code{true}, então @var{n} é um
 516 número primo.
 517
 518 Para @var{n} maior que 34155071728321 @code{primep} usa
 519 @code{primep_number_of_tests} que é os testes de pseudo-primalidade de Miller-Rabin
 520 e um teste de pseudo-primalidade de Lucas. A probabilidade que @var{n} irá
 521 passar por um teste de Miller-Rabin é menor que 1/4. Usando o valor padrão 25 para
 522 @code{primep_number_of_tests}, a probabilidade de @var{n} passar no teste sendo
 523 composto é muito menor que 10^-15.
 524
 525 @end deffn
 526
 527 @defvr {Variável de opção} primep_number_of_tests
 528 Valor padrão: 25
 529
 530 Número de testes de Miller-Rabin usados em @code{primep}.
 531 @end defvr
 532
 533 @deffn {Função} prev_prime (@var{n})
 534 Retorna o maior primo menor que @var{n}.
 535
 536 @example
 537 (%i1) prev_prime(27);
 538 (%o1)                       23
 539 @end example
 540 @end deffn
 541
 542 @deffn {Função} qunit (@var{n})
 543 Retorna a principal unidade do campo dos números quadráticos reais
 544 @code{sqrt (@var{n})} onde @var{n} é um inteiro,
 545 i.e., o elemento cuja norma é unidade.
 546 Isso é importante para resolver a equação de Pell @code{a^2 - @var{n} b^2 = 1}.
 547
 548 @example
 549 (%i1) qunit (17);
 550 (%o1)                     sqrt(17) + 4
 551 (%i2) expand (% * (sqrt(17) - 4));
 552 (%o2)                           1
 553 @end example
 554
 555 @end deffn
 556
 557 @deffn {Função} totient (@var{n})
 558 Retorna o número de inteiros menores que ou iguais a @var{n} que
 559 são relativamente primos com @var{n}.
 560
 561 @end deffn
 562
 563 @defvr {Variável de opção} zerobern
 564 Valor padrão: @code{true}
 565
 566 Quando @code{zerobern} for @code{false},
 567 @code{bern} exclui os números de Bernoulli que forem iguais a zero.
 568 Veja @code{bern}.
 569
 570 @end defvr
 571
 572 @deffn {Função} zeta (@var{n})
 573 Retorna a função zeta de Riemann se @var{x} for um inteiro negativo, 0, 1,
 574 ou número par positivo,
 575 e retorna uma forma substantiva @code{zeta (@var{n})} para todos os outros argumentos,
 576 incluindo não inteiros racionais, ponto flutuante, e argumentos complexos.
 577
 578 Veja também @code{bfzeta} e @code{zeta%pi}.
 579
 580 @example
 581 (%i1) map (zeta, [-4, -3, -2, -1, 0, 1, 2, 3, 4, 5]);
 582                                      2              4
 583            1        1     1       %pi            %pi
 584 (%o1) [0, ---, 0, - --, - -, inf, ----, zeta(3), ----, zeta(5)]
 585           120       12    2        6              90
 586 @end example
 587
 588 @end deffn
 589
 590 @defvr {Variável de opção} zeta%pi
 591 Valor padrão: @code{true}
 592
 593 Quando @code{zeta%pi} for @code{true}, @code{zeta} retorna uma expressão
 594 proporcional a @code{%pi^n} para inteiro par @code{n}.
 595 De outra forma, @code{zeta} retorna uma forma substantiva @code{zeta (n)}
 596 para inteiro par @code{n}.
 597
 598 @example
 599 (%i1) zeta%pi: true$
 600 (%i2) zeta (4);
 601                                  4
 602                               %pi
 603 (%o2)                         ----
 604                                90
 605 (%i3) zeta%pi: false$
 606 (%i4) zeta (4);
 607 (%o4)                        zeta(4)
 608 @end example
 609
 610 @end defvr
 611