dzeta --a Riemann-féle dzetafüggvény

  Bevezetés

dzeta(z) a Riemann-féle dzetafüggvényt, azaz a 
sum(k^(-z),k=1..infinity) állítja elő

   Hivatkozás(ok) 

zeta(z)

   Paraméter

 z- egy aritmetikai kifejezés 

   A függvény által kiszámított érték

 egy aritmetikai kifejezés 

 	Túlterhelhető: 

z

   Hibalehetőségek

A lebegőpontos ábrázolás során a függvény a környezeti változóknak azon
számjegyeire reagál, amelyek az aktuális numerikus pontosságnak megfelelnek. 

   Alkalmazott függvények: 

bernoulli

   Leírás

    A dzetafüggvény a z=1 egyszeres pólus kivételével az egész komplex síkon         definiált. 
    Lebegőpontos számolás során lebegőpontos számot ad eredményül. 
    A következő speciális értékekre az alábbiak vonatkoznak: 
    dzeta(z)=0 páros egész számokra, ha z<0,
    dzeta(z)=-bernoulli(z)/(1-z) páratlan egész számokra, ha  z<0, 
    zeta(0)=-1/2,
    zeta(z)=(2*PI)^z/2*abs(bernoulli(z))/fact(z) páros egész számokra, ha z>0. 

    Ha a fentiek egyikével sem lehet a változónak értéket adni, akkor a dzeta egy kiértékeletlen függvényhívást szolgáltat. 

    A dzetafüggvény lebegőpontos attribútuma (float-Attribut), egy magfüggvény 
    d.&thinsp;h., amely gyorsan szolgáltat numerikus értéket. Itt szerencsésebb            egy direkt lebegőpontos számítás zeta(float z)), mint a float(zeta(z)) alkalmazása, mivel nagy abszolútértékű egész z-re  dzeta(z) részeredményeinek pontos kiszámolása nagyon időigényes lehet.

    1. Példa

Néhány alkalmazás konkrét ill. szimbolikus bemenő adatokra 

>> zeta(-6), zeta(-5), zeta(-4), zeta(-3), zeta(-2), zeta(-1)

          0,   -1/252,       0,    1/120,         0,   -1/12

>> zeta(0), zeta(2), zeta(3), zeta(4), zeta(5), zeta(6), zeta(7)

                 2                  4                 6
               PI                 PI                PI
      -1/2,    ---,   zeta(3),    ---,  zeta(5),    ---,  zeta(7)
                6                  90               945

>> zeta(1/2), zeta(1 + I), zeta(z^2 -I)

                                          2
   zeta(1/2), zeta(1 + I), zeta(z  - I)

Lebegőpontos törtekre a dzetafüggvény numerikus értékei adódnak 

>> zeta(-1001.0),    zeta(12.3),     zeta(0.5 + 14.13472514*I) 

  -1.348590824e1771, 1.000199699, 0.0000000002163160213 - 0.000000001358779595 I

A z=1 pont egy pólus: 
>> zeta(1)

      Error: singularity [zeta]

   2.Példa 

A dzetafüggvény zérushelyeinek megkereséséhez ábrázoljuk az f(z)=abs(zeta(z)) függvényt a kritikus egyenesen, azaz minden ½ valós részű komplex számra 

>> plotfunc2d(Labels = ["", ""], Title = "", Grid = 500,
              abs(zeta(1/2 + y*I)), y = 0..30)

A következő eljárás a szokásos Newton-módszer egy egyszerű alkalmazása a dzetafügvény zérushelyeinek numerikus meghatározására.Észrevehető, hogy az eljárás numerikus deriválást tartalmaz, mivel MuPAD nem ad lehetőséget a dzetafüggvény szimbolikus differenciálására. 

>> NewtonStep := proc(z)
   local h, f, f2, fprime;
   begin
     z := float(z);
     h := 10^(-DIGITS/2.0)*(1 + abs(z));
     f := zeta(z);
     f2 := zeta(z + h);
     fprime := (f2 - f)/h;
     return(z - f/fprime)
   end_proc:

A z:=NewtonStep(z) által definiált sorozat egy zérushelyhez konvergál, ha a kezdőérték egy zérushely ’elég’ jó approximációja 
>> z:= 1/2 + 21*I:  z := NewtonStep(z): z, abs(zeta(z))

               0.5002926366 + 21.0220145 I, 0.0003338475592

>> z := NewtonStep(z): z, abs(zeta(z))

             0.4999999108 + 21.02203966 I, 0.0000001039451698

>> z := NewtonStep(z): z, abs(zeta(z))

                   0.5 + 21.02203964 I, 1.387291733e-11

>> delete NewtonStep, z:

Változtatások 

   Explicit kifejezések csak negatív egész, illetve pozitív páros egész    argumentumokra.

gamma – a gammafüggvény

  Bevezetés
 
gamma(x) a gammafüggvényt: int(exp(-t)*t^(x-1),t=0..infinity) állítja elő. 

   Hivatkozás(ok) 

gamma(x)

   Paraméter

 x-egy aritmetikai kifejezés

   A függvény által kiszámított érték: 

    egy aritmetikai kifejezés

Túlterhelhető: 

 x

   Hibalehetőségek 

