Podstawy programu MAPLE

25. Programowanie

25.1. Podstawowe konstrukcje

Oferowane przez program MAPLE podstawowe konstrukcje są podobne do tych, które można znaleźć w innych językach programowania.

25.1.1. if/then/else/fi

Operacje warunkowe programuje się w MAPLE'u przy użyciu konstrukcji if ... then ... else ... fi jak w przykładzie poniżej:

> if 9/23<13/33 then 9/23 else 9/23 fi;

                                     9/23

Powyższą konstrukcję operacji warunkowych można uzupełnić o element elif:

> if a<b then 1 elif a>b then -1 else 0 fi;

W takim przypadku zostanie zwrócona wartość "+1" gdy a<b, wartość "-1" gdy a>b oraz "0" w każdym innym przypadku.

25.1.2. for/from/by/to/do/od

Jest to operacja powtarzania o ogólnej strukturze: for i from a to b by c do x od;. Operacja x wykonywana jest wtedy, gdy zmienna i początkowo równa a nie przyjmie wartości większej niż b. Przy każdym powtórzeniu zmienna i zwiększana jest o c.

> for i from 1 to 11 by 2 do i od;

                                       1

                                       3

                                       5

                                       7

                                       9

                                      11

25.1.3. for/form/by/while/do/od

To jest inna wersja operacji powtarzania. Jej ogólna struktura wygląda tak: for i from a by c while warunek do x od;. Operacja x wykonywana jest wtedy, gdy warunek jest spełniony, dla zmiennej i równej a, a+c, a+2*c itd.

> for i from 1 by 3 while i!<100 do print(i,i!); od;

                                     1, 1

                                     4, 24

Powtarzanie zostało tutaj przerwane po drugim kroku, ponieważ przy trzecim kroku i=7, 7! = 5040, a 5040>100.

25.1.4. for/in/do/od

Taka konstrukcja operacji powtarzania jest specyficzna dla programu MAPLE. Buduje się ją zgodnie z następującym wzorcem: for i in wyrażenie do x do. Tutaj zmienna i przyjmuje kolejne operandy wyrażenia i dla każdej wartości wykonywana jest operacja x.

> for i in 4*x^4-3*x^3+2*x^2-x+0 do print(i,i/2); od;

                                     4     4
                                  4 x , 2 x

                                             3
                                     3    3 x
                                 -3 x , - ----
                                           2

                                      2   2
                                   2 x , x

                                   -x, - x/2

Tę konstrukcję operacji powtarzania można wykorzystać równolegle z listami i zestawami, na przykład:

> s := {seq(k^2,k=-5..5)};

                           s := {0, 1, 4, 9, 16, 25}

> for i in s do sqrt(i); od;

                                       0

                                       1

                                       2

                                       3

                                       4

                                       5

25.1.5. Wymuszanie i przerywanie powtarzania

Poleceniem next wymuszamy zignorowanie dalszych poleceń wykonywanych w danym kroku operacji powtarzania i natychmiastowe wykonanie następnego powtórzenia (kroku). Natomiast polecenie break służy do przerwania wykonywania operacji powtarzania.

25.2. Procedury

Podstawową zaletą języków programowania jest możliwość tworzenia procedur automatyzujących wykonywane operacje. Stworzona procedura może zawierać szereg różnych poleceń, których wielokrotne wypisywanie byłoby niewygodne.

Jako przykład napiszmy procedurę podającą największy czynnik rozkładu liczny n na czynniki pierwsze:

> largestfactor := proc(n::integer)
op(nops(ifactor(n)),ifactor(n));
end;

  largestfactor := proc(n::integer) op(nops(ifactor(n)), ifactor(n)) end proc

i zobaczmy jak działa w dwóch przypadkach:

> largestfactor(2387);

                                      (31)

(bo 2387 = 7 * 11 * 31)

> largestfactor(118277523);

                                         2
                                     (23)

(bo 118277523 = 33 * 72 * 132 * 232)

Innym przykładem procedury może być:

> Prostokat:=proc(x,y) x*y end;

                     Prostokat := proc(x, y) x*y end proc

> Prostokat(4,6);

                                      24

Generalnie wartością zwracaną dowolnej procedury jest ostatnio obliczona wartość. Istnieje również możliwość jawnego wyjścia z procedury i jawnego zwrócenia wartości. Realizuje to funkcja RETURN. Jej składnia jest następująca:

RETURN ( blok wyrażeń )

gdzie: blok wyrażeń - oznacza sekwencję wyrażeń oddzielonych przecinkami (w szczególnym przypadku jedno wyrażenie). Funkcja RETURN może być wywołana w dowolnym miejscu bloku instrukcji deklaracji procedury. Przerywa ona natychmiast działanie procedury i zwraca wartość (wartości) zawarte w bloku wyrażeń. Wspomnianą procedurę Prostokat można zadeklarować więc również tak:

> Prostokat:=proc(x,y) RETURN(x*y) end;

                 Prostokat := proc(x, y) RETURN(x*y) end proc

> Prostokat(4,6);

                                      24

Funkcja RETURN może także zwracać więcej wartości:

> Prostokat:=proc(x,y)
RETURN(cat(`Pole=`,x*y),cat(`Obwód=`,2*x+2*y))
end;

Prostokat :=

    proc(x, y) RETURN(cat(`Pole=`, x*y), cat(`Obwód=`, 2*x + 2*y)) end proc

> Prostokat(4,6);

                               Pole=24, Obwód=20

Funkcja cat służy do sklejania ciągów znakowych i została użyta w celu uniknięcia przecinka pojawiającego się pomiędzy elementami sekwencji zwracanej przez funkcję RETURN.

Co gdy parametry to dwa zera lub jakaś liczba ujemna?

> Prostokat(-2,1);

                               Pole=-2, Obwód=-2

Prostokąt o takich wymiarach nie istnieje. W takim przypadku należałoby poinformować użytkownika o zaistniałym błędzie. Służy do tego funkcja ERROR. Jej składnia jest następująca:

ERROR ( blok wyrażeń )

Przerywa działanie procedury i informuje użytkownika o wystąpieniu błędu. Obok sygnalizacji błędu pojawiają się również dodatkowa informacja. Tą dodatkową informacją jest blok wyrażeń występujący przy wywołaniu funkcji ERROR. Procedure Prostokat można zmodyfikować następująco:

> Prostokat:=proc(x,y)
if (x<=0) or (y<=0) then
ERROR(`Prostokąt o takich wymiarach nie istnieje`) fi;
RETURN(cat(`Pole=`,x*y),cat(`Obwód=`,2*x+2*y)) end;

Prostokat := proc(x, y)
    if x <= 0 or y <= 0 then
        ERROR(`Prostokat o takich wymiarach nie istnieje`)
    end if;
    RETURN(cat(`Pole=`, x*y), cat(`Obwód=`, 2*x + 2*y))
end proc

> Prostokat(-2,4);

Error, (in Prostokat) Prostokat o takich wymiarach nie istnieje


Oczywiście są to ekstremalnie uproszczone przykłady procedur w MAPLE'u. Wiele predefiniowanych procedur w bibliotekach MAPLE'a składa się z setek linii i zawiera dodatkowe testowanie typów zmiennych, obsługę błędów oraz alternatywne algorytmy.

[koniec]