Podstawy programu MAPLE

6. Ułamki

6.1. Funkcje podstawowe

ceil(x): funkcja "sufit", zwraca najmniejszą liczbę całkowitą większą bądź równą x
floor(x): funkcja "podłoga", zwraca największą liczbę całkowitą mniejszą bądź równą x
numer(x): zwraca licznik ułamka x
denom(x): zwraca mianownik ułamka x
frac(x): zwraca część ułamkową liczby x: frac(x) = x - trunc(x)
trunc(x): zwraca największą liczbę całkowitą mniejszą bądź równą x, dla x<0: trunc(x) = -trunc(-x)
round(x): przybliża do najbliższej liczby całkowitej
rationalize(x): usuwa niewymierność z mianownika ułamka x

Dla liczb zespolonych mamy:

trunc(x) = trunc(Re(x)) + I*trunc(Im(x))
round(x) = round(Re(x)) + I*round(Im(x))
frac(x) = frac(Re(x)) + I*frac(Im(x))
ceil(x) = -floor(-x)
floor(x) = floor(Re(x)) + I*floor(Im(x)) + Y

gdzie Y zdefiniowane jest jako:

`Y` = 0	gdy: a + b < 1
`Y` = 1	gdy: a + b >= 1 oraz a >= b
`Y` = I	gdy: a + b >= 1 oraz a < b

gdzie: a = Re(x)-floor(Re(x)) oraz b = Im(x)-floor(Im(x))

6.2. Ułamki łańcuchowe

> with(numtheory);

Warning, the protected name order has been redefined and unprotected
[GIgcd, bigomega, cfrac, cfracpol, cyclotomic, divisors, factorEQ, factorset,

    fermat, imagunit, index, integral_basis, invcfrac, invphi, issqrfree,

    jacobi, kronecker, lambda, legendre, mcombine, mersenne, migcdex,

    minkowski, mipolys, mlog, mobius, mroot, msqrt, nearestp, nthconver,

    nthdenom, nthnumer, nthpow, order, pdexpand, phi, pi, pprimroot, primroot,

    quadres, rootsunity, safeprime, sigma, sq2factor, sum2sqr, tau, thue]

> cfrac(Pi);

                                        1
              3 + ----------------------------------------------
                                          1
                  7 + ------------------------------------------
                                             1
                      15 + -------------------------------------
                                               1
                           1 + ---------------------------------
                                                  1
                               292 + ---------------------------
                                                    1
                                     1 + -----------------------
                                                      1
                                         1 + -------------------
                                                        1
                                             1 + ---------------
                                                          1
                                                 2 + -----------
                                                            1
                                                     1 + -------
                                                         3 + ...

Dodanie parametru quotients powoduje wypisanie jedynie współczynników:

> cfrac(Pi, 'quotients');

                   [3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, ...]

Jako argument można podać nazwę zmiennej, pod którą zostaną zapisane kolejne ułamki, coraz to lepiej przybliżające rozwijaną wartość:

> cfrac(Pi,6,'con');

                                        1
                      3 + ------------------------------
                                          1
                          7 + --------------------------
                                             1
                              15 + ---------------------
                                               1
                                   1 + -----------------
                                                  1
                                       292 + -----------
                                                    1
                                             1 + -------
                                                 1 + ...

> con;

                         333  355  103993  104348  208341
               [3, 22/7, ---, ---, ------, ------, ------, ...]
                         106  113  33102   33215   66317

I tak różnica pomiędzy dokładną wartością liczby π a ostatnim z wyświetlonych ułamków (²⁰⁸³⁴¹/₆₆₃₁₇) wynosi tylko 0,1×10^-8

Jeżeli chcemy uzyskać przybliżenie ułamka łańcuchowego u do n-tego rzędu, należy użyć polecenia nthconver(u,n):

> nthconver(cfrac(Pi),3);

                                      355
                                      ---
                                      113

> cfrac(tan(x));

                                      x
               ------------------------------------------------
                                         2
                                        x
               1 - --------------------------------------------
                                           2
                                          x
                   3 - ----------------------------------------
                                             2
                                            x
                       5 - ------------------------------------
                                               2
                                              x
                           7 - --------------------------------
                                                 2
                                                x
                               9 - ----------------------------
                                                   2
                                                  x
                                   11 - -----------------------
                                                      2
                                                     x
                                        13 - ------------------
                                                        2
                                                       x
                                             15 - -------------
                                                           2
                                                          x
                                                  17 - --------
                                                       19 + ...

> nthconver(cfrac(tan(x)),1);

> nthconver(cfrac(tan(x)),2);