A lebegőpontos ábrázolás során a függvény a környezeti változóknak azon
számjegyeire reagál, amelyek az aktuális numerikus pontosságnak megfelelnek. 

   Alkalmazott függvények

beta, fact, igamma, psi

 Leírás 
    A gammafüggvény a 0,-1,-2,.. pólusokon kívül minden komplex argumentumra   definiált. Pozitív egészekre ez pont a faktoriális függvény:
gamma(x)=fact(x-1)=(x-1)!. 
    Ha x egy lebegőpontos szám, az eredmény is egy lebegőpontos szám lesz.  
    Ha x egy 1000-nél kisebb pozitív egész, akkor az eredmény egy egész szám lesz.
Ha x egy Domain-típusú (DOM_RAT) racionális szám és 1<x<500, akkor az eredmény a gamma(x)=(x-1)*gamma(x-1) rekurzió segítségével ’normálható’ 
A gamma(x)*gamma(1-x)=PI*csc(PI*x) összefüggést használhatjuk, ha x<1/2 racionális szám ,Domain-típusú (DOM_RAT) és 1/4 vagy 1/6 egész számú többszöröse.  
A gamma(1/2)=sqrt(PI), a gamma(infinity) értéke pedig végtelen. 

    Minden más argumentumra a gamma szimbolikus értéket ad. 

    A gamma lebegőpontos attribútuma (float-Attribut) egy magfüggvény,
    d.&thinsp;h., amely gyorsan szolgáltat numerikus értéket. A gamma   logaritmikus deriváltja a digammafüggvény, a pszi segítségével számolható.
 
   1.Példa 

Néhány alkalmazás konkrét ill. szimbolikus bemenő adatokra 

>> gamma(15),         gamma(23/2), gamma(sqrt(2)), gamma(x + 1)

                              1/2
                13749310575 PI               1/2
   87178291200, -----------------,    gamma(2   ), gamma(x + 1)
                       2048

Lebegőpontos törtekre a gamma numerikus értékei adódnak 

>> gamma(11.5),         gamma(2.0 + 10.0*I)

           11899423.08,  - 0.00001089258677 + 0.00000504737724 I

   2.Példa 
gamma szinguláris a nem pozitív egész számokra 

>> gamma(-2)

      Error: singularity [gamma]

   3.Példa 

A diff, expand, float, limit und series függvények szimbolikus gamma-kifejezésekkel dolgoznak.

>> diff(gamma(x^2 + 1), x),          float(ln(3 + gamma(sqrt(PI))))

             2             2
    2 x psi(x  + 1) gamma(x  + 1),      1.367203476

>> expand(gamma(3*x - 4))

                                gamma(3 x)
                  ---------------------------------------
                  (3 x - 1) (3 x - 2) (3 x - 3) (3 x - 4)

>> limit(1/gamma(x), x = infinity), 
   limit(gamma(x - 4)/gamma(x - 10), x = 0)

                                 0, 151200

>> series(gamma(x), x = 0, 4)

                              /          2        2 \
                              |        PI    EULER  |
                              |      - --- + ------ |
             1                | PI     12      2    |      2
             - - EULER + x PI | -- + -------------- | + O(x )
             x                \ 6          PI       /

A Stirling-formulát aszimptotikus sorfejtéssel kapjuk:

>> series(gamma(x), x = infinity, 3)

                                x         / 2 PI \1/2
                               x  exp(-x) | ---- |
       x         / 2 PI \1/2              \  x   /
      x  exp(-x) | ---- |    + ---------------------- +
                 \  x   /               12 x
      
          x         / 2 PI \1/2    /  x         / 2 PI \1/2 \
         x  exp(-x) | ---- |       | x  exp(-x) | ---- |    |
                    \  x   /       |            \  x   /    |
         ---------------------- + O| ---------------------- |
                      2            |            3           |
                 288 x             \           x            /

Változtatások 

    Nincs változtatás 

igamma – a hiányos gammafüggvény

Bevezetés
 
igamma(a, x) a hiányos gammafüggvényt: int(exp(-t)*t^(a-1), t=x..infinity) állítja elő. 

   Hivatkozás(ok) 

igamma(a, x)

Paraméter

 a, x - aritmetikai kifejezések

   A függvény által kiszámított érték: 

    egy aritmetikai kifejezés

 

Túlterhelhető: 

 a, x

   Hibalehetőségek 

A lebegőpontos ábrázolás során a függvény a környezeti változóknak azon
számjegyeire reagál, amelyek az aktuális numerikus pontosságnak megfelelnek. 

   Alkalmazott függvények

Ei, erfc, exp, fact, gamma, int 

 Leírás 

    Lebegőpontos értéket számol, ha legalább az egyik argumentum lebegőpontos, mindkét érték numerikus, és a lentebb bevezetett korlátozások érvényesek. Minden más esetben az igammának és/vagy más speciális függvénynek az értéke adódhat eredményül. A lebegőpontos kiértékelés a és x tetszőleges pozitív értékére rendelkezésünkre áll. Ezen felül használhatjuk tetszőleges x komplex érték mellett is, ha a az 1/2 egész számú többszöröse. Egyéb esetekben nem biztos, hogy a lebegőpontos kiértékelés lehetséges. Még inkább szimbolikus kifejezés adódik igammára, ha a nem valós szám. A következő egyszerűsítések és kifejtési szabályok érvényesek:

            igamma(a, 0)   -->  gamma(a),
            igamma(0, x)   -->  Ei(x),
            igamma(1/2, x) -->  sqrt(PI)*erfc(sqrt(x)),
            igamma(1, x)   -->  exp(-x).

    Ha az a valós numerikus értékű, Type::Real típusú argumentum, akkor a következő összefüggés: 

    igamma(a, x) = x^(a - 1)*exp(-x) + (a - 1)*igamma(a - 1, x)

    rekurzív módon használható arra, hogy az első argumentumot a [0,1] intervallumba (0<= a <= 1) toljuk el. 
