Maple :: ułamki

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 ab
  • Y = I gdy: a + b ≥ 1 oraz a < b

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

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 (208341/66317) wynosi tylko 0,1×10⁻⁸

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

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

                                      3 x
                                    -------
                                      2
                                    -x  + 3