Ennek megfelelően, ha a az ½ egy egész számú többszöröse, akkor a végeredmény teljes egészében kifejezhető az ei, az erfc és az exp függvények felhasználásával. Lásd: 1.Példa.
Speciálisan: igamma(a,infinity)=0    
A lebegőpontos kiértékelés gyors és numerikusan stabil, ha mindkét argumentum valós és pozitív. Minden más esetben az esetleges túlcsordulás numerikus instabilitáshoz vezethet! Lásd: 3.Példa 

1.Példa 

Néhány alkalmazás konkrét ill. szimbolikus bemenő adatokra 

>> igamma(2, 3), igamma(1/7, x), igamma(sqrt(2), 3)

                                          1/2
      4 exp(-3), igamma(1/7, x), igamma(2   , 3)

>> igamma(a, 4), igamma(1 + I, x^2 + 1), igamma(a, infinity)

                                 2
   igamma(a, 4), igamma(1 + I, x  + 1),    0

Ha az első argumentum (a) egy valós, numerikus érték, akkor a leírásban ismertetett eljárással rekurzív módon addig alakítgatja a kifejezést, míg az első argumentum 0 és 1 közé nem esik (0<= a <= 1): 

>> igamma(-1/10, 1),                     igamma(7/4, 1) 

                                                   3 igamma(3/4, 1)
        10 exp(-1) - 10 igamma(9/10, 1), exp(-1) + ----------------
                                                          4

Ha az első argumentum az ½ egész számú többszöröse, akkor az eredmény teljes egészében kifejezhető az ei, az erfc és az exp függvények felhasználásával: 

>> igamma(-3, x), igamma(-5/2, x), igamma(8, x), igamma(13/2, 4) 

                        / 1    1   2  \
                exp(-x) | -- - - - -- |
                        |  2   x    3 |
        Ei(x)           \ x        x  /
      - ----- - -----------------------,
          6                6
      
                                                 1/2       1/2
         8 exp(-x)   4 exp(-x)   2 exp(-x)   8 PI    erfc(x   )
         --------- - --------- + --------- - ------------------,
              1/2         3/2        5/2             15
          15 x        15 x        5 x
      
                      /      2    3    4    5     6      7      \
                      |     x    x    x    x     x      x       |
         5040 exp(-x) | x + -- + -- + -- + --- + --- + ---- + 1 |,
                      \     2    6    24   120   720   5040     /
      
                                  1/2
         210979 exp(-4)   10395 PI    erfc(2)
         -------------- + -------------------
               16                 64

Lebegőpontos számokra az igamma numerikus értéket ad: 

>> igamma(0.1, 4.0),   igamma(7, 0.5), igamma(100, 100.0) 

     0.004420083058,  719.9992783,     4.542198121e155

   2.Példa 

Gyors és stabil numerikus lebegőpontos kiértékelésre van lehetőség minden pozitív valós a és x esetén 

>> igamma(1.0, 4.0), igamma(7.0, 10.2), igamma(12.3, 34.5) 

                  0.01831563889, 84.97892788, 361.781135

A lebegőpontos kiértékelés nem lehetséges, ha a  nem valós: 

>> igamma(1.0*I, 4.0),         igamma(7.0 - 3.2*I, 10.2)

     igamma(1.0 I, 4.0),       igamma(7.0 - 3.2 I, 10.2)

A lebegőpontos kiértékelés akkor sem lehetséges, a nem egész számú többszöröse 1/2-nek és x nem pozitív valós szám. 

>> igamma(0.1, -4.0),    igamma(3/4, 12.3 + 3.45*I)

   igamma(0.1, -4.0), igamma(3/4, 12.3 + 3.45 I)

A lebegőpontos kiértékelés minden komplex x-re lehetséges, ha a ½ egész számú többszöröse: 

>> igamma(-3/2, -4.0),            igamma(12, 12.3 + 3.45*I)

     2.363271801 - 2.925061502 I, 13266196.93 - 17206446.91 I

   3.Példa 

A különféle első argumentumokra használhatjuk a leírásban már említett összefüggést, hogy az eredményül kapott kifejezés ’normált’ formájú legyen:

>> igamma(-8, x), igamma(7/3, x)

                      / 1    1   2    6    24   120   720   5040 \
              exp(-x) | -- - - - -- + -- - -- + --- - --- + ---- |
                      |  2   x    3    4    5    6     7      8  |
      Ei(x)           \ x        x    x    x    x     x      x   /
      ----- + ----------------------------------------------------,
      40320                          40320
      
                               1/3
         4 igamma(1/3, x)   4 x    exp(-x)    4/3
         ---------------- + -------------- + x    exp(-x)
                9                 3

Észrevehető, hogy ilyen sorfejtéseket még a lebegőpontos kiértékelésnél is alkalmaznak, ha az a és az x nem valós és pozitív. 
A sorfejtés még numerikusan is instabil lehet, ha az a abszolútértéke nagy:

>> DIGITS := 10: igamma(-100, 100.0) 

                             8.139678825e-223

>> DIGITS := 20: igamma(-100, 100.0)

                        1.8951666599463620044e-232

>> delete DIGITS:

Változtatások 

    Az első argumentum normálása (azaz eltolása úgy, hogy 0<= a <= 1) csak az olyan a-kra lehetséges,  amelyek típusa: Type::Real. Az igamma(a,infinity) értéke pedig 0.

nextprime – a következő prímszám

 Bevezetés
 
nextprime(m) értéke a legkisebb olyan prímszám, amely nagyobb vagy egyenlő, 
mint m. 

   Hivatkozás(ok) 

nextprime(m) 

Paraméter

m- egy aritmetikai kifejezés

   A függvény által kiszámított érték: 

    egy prímszám, vagy a nextprime függvényt tartalmazó szimbolikus kifejezés

 
Alkalmazott függvények

ifactor, igcd, ilcm, isprime, ithprime,
numlib::prevprime

 Leírás
 
 Ha az m argumentum egy egész szám, akkor az eredmény a legkisebb olyan prímszám lesz, amely nagyobb vagy egyenlő, mint m. Ha m típusa nem Type::Numeric, akkor az eredmény a nextprime függvényt tartalmazó szimbolikus kifejezés. Ha az argumentum szám ugyan, de nem egész szám, akkor a program hibát jelez.

    Az első prímszám a 2. 
    nextprime a rendszermag (System-Kern) egy függvénye. 

   1.Példa 

Az első prímszámot számítja ki: 

>> nextprime(-13)

                                     2

Ha a nextprime argumentuma prímszám, akkor eredményül ez a szám adódik: 

>> nextprime(11)

                                    11

Egy nagyobb prímszámot számít ki: 

>> nextprime(56475767478567)

                              56475767478601

Szimbolikus argumentumok szibolikus eredményhez vezetnek: 

>> nextprime(x)

                               nextprime(x)

   További információk 

    A nextprime egy gyors valószínűségi prímszámtesztet  (Miller-Rabin-Test) használ annak eldöntésére, hogy a kérdéses argumentum prímszám-e. Így a nextprime függvény prímszámai vagy prímek, vagy pedig 10 (véletlenül választott) alapú erős pszeudoprímek.

Lásd: Michael O. Rabin, Probabilistic algorithms,
    in J. F. Traub, ed., Algorithms and Complexity,
    Academic Press, New York, 1976, S. 21-39. 

  Változtatások 

    Nincs változtatás 

pszi -- a digamma-/poligammafüggvény

 Bevezetés
 
psi(x) a digammafüggvényt állítja elő, azaz a gammafüggvény logaritmikus deriváltját: diff(ln(gamma(x)),x) 

psi(x,n) az n-edik poligammafüggvényt állítja elő ,azaz a gammafüggvény n-edik logaritmikus deriváltját: diff(psi(x),x$n) 

   Hivatkozás(ok) 

psi(x)
psi(x, n)

Paraméter

 x- egy aritmetikai kifejezés
   
 n- egy nem negatív egész szám

   A függvény által kiszámított érték: 

    egy aritmetikai kifejezés

 

Túlterhelhető: 

 x

   Hibalehetőségek 

Ha x egy lebegőpontos szám, akkor a függvény a környezeti változóknak azon
számjegyeire reagál, amelyek az aktuális numerikus pontosságnak megfelelnek. 

   Alkalmazott függvények

fact, gamma, zeta
  
   Leírás 

    psi(x, 0) ekvivalens a psi(x)-szel. 
    A digamma-/poligammafüggvény a 0,-1,-2,.. szinguláris pontok kivételével minden komplex argumentumra definiált. Ha x lebegőpontos szám, akkor eredményül lebegőpontos szám adódik.
 
     Ha x 1000-nél kisebb pozitív egész vagy ½ páratlanszoros többszöröse úgy, hogy |x| 1000-nél kisebb, akkor a rekurziós összefüggést:

           psi(x+1,n)=psi(x,n)+(-1)^n*n!/x^(n+1)

 alkalmazza a program. A következők segítségével 

    psi(1) = -EULER,

    psi(1,n) = (-1)^(n+1)*n!*zeta(n+1), n>0,

    psi(1/2) = -2*ln(2) - EULER,

    psi(1/2,n) =
    (-1)^(n+1)*n!*(2^(n+1)-1)*zeta(n+1), n>0

    psi(1/2) = -2*ln(2) -EULER,

    a pszi értékére explicit kifejezést kapunk. 
    A speciális értékekre: psi(infinity) =psi(infinity,0) = infinity és                                            psi(infinity,n) = 0   n>0 esetén

    Minden más argumentumra a psi értéke szimbolikus kifejezés lesz. 

    A psi(x) digammafüggvény lebegőpontos attribútuma (float-Attribut) egy magfüggvény, azaz a numerikus kiértékelés gyors.
    A psi(x,n) n>0 poligammafüggvény lebegőpontos attribútuma (float-Attribut) egy könyvtárbeli függvény. Észrevehető, hogy egész számokra és az ½ páratlan többszöröseire a psi(float(x)) ill. psi(float(x,n)) numerikus kiértékelést érdemes használni a float(psi(x)) ill. float(psi(x,n)) helyett: psi(x) ill. psi(x,n) szimbolikus eredményeinek számolása időigényes, továbbá a végső lebegőpontos (float)értékadás numerikusan instabillá válhat.  
 A növekedési tulajdonságot a 

           psi(x+1,n)=psi(x,n)+(-1)^n*n!/x^(n+1)
          
    írja le. Numerikus értékek esetén a formula használható arra, hogy az argumentumt a (0,1) intervallumba toljuk el (0<x<1). Lásd: 3. és 4. Példa

   1.Példa 

Néhány alkalmazás konkrét ill. szimbolikus bemenő adatokra: 

>> psi(-3/2),             psi(4, 1),      psi(3/2, 2)

                             2
                           PI
   8/3 - 2 ln(2) - EULER,  --- - 49/36,   16 - 14 zeta(3)
                            6

>> psi(x + sqrt(2), 4),      psi(infinity, 5)

                1/2
       psi(x + 2   , 4),            0

Lebegőpontos számokra a pszi numerikus értéket ad: 

>> psi(-5.2),     psi(1.0, 3),    psi(2.0 + 3.0*I, 10)

   6.065773152,  6.493939402,    0.7526409593 - 2.299472238 I

   2.Példa 

a nem pozitív egészekre pszi szinguláris 

>> psi(-2)

      Error: singularity [psi]

   3.Példa 

Pozitív egészekre és az ½ páratlanszoros többszöröseire az EULER, PI, ln ill. zeta függvények felhasználásával kifejezhető az eredmény, ha az argumentum abszolútértéke kisebb, mint 1000::

>> psi(-5/2), psi(-3/2, 1), psi(4, 3), psi(9/2, 2)

                              2           4
                            PI          PI
  46/15 - 2 ln(2) - EULER,  --- + 40/9, --- - 1393/216,
                             2          15

                 19410176/1157625 - 14 zeta(3)

Nagy argumentumokra a kiterjedési attribútum (expand-Attribut) feletti ilyen értékeket ad:   

>> psi(1000, 1)

                               psi(1000, 1)

>> expand(%)

        2
      PI
      --- -
       6
      
      835458876624295851523752364295.../50820720104325812617835292...

   4.Példa 

A diff, float, expand, limit és series függvények szimbolikus pszi-kifejezésekkel is dolgoznak:

>> diff(psi(x^2 + 1, 3), x), float(ln(3 + psi(sqrt(PI))))

                               2
                      2 x psi(x  + 1, 4), 1.183103343

>> expand(psi(15/4)), expand(psi(x + 3, 2))

                                         2       2          2
         psi(3/4) + 524/231, psi(x, 2) + -- + -------- + --------
                                          3          3          3
                                         x    (x + 1)    (x + 2)

>> limit(x*psi(x), x = 0), limit(psi(x, 3), x = infinity)

                                   -1, 0

>> series(psi(x), x = 0), series(psi(x, 3), x = infinity, 3)

                        2                 3   4
        1           x PI     2           x  PI       4
      - - - EULER + ----- - x  zeta(3) + ------ + O(x ),
        x             6                    90
      
         2    3    2     / 1  \
         -- + -- + -- + O| -- |
          3    4    5    |  6 |
         x    x    x     \ x  /

Változtatások 

    Explicit kifejezést csak olyan argumentumokra kapunk eredményül, melyek tetszőleges egészek vagy az ½ páratlan többszörösei és 1000-nél kisebb abszolútértékűek (|x|<1000). A kiterjedési attribútum (expand-Attribute) a szimbolikus eredményt is numerikusan írja le. 
A speciális értékekre: psi(infinity) = psi(infinity,0)= 0                           psi(infinity,n) = 0  ,ha  n>0 

isprime –- prímszámteszt

 Bevezetés
 
isprime(n) teszteli, hogy n prímszám-e 

   Hivatkozás(ok) 

isprime(n)

Paraméter

n- egy aritmetikai kifejezés, egy egész szám

   A függvény által kiszámított érték: 

 TRUE, FALSE vagy egy szimbolikus isprime-kifejezés 

 
Alkalmazott függvények

factor, ifactor, igcd, ilcm, irreducible, ithprime,
nextprime, numlib::primedivisors,
numlib::prevprime, numlib::proveprime

 Leírás

    Az isprime egy gyorsabb sztochasztikus prímszámteszt. A függvény akkor ad vissza TRUE értéket, ha az n egész szám prímszám, vagy egy -10 véletlen bázison alapuló- erős pszeudoprím. Ha az n pozitív, és FALSE értéket kapunk, akkor az n biztosan nem prímszám. Ha az n pozitív, és az isprime TRUE értéket ad, akkor az n nagy valószínűséggel prím. 

    A numlib::proveprime függvénnyel egy olyan prímszámteszt áll rendelkezésünkre, amely korrekt eredményt szolgáltat, de általában jóval lassabb, mint az isprime. 

Az isprime(0) és az isprime(1) értéke FALSE. Az isprime mindig hamis értéket ad, ha n negatív vagy az argumentum szám ugyan, de nem egész. Ha n nem szám, akkor egy szimbolikus isprime-kifejezést kapunk eredményül. Az isprime egy rendszermag-függvény. 

   1.Példa 

Az 989999 prím?

>> isprime(989999)

                                   TRUE

>> ifactor(989999)

                                  989999

Az ifactor függvénnyel ellentétben még nagy számokra is gyors:

>> isprime(2^(2^11) + 1)

                                   FALSE

isprime(0) és isprime(1) FALSE:

>> isprime(0), isprime(1)

                               FALSE, FALSE

Negatív számokra FALSE eredményt ad:

>> isprime(-13)

                                   FALSE

Nem numerikus argumentumokra szimbolikus isprime-kifejezést ad eredményül: 

>> delete n: isprime(n)

                                isprime(n)

   További információk 

    Verweis: Michael O. Rabin, Probabilistic algorithms,
    in J. F. Traub, ed., Algorithms and Complexity,
    Academic Press, New York, 1976, S. 21-39. 

Változtatások 

    Nincs változtatás 

ithprime – az i-edik prímszám

 Bevezetés
 
ithprime(i) az i-edik prímszámot adja vissza 

   Hivatkozás(ok) 

ithprime(i)

Paraméter

i- egy aritmetikai kifejezés

   A függvény által kiszámított érték: 

    egy prímszám, vagy egy, az ithprime-ra való ki nem értékelt hivatkozás 

Alkalmazott függvények

ifactor, igcd, ilcm, isprime, nextprime,
numlib::prevprime

 Leírás

 Ha az i argumentum egy pozitív szám, akkor a függvény az i-edik prímszámot adja eredményül. Ha az i típusa nem Type::Numeric, akkor egy ki nem értékelt függvényhivatkozást kapunk. Ha az argumentum szám ugyan, de nem pozitív egész, akkor a program hibát jelez. Az első prímszám a 2: ithprime(1)= 2.  
Ha az i-edik prímszámot a rendszer prímszámtáblázata tartalmazza (lásd az ifaktor súgóját), akkor az eredményt egy gyors magfüggvény szolgáltatja. Különben a nextprime függvény segítségével maga számolja ki az ithprime értékét. Ez a számolás i <= 1000000 argumentumokra még mindig elég gyors. Az i nagyobb értékeire viszont a számoláshoz szükséges idő az i számjegyeitől függően exponenciálisan nő. 

   1.Példa 

Az első 10 prímszám: 

>> ithprime(i) $ i = 1..10

                    2, 3, 5, 7, 11, 13, 17, 19, 23, 29

Egy nagyobb prímszám:

>> ithprime(123456)

                                  1632899

Szimbolikus kifejezések ki nem értékelt hivatkozásokhoz vezetnek:

>> ithprime(i)

                                ithprime(i)

Változtatások 

    Nincs változtatás 

ifactor – egész számok prímtényezőkre bontása

 Bevezetés
 
Az ifactor(n) az n = s * p1^^e1* ... * pr^er szán prímtényezős felbontását adja, ahol s az n előjele, p1,...,pr az n különböző prímtényezői, e1,...,er pedig pozitív egész számok. 

Hivatkozás(ok) 

ifactor(n <, UsePrimeTab>)
ifactor(PrimeLimit)

Paraméter

n- egy aritmetikai kifejezés, egy egész szám

 Opciók 

 UsePrimeTab - olyan prímtényezőket keres, amelyek benne vannak a rendszer belső     prímszámtáblázatában.

PrimeLimit - megadja, hogy melyik a legnagyobb prímszám, ami még benne van a   táblázatban.

A függvény által kiszámított érték: 

Egy Domaintyp Factored típusú, vagy egy szimbolikus, ifactort tartalmazó  kifejezés.

 
Alkalmazott függvények

content, factor, Factored, icontent, igcd, ilcm,
isprime, ithprime, nextprime, numlib::divisors,
numlib::ecm, numlib::mpqs, numlib::pollard,
numlib::prevprime, numlib::primedivisors

 Leírás 

    Az ifactor eredménye Domaintyp Factored típusú. Azaz f:=ifactor(n) egy olyan objektum, amelynek belső megjelenítése a következő lista:  
    [s,p1, e1, ..., pr, er]. A lista páratlan (2r+1) hosszú, ahol az r az n különböző prímtényezőinek számát jelenti. A pi-k általában nincsenek nagyság szerint rendezve. 

    Az s előjelet, a pi prímszámokat és az ei hatványkitevőket a szokásos indexoperátorral [ ] tudjuk kiolvasni, 
    azaz f[1] = s, f[2] = p1, f[3] = e1, ....

    Az f[2*i] $ i = 1..nops(f) div 2 például n minden prímtényezőjét meghatározza. Ugyanez – valamivel kényelmesebben – a Factored::factors(f)-vel is elérhető. Ugyanígy a Factored::exponents(f) a fenti ei (1<=i<=r) exponensek egy listáját adja. 

    A 0,az 1 és a –1 faktorizálásakor egyszerűen a 0, 1 ill. –1 számokat kapjuk. A belső megjelenítés a következő lista: [0], [1] ill. [-1] 

    A coerce(f,DOM_LIST) egy faktorizált objektumot a fenti lista formájában jelenít meg.

    Észrevehető, hogy az ifactor függvény eredménye kifejezés formájú, és  általában úgy is viselkedik. Például az ifactor(12) egy 2^2*3 formájú 
    objektum, és egy "_mult" típusú kifejezés. 

    Lásd : 1.Példa és a súgó(Factored to Details).

    Arra, hogy megtudjuk, vajon n prímszám-e, ha a prímfaktorizációra nincs szükségünk, lényegesen gyorsabb, ha az isprime függvényt használjuk az ifactor helyett. 

    Az ifactor hibaüzenetet ad, ha az argumentum szám ugyan, de nem egész. Ha az argumentum nem szám, akkor egy szimbolikus ifactor-kifejezést kapunk vissza. 

   Opció: UsePrimeTab

     A MuPAD rendszerszerűen kiszámolja prímszámoknak egy táblázatát, amely egy adott korlátig minden prímszámot tartalmaz. Az ifactor(n, UsePrimeTab) csak azokat a prímeket találja meg, amelyeket ez a táblázat tartalmaz. Ez a forma lényegesen gyorsabb, de a pi tényezők nem feltétlenül prímek  
     (lásd: 2.Példa)

 

   Opció: PrimeLimit

    Az ifactor(PrimeLimit) eredménye egy n természetes szám, azon számok felső   korlátja, amelyek még benne vannak a a prímtáblázatban. 

    Az n-re vonatkozó standard értékek:  
    1&thinsp;000&thinsp;000 unter Unix, 300&thinsp;000
    unter MacOS und Windows.

    UNIX rendszereken a prímtáblázat standard értékei a Kom­man­do­zei­len-  Option-L segítségével megváltoztathatók. 

   1.Példa
 
a 120 prímtényezős felbontása a következő: 

>> f := ifactor(120)

                                   3
                                  2  3 5

A belső megjelenítésből az indexoperátor segítségével olvashatjuk ki az elemeket: 

>> f[1];                            // az előjel 
   f[2*i]     $ i=1..nops(f) div 2; // a tényezők 
   f[2*i + 1] $ i=1..nops(f) div 2; // az exponensek 

                                     1
      
                                  2, 3, 5
      
                                  3, 1, 1

Az f teljes belső megjelenítése a fent leírtak alapján a következő: 

>> coerce(f, DOM_LIST)

                           [1, 2, 3, 3, 1, 5, 1]

A faktorizáció eredménye Domaintyp Factored típusú Das Ergebnis der Faktorisierung ist ein Objekt des
Domains Factored:

>> domtype(f)

                                 Factored

Diese Domain stellt einige Funktionalität zum Arbeiten mit
solchen Objekten zur Verfügung, die an dieser Stelle nur
kurz beschrieben werden.

So lassen sich die Faktoren und Exponenten auch direkt wie
folgt erfragen:

>> Factored::factors(f), Factored::exponents(f)

                           [2, 3, 5], [3, 1, 1]

Der Typ der Faktorisierung kann bestimmt werden:

>> Factored::getType(f)

                               "irreducible"

Ez az eredmény azt jelenti, hogy minden pi prím. Más lehetséges típusok: "squarefree" (lásd. polylib::sqrfree) vagy "unknown".

Ezek az objektumok össze is szorozhatók. Az eredményt faktorizált alakban kapjuk: 

>> f2 := ifactor(12)

                                    2
                                   2  3

>> f*f2

                                   5  2
                                  2  3  5

Es läßt sich fast jede Funktion auf ein solches Objekt
anwenden (überwiegend Funktionen, die als Eingabe
arithmetische Ausdrücke erwarten). Das Ergebnis ist meist
nicht mehr ein Objekt des Domains Factored:

>> expand(f);
   domtype(%)

                                    120
      
                                  DOM_INT

Die Funktion type konvertiert ein Objekt des Domains
Factored automatisch in einen Ausdruck:

>> type(f)

                                  "_mult"

Eine detaillierte Beschreibung solcher Objekte enthält die
Hilfeseite des Domains Factored.

   2.Példa 

Die Faktorisierungen von 0, 1 und -1 haben jeweils genau
einen Faktor:

>> ifactor(0), ifactor(1), ifactor(-1)

                                 0, 1, -1

>> map(%, coerce, DOM_LIST)

                              [0], [1], [-1]

Die interne Darstellung der Faktorisierung einer Primzahl
p ist die Liste [1, p, 1]:

>> coerce(ifactor(5), DOM_LIST)

                                 [1, 5, 1]

   3.Példa 

Die Schranke für die größte Zahl der Primzahltabelle ist:

>> ifactor(PrimeLimit)

                                  1000000

p wird eine große Primzahl zugewiesen:

>> p := nextprime(10^12)

                               1000000000039

Die Faktorisierung der 36stelligen Zahl 6*p^3 dauert
etwas länger (die zweite Ausgabezeile zeigt die benötigte
Zeit in Sekunden):

>> t := time():
   f := ifactor(6*p^3);
   (time() - t)/1000.0

                                             3
                            2 3 1000000000039
      
                                   12.34

>> Factored::getType(f)

                               "irreducible"

Wenn zur Faktorisierung nur die Faktoren der
Primzahltabelle genutzt werden, ist die Berechnung sehr
schnell; der Faktor p^3 wird jedoch unzerlegt
zurückgegeben:

>> t := time():
   f := ifactor(6*p^3, UsePrimeTab);
   (time() - t)/1000.0

                 2 3 1000000000117000000004563000000059319
      
                                   0.21

>> Factored::getType(f)

                                 "unknown"

   Weitere Informationen

    ifactor benutzt die elliptische Kurvenmethode. 

    ifactor ist eine Schnittstellenfunktion für die
    Kernfunktion stdlib::ifactor. Sie ruft die Funktion
    stdlib::ifactor mit den gegebenen Argumenten auf
    und konvertiert das Ergebnis, das die Liste [s, p1,
    e1, ..., pr, er] in der oben beschriebenen Form
    ist, in ein Objekt des Domaintyps Factored.

    Um diese Konvertierung zu vermeiden und damit die
    Laufzeit zu reduzieren, kann (z.&thinsp;B. innerhalb
    eigener Routinen) die Kernfunktion stdlib::ifactor
    aufgerufen werde.

Änderungen

    Der Rückgabewert von ifactor ist ein Objekt des
    Domains Factored.

fact – a faktoriálisfüggvény

 Bevezetés
 
fact(n) a faktoriálisfüggvény : n!=1*2*3*..*n 

   Hivatkozás(ok) 

fact(n)

n!

Paraméter

n- egy aritmetikai kifejezés, egy nem-negatív egész szám

   A függvény által kiszámított érték: 

 Egy aritmetikai kifejezés 

Túlterhelhető:

n

Alkalmazott függvények

gamma, igamma, psi

 Leírás

 A fact(n) kifejezés és az n! ekvivalensek. Nem-negatív egész n-ekre a függvény egész értéket ad, más numerikus argumentumokra hibát jelez. Ha n egy szimbolikus kifejezés, akkor eredményül is egy fact-ot tartalmazó szimbolikus kifejezés adódik. Az egész argumentumoknak a 32 bites rendszerben 2^31-nél, 64 bites rendszerben 2^63-nál kisebbnek kell lenniük. Nagyobb argumentumokra hibaüzenetet kapunk. A gammafüggvény a faktoriálisfüggvény tetszőleges komplex argumentumokra való általánosítása. Nem-negatív egész n-ekre teljesül a gamma(n+1) = n! egyenlőség. A rewrite(kifejezés, gamma) függvény segítségével írhatunk körül egy fact-ot tartalmazó szimbolikus kifejezést. Lásd: 3.Példa
     A ! operátor prefixjelként is alkalmazható (más jelentéssel): a !command       ekvivalens a system("command")-dal. A fact egy rendszermag-függvény.

1.Példa 

Nem-negatív egész argumentumokra a faktoriálisfüggvény értékét számolja ki:

>> fact(0), fact(5), fact(2^5)

               1, 120, 263130836933693530167218012160000000

Szimbolikus kifejezésekre eredményül is egy fact-ot tartalmazó szimbolikus kifejezés adódik:

>> fact(n), fact(n - sin(x)), fact(3.0*n + I)

                fact(n), fact(n - sin(x)), fact(3.0 n + I)

A fact(n) kifejezés és az n! ekvivalensek:

>> 5! = fact(5), (n^2 + 3)!

                                           2
                          120 = 120, fact(n  + 3)

Ha nem egész szám, akkor a numerikus argumentum is hibát okoz: 

>> fact(3/2 + I)

      Error: Non-negative integer expected [specfunc::fact];
      during evaluation of 'fact'

   2.Példa 

Hgy elkerüljük a nagyon nagy számokkal való időigényes számolást, a float(fact(n)) függvény helyett a gamma(float(n+1)) függvény segítségével numerikus közelítést kell alkalmazni:

>> float(fact(2^13)) = gamma(float(2^13 + 1))

                   1.275885799e28503 = 1.275885799e28503

   3.Példa 

Az expand, limit, rewrite és series függvények szimbolikus fact-kifejezésekkel dolgoznak:

>> expand(fact(n^2 + 4))

                     2    2        2        2        2
               fact(n ) (n  + 1) (n  + 2) (n  + 3) (n  + 4)

>> limit(fact(n)/exp(n), n = infinity)

                                 infinity

>> rewrite(fact(2*n^2 + 1)/fact(n - 1), gamma)

                                       2
                              gamma(2 n  + 2)
                              ---------------
                                 gamma(n)

A Stirling-formulát aszimptotikus sorfejtéssel kapjuk:

>> series(fact(n), n = infinity, 2)

             n + 1              / 2 PI  \1/2
      (n + 1)      exp(- n - 1) | ----- |    +
                                \ n + 1 /
      
                n + 1              / 2 PI  \1/2
         (n + 1)      exp(- n - 1) | ----- |
                                   \ n + 1 /
         -------------------------------------- +
                          12 n
      
          /        n + 1              / 2 PI  \1/2 \
          | (n + 1)      exp(- n - 1) | ----- |    |
          |                           \ n + 1 /    |
         O| -------------------------------------- |
          |                    2                   |
          \                   n                    /

Változtatások 

    Nincs változtatás