1. Wstęp1.1. Rozpoczynamy pracę z programem MAPLE

Maple jest kompletnym środowiskiem do rozwiązywania zaawansowanych problemów matematycznych z wykorzystaniem rachunku symbolicznego, obliczeń numerycznych z dowolną dokładnością, oraz bogatym zestawem sposobów wizualizacji matematycznej. Zastosowanie rachunku symbolicznego pozwala na rozwiązywanie problemów matematycznych w sposób dokładny, w przeciwieństwie do podejścia numerycznego, gdzie zazwyczaj otrzymuje się rozwiązania przybliżone.

Pierwszą rzeczą na jaką musisz zwrócić uwagę podczas pracy z programem Maple jest znak zgłoszenia > znajdujący się z lewej strony okna. Wszystkie instrukcje przekazywane do programu będą wpisywane po tym znaku zgłoszenia.

Dane wejściowe muszą być zakończone znakiem ; lub znakiem :. Znak ; informuje program MAPLE aby wykonał podane instrukcje, a wynik wyświetlił na ekranie, natomiast znak : oznacza, że wyrażenie ma być tylko wykonane, bez wyświetlania rezultatu jego pracy. Zobaczmy:

> a:=2;

a := 2

> b:=3:

MAPLE pamięta teraz obie zmienne: a = 2 oraz b = 3. Można teraz wykonać dodawanie a + b:

> a+b;

5

Ważnym znakiem specjalnym jest backslash \. Jest to znak kontynuacji: jeżeli wynik nie mieści się w jednej linijce, każda linijka zakończona jest właśnie tym znakiem:

> 100!

933262154439441526816992388562667004907159682643816214685929638952175999932\ 29915608941463976156518286253697920827223758251185210916864000000000000\ 000000000000

1.2. Komunikowanie się z użytkownikiem

Dane wejściowe i instrukcje (w programie MAPLE, jak również na tych stronach) oznaczane są kolorem czerwonym:

> Pi;

wyniki - kolorem niebieskim:3.1415

a komunikaty błędów - różowym:Error, numeric exception: division by zero

1.3. Uzyskiwanie pomocy

Niniejsze strony (zgodnie z tytułem) zawierają jedynie podstawy programu MAPLE. Często przedstawione funkcje posiadają o wiele więcej możliwości, niż zostało to tutaj opisane. W celu uzyskania dodatkowych informacji odnośnie interesującej funkcji należy użyć znaku zapytania ? przez nazwą funkcji:

> ?simplify

simplify - apply simplification rules to an expression

Calling Sequence simplify(expr)

simplify(expr, n1, n2, ...)

simplify(expr, assume=prop)

simplify(expr, symbolic)

Parameters expr - any expression

n1, n2,... - (optional) names, sets, or lists

prop - (optional) any property

Description- The simplify command is used to apply simplification rules to an expression....

Aby zakończyć czytanie pomocy należy nacisnąć przycisk Q na klawiaturze.

1.4. Kończenie pracy programu

W celu zakończenia sesji i wyjścia z programu należy użyć polecenia:

> quit;

Można też użyć kombinacji Ctrl + D

2. StałeW programie MAPLE zdefiniowanych jest domyślnie kilka stałych. Oto one (w kolejności alfabetycznej):bernoulli(n)

n-ta liczba Bernoulli'egoCatalan

stała Catalan'a, 0.9159655942..., zdefiniowana jako: sum((-1)^i/(2*i+1)^2,i=0..infinity)

euler(n)n-ta liczba Euler'a

exp(1)podstawa logarytmów naturalnych, e = 2.718281828...

fibonacci(n)

n-ta liczba Fibonacci'ego Fn, wyznaczona z zależności rekurencyjnej Fn = Fn-2 + Fn-1 gdzie F0=1 oraz F1=1. Użycie tej funkcji wymaga załadowania pakietu combinat (with(combinat))

gammastała Euler'a, γ = 0.5772156649..., zdefiniowana jako: limit(sum(1/i, i=1..n) - ln(n), n=infinity)

Ijednostka urojona i2 = -1

infinitynieskończoność

-infinityminus nieskończoność

Piπ = 3.141592654...

3. Zmienne, zestawy i listy3.1. Zmienne

Wszystkie operacje matematyczne wykonuje się na zmiennych. W programie MAPLE nie ma potrzeby specjalnego definiowania używanych zmiennych (nazwy, typu itd.). Dla programu MAPLE każdy ciąg liter i cyfr, nie rozpoczynający się jednak od cyfry i nie zawierający innych znaków, jest zmienną. Nazwy zmiennych mogą być więcej niż jednoznakowe.

Jednakże może się zdarzyć, że potrzebujemy korzystać ze stałych nie zdefiniowanych w programie. W takiej sytuacji możemy zadeklarować jakąś zmienną i przypisać jej potrzebną nam wartość, np. g = 9.81

Sprawdźmy najpierw czy program MAPLE czasem nie ma zadeklarowanej takiej stałej:

> g;

g

> about(g);

g: nothing known about this object

Przypisujemy zmiennej g wartość 9.81:> g:=9.81; g := 9.81

Tak przygotowaną zmienną (stałą) możemy użyć w innych obliczeniach:> g^2; 96.2361

Wartość zadeklarowanej zmiennej można oczywiście zmieniać podczas dalszej pracy:

> g:=10;

g := 10

> g^2;

100

> about(g); 10: All numeric values are properties as well as objects. Their location in the property lattice is obvious, in this case float.

W celu usunięcia z pamięci zmiennej g należy wpisać> g:='g'; g := g> about(g); g: nothing known about this object

3.2. Obliczenia

Program MAPLE jest tak skonstruowany, aby wykonywał wszystkie obliczenia możliwie najdokładniej i w jak najbardziej ścisły sposób. Może to powodować małe niedogodności:

> c:=sin(2);

c := sin(2)

Aby zmusić MAPLE'a do podania wartości liczbowej można użyć funkcji evalf:

> evalf(c);

0.9092974268

3.3. Zmienne zależne od innych zmiennych

Zmienne w programie MAPLE nie muszą być wartościami stałymi - mogą zawierać w sobie inne zmienne:

> a:=2*b;

a := 2 b

> 2*a + 5;

4 b + 5

3.4. Zestawy (ang. sets)

Zestawem w programie MAPLE nazywamy zbiór jedno- lub więcejelementowy zawierający niepowtarzające się elementy. Zestaw jest zawsze sortowany rosnąco.

> {2,1,3,2,1};

{1, 2, 3}

W celu połączenia dwóch zestawów można użyć takiej funkcji:

> {a,b,c,d} union {d,e,f};

{a, b, c, d, e, f}

a wyznaczenie części wspólnej - takiej funkcji:

> {1,2,3,4,5} intersect {2,4,6,8,10};

{2, 4}

Aby sprawdzić czy jakiś element (n) należy do danego zestawu

({w,e,d,n,e,s,d,a,y}) należy postąpić tak:

> member(n,{w,e,d,n,e,s,d,a,y});

true

Dodanie elementu(-ów) do zestawu:

> ze:={2,3,4,3,4,4};

ze := {2, 3, 4}

> ze:={op(ze),-9};

ze := {-9, 2, 3, 4}

3.5. Listy (ang. lists)

Listą w programie MAPLE nazywamy zbiór jedno- lub więcejelementowy zawierający elementy, które (w odróżnieniu od zestawu) mogą się powtarzać. Elementy listy pamiętane są w takiej kolejności, w jakiej zostały podane.

> l:=[a,b,c,d,e,f,g,h,i,j];

l := [a, b, c, d, e, f, g, h, i, j]

W celu poznania rozmiaru listy (ilości znajdujących się na niej elementów) używamy funkcji:

> nops(l);

10

Funkcja op służy do wybierania z listy konkretnych jej elementów:

> op(7,l);

g

> op(4..8,l);

d, e, f, g, h

> op(-2,l);

i

Dodanie elementu(-ów) do listy:

> li:=[2,3,4,3,4,4];

li := [2, 3, 4, 3, 4, 4]

> li:=[op(li),9];

li := [2, 3, 4, 3, 4, 4, 9]

3.6. Sekwencje

Za pomocą komendy seq tworzyć można ciągi skończone i wykorzystać je do tworzenia list lub zestawów:

> seq(k^2,k=1..100);

1, 4, 9, 16, 25, 36, 49, 64, 81, 100, 121, 144, 169, 196, 225, 256, 289, 324,

361, 400, 441, 484, 529, 576, 625, 676, 729, 784, 841, 900, 961, 1024,

1089, 1156, 1225, 1296, 1369, 1444, 1521, 1600, 1681, 1764, 1849, 1936,

2025, 2116, 2209, 2304, 2401, 2500, 2601, 2704, 2809, 2916, 3025, 3136,

3249, 3364, 3481, 3600, 3721, 3844, 3969, 4096, 4225, 4356, 4489, 4624,

4761, 4900, 5041, 5184, 5329, 5476, 5625, 5776, 5929, 6084, 6241, 6400,

6561, 6724, 6889, 7056, 7225, 7396, 7569, 7744, 7921, 8100, 8281, 8464,

8649, 8836, 9025, 9216, 9409, 9604, 9801, 10000

> [seq(k^2,k=-5..5)];

[25, 16, 9, 4, 1, 0, 1, 4, 9, 16, 25]

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

{0, 1, 4, 9, 16, 25}

Inną metodą definiowania sekwencji jest użycie operatora $:

> [k^2$k=-5..5];

[25, 16, 9, 4, 1, 0, 1, 4, 9, 16, 25]

> {k^2$k=-5..5};

{0, 1, 4, 9, 16, 25}

4. Typy zmiennych4.1. Definiowanie typu

W programie MAPLE nie ma potrzeby definiowania typu zmiennej. Program sam rozpoznaje jaka struktura zapamiętana jest pod daną zmienną.

4.2. Sprawdzanie typu

4.2.1. Identyfikacja typuDo sprawdzenia typu zmiennej wykorzystuje się polecenie whattype(z) podając jako argument nazwę zmiennej z, której typ chcemy zbadać. Na przykład:

> a;

a

> whattype(a);

symbol

> a:=1;

a := 1

> whattype(a);

integer

> a:=1.;

a := 1.

> whattype(a);

float

Funkcja whattype zwraca jedną z następujących wartości:

• *

• +

• .

• ..

• ::

• <

• <=

• <>

• =

• ^

• and

• array

• exprseq

• float

• fraction

• function

• hfarray

• indexed

• integer

• list

• not

• or

• procedure

• series

• set

• string

• symbol

• table

• uneval

• Array

• Matrix

• Vector[column]

• Vector[row]

4.2.2. Potwierdzenie typuInną funkcją służącą do określania typu jest funkcja type(expr,t), która zwraca wartość logiczną "prawda" jeżeli zmienna expr jest typu t. Oto lista nazw typów, które mogą być użyte w funkcji type: abstract_rootof algebraic algext algfun algnumext algnum And and anyfunc anyindex anything appliable applied arctrig array Array assignable atomic attributed BooleanOpt boolean builtin character ClosedIdeal CommAlgebra complexcons complex composition constant const cubic cx_infinity cx_zero dependent dictionary dimension disjcyc embedded_axis embedded_imaginary embedded_real equation evenfunc even expanded extended_numeric extended_rational facint filedesc finite float float[] form fraction freeof function global hfarray identical imaginary implies indexable indexedfun indexed infinity integer intersect in last_name_eval laurent linear listlist list literal local logical mathfunc matrix Matrix minus moduledefinition module monomial MVIndex name negative neg_infinity negint negzero NONNEGATIVE nonnegative nonnegint nonposint nonpositive nonreal nothing Not not numeric oddfunc odd operator OreAlgebra Or or package patfunc patindex patlist Point point polynom pos_infinity posint positive poszero prime procedure property protected quadratic quartic Queue radalgfun radalgnum radext radfunext radfun radical radnumext radnum range Range rational ratpoly ratseq realcons real_infinity relation RootOf rtable satisfies scalar SDMPolynom sequential series SERIES set sfloat ShortTermOrder SkewAlgebra SkewParamAlgebra

SkewPolynomial specfunc specified_rootof specindex sqrt Stack stack stdlib std string subset suffixed SymbolicInfinity symbol symmfunc table tabular taylor TermOrder TEXT trigh trig truefalse <= <> < || . ^ * + @ @@ = ! typefunc typeindex type undefined uneval union unit_name unit vector Vector verification verify with_unit xor zppoly

4.3. Konwersja typu

Do zmiany typu zmiennej (przekonwertowania) wykorzystuje się polecenie convert(expr,t), które konwertuje wyrażenie expr na typ t.

Nazwy typów, jakie mogą być użyte w tej funkcji to:Abel_RNF abs and arabic arraybase Bessel binary binomial boolean_functionbytes compose confrac conversion_table convert/'*'convert/'+' D decimal degrees DESoldiff dimensions disjcyc Ei equalityerfc erf exp expln expsincosfactorial FirstKind float fullparfrac function_rulesGAMMA global Heaviside hexadecimal hexhypergeom int Int iupac linearODElist listlist ln local mathornermatrix Matrix MeijerG metric mod2ModifiedMeijerG multiset name NormalForm numericprococtal or package parfrac permlistpiecewise PLOT3Doptions PLOToptions polar POLYGONSpolynom pwlist radians radical rationalratpoly RealRange record relation Riccatiroman RootOf SecondKind set signumsincos sqrfree StandardFunctions std stdlestring sum Sum surd symbolsystem table tan temperature to_special_functiontruefalse unit_free units vector Vectorwindchill xor y_x

5. Liczby całkowite5.1. Dzielenie liczb całkowitychiquo(m,n)

zwraca liczbę całkowitą q, która jest ilorazem liczb m przez n; m = n q + rirem(m,n)

zwraca liczbę całkowitą r będącą resztą z dzielenia liczby m przez n; m = n q + r

5.2. Rozkład liczby na czynniki pierwsze> ifactor(31722722304);

10 2 2 (2) (3) (7) (13) (29) (43)

> ifactors(31722722304);

[1, [[2, 10], [3, 1], [7, 2], [13, 2], [29, 1], [43, 1]]]

5.3. Inne funkcje na liczbach całkowitychigcd(x1,x2,x3...)

wyznacza największy wspólny dzielnik liczb x1, x2, x3...ilcm(x1,x2,x3...)

wyznacza najmniejszą wspólną wielokrotność liczb x1, x2, x3...

5.4. Liczby pierwszeisprime(n)

sprawdza czy liczba n jest liczbą pierwsząithprime(n)

wyznacza n-tą liczbę pierwsząprevprime(m)

zwraca największą liczbę pierwszą, ale nie większą niż liczba mnextprime(m)

zwraca najmniejszą liczbę pierwszą, ale nie mniejszą niż liczba m

6. Ułamki6.1. Funkcje podstawoweceil(x)

funkcja "sufit", zwraca najmniejszą liczbę całkowitą większą bądź równą xfloor(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 < 1Y = 1 gdy: a + b >= 1 oraz a >= bY = 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 (208341/66317) 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);

x

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

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

7. Wielomiany7.1. Definicja wielomianu> w := x^4-6*x^3+3*x^2+26*x-24;

4 3 2 w := x - 6 x + 3 x + 26 x - 24

Obliczenie wartości wielomianu w dla x = 4,5 wygląda tak:

> subs(x=4.5,w);

17.0625

7.2. Stopień wielomianu

Funkcja degree(w) zwraca stopień wielomianu w jednej zmiennej, natomiast funkcja degree(w,x) - stopień w zmiennej x wielomianu w wielu zmiennych. Analogicznie funkcje ldegree(w) oraz ldegree(w,x) zwracają najniższe potęgi zmiennej x w wielomianie w. Porównaj:

> p:=expand(x^2*(1-x^3)^4);

2 5 8 11 14 p := x - 4 x + 6 x - 4 x + x

> degree(p);

14

> ldegree(p);

2

> q:=-120*x^3-30*x^4+18*x^5+5*x^6+30*x*y^2;

3 4 5 6 2 q := -120 x - 30 x + 18 x + 5 x + 30 x y

> degree(q);

6

> ldegree(q);

3

> degree(q,x);

6

> ldegree(q,x);

1

> degree(q,y);

2

> ldegree(q,x);

0

7.3. Współczynniki wielomianu

Aby odczytać współczynnik stojący przy xn w wielomianie w należy użyć funkcji coeff(w,x^n) lub coeff(w,x,n) jak w przykładzie:

> p:=x*y^3+x^2*y^2+x^3*y;

3 2 2 3 p := x y + x y + x y

> coeff(p,x^2);

2 y

Funkcja coeffs(w,x) wypisuje wszystkie współczynniki wielomiany w stojące przy kolejnych potęgach zmiennej x

> p:=x*y^3+x^2*y^2+x^3*y;

3 2 2 3 p := x y + x y + x y

> coeffs(p,x);

3 2 y , y , y

> q:=-5+119/6*x-30*x^2+65*3*x^3-15/2*x^4+x^5;

2 3 4 5 q := -5 + 119/6 x - 30 x + 195 x - 15/2 x + x

> coeffs(q,x);

-5, 119/6, 1, -15/2, -30, 195

7.4. Grupowanie wyrazów

W celu zgrupowania współczynników wielomianu w stojących przy tej samej potędze

zmiennej x należy użyć funkcji cellect(w,x) jak następuje:

> p:=9+8*x+7*x^2+6*y+5*x*y+4*x^2*y+3*y^2+2*x*y^2+x^2*y^2;

2 2 2 2 2 2 p := 9 + 8 x + 7 x + 6 y + 5 x y + 4 x y + 3 y + 2 x y + x y

> collect(p,x);

2 2 2 2 (4 y + 7 + y ) x + (8 + 5 y + 2 y ) x + 9 + 3 y + 6 y

> collect(p,y);

2 2 2 2 (3 + 2 x + x ) y + (6 + 5 x + 4 x ) y + 9 + 8 x + 7 x

7.5. Rozkład wielomianu> factor(w);

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

Aby zwinąć wielomian:

> expand(%);

4 3 2 x - 6 x + 3 x + 26 x - 24

Drugi argument wskazuje na dziedzinę, w której dokonujemy rozkładu:

> factor(x^2+1);

2 x + 1

> factor(x^2+1, complex);

(x + 1.000000000 I) (x - 1. I)

7.6. Sprawdzenie wykonalności dzielenia wielomianów

Dzielenie wielomianów w1 przez w2 o współczynnikach wymiernych realizuje się poprzez użycie funkcji divide(w1,w2,'q'). Funkcja zwraca wartość logiczną "prawda", jeśli dzielenie jest wykonalne. Jeśli podamy dowolną nazwę jako trzeci argument (q), to w przypadku wykonalności dzielenia, będzie mu przyporządkowany iloraz wielomianów:

> divide(2*x^3-x^2+2*x-3,x-1);

true

> divide(2*x^3-x^2+2*x-3,x-1,'q');

true

> q;

2 2 x + x + 3

7.7. Wynik z dzielenia wielomianów

Funkcja quo(w2,w2,x,'q') zwraca iloraz dwóch wielomianów w1 oraz w2 jednej zmiennej x. Jeśli ostatnim argumentem będzie nazwa (q), to zostanie jej przypisana

reszta z dzielenia wielomianów:

> quo(x^3+2*x+1,x^2+1,x);

x

> quo(x^3+2*x+1,x^2+1,x,'q');

x

> q;

1 + x

7.8. Reszta z dzielenia wielomianów

Funkcja rem(w1,w2,x,'q') zwraca resztę z dzielenia dwóch wielomianów w1 oraz w2 jednej zmiennej x. Jeśli podamy jeszcze nazwę jako ostatni (q) argument, to zostanie jej przyporządkowany iloraz wielomianów:

> rem(x^3+2*x+1,x^2+1,x);

x + 1

> rem(x^3+2*x+1,x^2+1,x,'q');

x + 1

> q;

x

7.9. Dopełnianie do kwadratu

Często mając wielomian stopnia drugiego chcemy zwinąć go do pełnego kwadratu (plus jakaś reszta). Pomoże nam w tym następujące polecenie completesquare znajdujące się w pakiecie student:

> with(student);

[D, Diff, Doubleint, Int, Limit, Lineint, Product, Sum, Tripleint, changevar,

completesquare, distance, equate, integrand, intercept, intparts, leftbox,

leftsum, makeproc, middlebox, middlesum, midpoint, powsubs, rightbox,

rightsum, showtangent, simpson, slope, summand, trapezoid]

> completesquare(x^2+x+1);

2 (x + 1/2) + 3/4

7.10. Wydzielanie z wielomianu

Funkcja compoly(w,x) wykonuje operację wydzielenia z wielomianu w zmiennej x takiego "podwielomianu" q(x), że dla zwracanego wielomianu p zachodzi, że: p(q(x)) = w(x). Dla przykładu popatrz na wielomian: w = 16 - 40x2 + 48x4 - 28x6 + 7x8

> w:=16-40*x^2+48*x^4-28*x^6+7*x^8;

2 4 6 8 w := 16 - 40 x + 48 x - 28 x + 7 x

> p:=compoly(w,x);

4 2 2 p := 7 x + 3 + 6 x , x = -1 + x

czyli p = 7x + 3 +6x4 a q(x) = -1 + x2

8. Wyrażenia algebraiczne8.1. Rozwijanie wyrażeń

Wyrażenia algebraiczne, trygonometryczne, logarytmiczne i inne rozwijamy przy pomocy funkcji expand(f), na przykład:

> expand((x-1)*(x+2));

2 x + x - 2

> expand((x-a-b)*(x+2));

2 x + 2 x - a x - 2 a - b x - 2 b

8.2. Rozwijanie z warunkami

Podając dodatkowe wyrażenia jako kolejne argumenty funkcji expand zapobiegamy ich rozwijaniu. Porównaj:

> expand((x+y)*(u-w^2));

2 2 x u - x w + y u - y w

> expand((x+y)*(u-w^2),u-w^2);

2 2 (u - w ) x + (u - w ) y

8.3. Upraszczanie wyrażeń

Funkcja normal(f) upraszcza wyrażenia wykonując na przykład redukcję wyrazów podobnych i skracanie, na przykład:

> normal(a*b-a*(b+1));

-a

> normal((a^3-b^3)/(a-b));

2 2 a + a b + b

> normal(x/(x+1) + 1/x + 1/(1+x));

x + 1 ----- x

8.4. Upraszczanie wyrażeń

Funkcja simplify(f) upraszcza wyrażenia wykonując odpowiednie prawa działań,

na przykład:

> simplify((2^3)^2-sqrt(4*7-19));

61

> simplify(((x+y)^2*(x-y)^3)^2);

4 6 (x + y) (x - y)

Dodatkowy argument wskazuje na rodzaj wyrażeń:

> simplify(cos(x)^2-sin(x)^2,trig);

2 2 cos(x) - 1

8.5. "Kombinowanie" wyrażeń

Funkcja combine(expr,name) służy do przekształcania wyrażenie expr z zastosowaniem reguł określonych jako name. Regułami mogą być: exp, ln, power, Psi, trig. Na przykład wyrażenie ex esin(x) sin4(x) można przekształcać tak: Bez stosowania reguł otrzymujemy:

> combine(exp(x)*exp(sin(x))*sin(x)^4);

3/8 exp(x + sin(x)) + 1/8 exp(x + sin(x)) cos(4 x)

- 1/2 exp(x + sin(x)) cos(2 x)

3/8 ex+sin(x) + 1/8 ex+sin(x) cos(4x) - 1/2 ex+sin(x) cos(2x). Po wymuszeniu przekształceń ze względu na eksponensy otrzymujemy:

> combine(exp(x)*exp(sin(x))*sin(x)^4,exp);

4 sin(x) exp(x + sin(x))

sin4(x) ex+sin(x). Przekształcając ze względu na funkcje trygonometryczne:

> combine(exp(x)*exp(sin(x))*sin(x)^4,trig);

3/8 exp(x) exp(sin(x)) + 1/8 exp(x) exp(sin(x)) cos(4 x)

- 1/2 exp(x) exp(sin(x)) cos(2 x)

3/8 ex esin(x) + 1/8 ex esin(x) cos(4x) - 1/2 ex esin(x) cos(2x). No i na koniec jeszcze jeden przykład:

> combine(exp(x)*exp(sin(x))*sin(x)^4,trig,exp);

3/8 exp(x + sin(x)) + 1/8 exp(x + sin(x)) cos(4 x)

- 1/2 exp(x + sin(x)) cos(2 x)

3/8 ex+sin(x) + 1/8 ex+sin(x) cos(4x) - 1/2 ex+sin(x) cos(2x)

8.6. Obliczanie wartości wyrażenia w punkcie

Weźmy takie wyrażenie:

> w:=(2*a*x^2-3)/(x-a);

2 2 a x - 3 w := ----------

x - a

Możemy obliczyć jego wartość dla zadanej wartości parametru a i/lub w zadanym punkcie x. Ile wynosi wartość tego wyrażenia dla a=0? Aby się tego dowiedzieć trzeba użyć funkcji subs(x1=a1,x2=a2,...,w), która oblicza wartość wyrażenia w z warunkami x1=a1, x2=a2... gdzie xi są zmiennymi (parametrami) wyrażenia w, a ai ich wartościami.

> subs(a=0,w);

- 3/x

A dla dowolnego a i x=5?

> subs(x=5,w);

50 a - 3 -------- 5 - a

Możemy też chcieć znać wartość jednocześnie dla a=0 i x=5:

> subs(a=0,x=5,w);

-3/5

Oczywiście równoważne są następujące trzy zapisy:

> subs(a=0,x=5,w);

> subs(x=5,subs(a=0,w));

> subs(a=0,subs(x=5,w));

8.7. Podstawienia

Funkcji subs(x1=a1,x2=a2,...,w) można też używać w celu dokonywania podstawień. Weźmy takie wyrażenie:

> w:=1/2*(3*x^2-5*x);

2 w := 3/2 x - 5/2 x

i dokonajmy trzech (przykładowych) podstawień: cos(t) zamiast x, z zamiast x2 oraz x zamiast x2:

> subs(x=cos(t),w);

2 3/2 cos(t) - 5/2 cos(t)

> subs(x^2=z,w);

3 z 5 x --- - --- 2 2

> subs(x^2=x,w);

-x

8.8. Określanie precyzjievalf(1/3+1/4);

0.5833333333

evalf(1/3+1/4,4);

0.5833

9. Funkcje predefiniowane9.1. Działaniaa+b

suma liczb a i ba-b

różnica liczb a i ba*b

iloczyn liczb a i ba/b

iloraz liczb a i ba^b

b-ta potęga aa!

silnia liczby a

9.2. Funkcje podstawoweabs(x)

wartość bezwzględna (moduł) liczby xsqrt(x)

pierwiastek kwadratowy z xexp(x)

funkcja wykładnicza ex

ln(x)logarytm naturalny x

log[n](x)logarytm x przy podstawie n

log10(x)logarytm x przy podstawie 10

a mod bdzielenie a modulo b

max(x1,x2,x3...)zwraca największą wartość spośród wymienionych x1, x2, x3...

min(x1,x2,x3...)zwraca najmniejszą wartość spośród wymienionych x1, x2, x3...

9.2.1. Funkcje "schodkowe"csgn(x)

zwraca znak x-a zgodnie z następującymi zasadami:x = 0 csgn(x) = 1Re(x) > 0 csgn(x) = 1Re(x) = 0 oraz Im(x) > 0 csgn(x) = 1Re(x) < 0 csgn(x) = -1Re(x) = 0 oraz Im(x) < 0 csgn(x) = -1inne przypadki csgn przyjmuje wartość nieokreśloną

signum(x)zwraca znak x-a: zwraca -1 dla x < 0, zwraca +1 dla x >= 0; jeżeli x jest liczbą zespoloną zwracana jest wartość x/abs(x)

Dirac(x)

funkcja δ Diraca, przyjmuje wartość 0 dla wszystkich x-ów różnych od zera oraz nieskończoność - dla x = 0

Heaviside(x)funkcja schodkowa Heaviside'a, przyjmuje wartość 0 dla x < 0 oraz wartość 1 dla x >= 0

9.3. Funkcje trygonometryczne

9.3.1. ... podstawowesin(x)

sinus xcos(x)

cosinus xtan(x)

tangens xcot(x)

cotangens xsec(x)

secans xcsc(x)

cosecans x

9.3.2. ... hiperbolicznesinh(x)

sinus hiperboliczny xcosh(x)

cosinus hiperboliczny xtanh(x)

tangens hiperboliczny xcoth(x)

cotangens hiperboliczny xsech(x)

secans hiperboliczny xcsch(x)

cosecans hiperboliczny x

9.3.3. ...odwrotnearcsin(x)

arcus sinus xarccos(x)

arcus cosinus xarctan(x)

arcus tangens xarccot(x)

arcus cotangens xarcsec(x)

arcus secans xarccsc(x)

arcus cosecans x

9.3.4. ...hiperboliczne odwrotnearcsinh(x)

arcus sinus hiperboliczny xarccosh(x)

area cosinus hiperboliczny xarctanh(x)

arcus tangens hiperboliczny xarccoth(x)

arcus cotangens hiperboliczny xarcsech(x)

arcus secans hiperboliczny xarccsch(x)

arcus cosecans hiperboliczny x

9.4. Funkcje całkoweEi(n,x)

eksponent całkowy, zdefiniowany jako: int(exp(-x*t) / t^n, t=1..infinity)

Li(n,x)logarytm całkowy

Si(x)sinus całkowy, zdefiniowany jako: int(sin(t) / t, t=0..x)

Ci(x)cosinus całkowy, zdefiniowany jako: gamma + ln(I*x) - I*Pi/2 + int((cos(t) - 1) / t, t=0..x)

Ssi(x)przesunięty sinus całkowy, zdefiniowany jako: Si(x) - Pi/2

Shi(x)sinus hiperboliczny całkowy, zdefiniowany jako: int(sinh(t) / t, t=0..x)

Chi(x)cosinus hiperboliczny całkowy, zdefiniowany jako: gamma + ln(x) + int((cosh(t) - 1) / t, t=0..x)

FresnelS(x)sinus całkowy Fresnel'a, zdefiniowana jako: int(sin(Pi/2*t^2), t=0..x)

FresnelC(x)cosinus całkowy Fresnel'a, zdefiniowana jako: int(cos(Pi/2*t^2), t=0..x)

9.5. Funkcje specjalne

9.5.1. Funkcje Airy'egoAi(z)

funkcja falowa Airy'ego "Ai", jedno z liniowo niezależnych rozwiązań w równania różniczkowego: w" - wz = 0

Bi(z)funkcja falowa Airy'ego "Bi", jedno z liniowo niezależnych rozwiązań w równania różniczkowego: w" - wz = 0

9.5.2. Funkcje Bessel'aBesselI(v,x)

zmodyfikowana funkcja Bessel'a pierwszego rodzaju, zdefiniowana jako: x2 y" + x y' - (x2+v2)*y = 0 gdzie y=y(x)

BesselJ(v,x)funkcja Bessel'a pierwszego rodzaju, zdefiniowana jako: x2 y" + x y' + (x2+v2)*y = 0 gdzie y=y(x)

BesselK(v,x)zmodyfikowana funkcja Bessel'a drugiego rodzaju, zdefiniowana jak:

BesselIBesselY(v,x)

funkcja Bessel'a drugiego rodzaju, zdefiniowana jak: BesselJ

9.5.3. Funkcje ΓGAMMA(x)

funkcja Γ, zdefiniowana jako: int(exp(-t) * t^(x-1), t=0..infinity)Beta(z1,z2)

funkcja Beta, zdefiniowana jako (GAMMA(z1) * GAMMA(z2)) / GAMMA(z1 + z2)

Psi(x)funkcja digamma, zdefiniowana jako: diff(ln(GAMMA(x)),x) = diff(GAMMA(x),x) / GAMMA(x)

9.5.4. Inne funkcje specjalnedawson(z)

funkcja całkowa Dawson'a, zdefiniowana jako: exp(-z^2) * int(exp(t^2), t=0..z)

dilog(z)funkcja dilogarytmiczna, zdefiniowana jako: int(ln(t) / (1-t), t=1..z)

erf(z)error function - całka prawdopodobieństwa, zdefiniowana jako: 2 / sqrt(Pi) * int(exp(-t^2), t=0..z)

erfc(z)komplementarna error function, zdefiniowana jako: 1 - 2 / sqrt(Pi) * int(exp(-t^2), t=0..z) lub jako 1 - erf(z)

harmonic(z)funkcja harmoniczna, zdefiniowana jako: sum(1/i, i=1..n)

Zeta(z)funkcja ζ Riemann'a, zdefiniowana jako: sum(1/(i^z), i=1..infinity)

10. Funkcje definiowane przez użytkownika10.1. Definicja funkcji

Funkcję jednej zmiennej (na przykład: f(x) = x2) definiuje się następująco:

> f:=x->x^2;

2 f := x -> x

Można obliczyć wartość tej funkcji w punkcie, na przykład w x = 4:

> f(4);

16

Funkcję wielu zmiennych (lub zmiennych i parametrów) definiuje się w następujący sposób:

> g:=(x,a,b)->sqrt(x-b)/(X^2-a^2);

sqrt(x - b) g := (x, a, b) -> ----------- 2 2 X - a

> g(1,a,b);

1/2 (1 - b) ---------- 2 2 X - a

10.2. Funkcja na zbiorze argumentów

Funkcja map(f,{x1,x2,x3,...}) oblicza wartość funkcji f tylko w punktach określonych w zestawie {...}, tzn. tylko w punktach x1, x2 itd. W takiej sytuacji zwracana jest tablica wartości: {f(x1), f(x2)...}

> map(f,{1,2,3,4});

{1, 4, 9, 16}

Można też wykonać wykonać szybkie podstawienie przed obliczeniem wartości funkcji. Na przykład dokonajmy podstawienia 1/x na miejsce zmiennej x:

> map(x->x^(-1),{a,b,c,d});

{1/a, 1/b, 1/c, 1/d}

10.3. Funkcja zadana przedziałami

Funkcje w programie MAPLE można zadawać przedziałami. Jako przykład weźmy funkcję taką:

zakres argumentu x wartość funkcji f(x) w tym zakresie] -inf; 1 [ -1[ 1; 2 [ 1[ 2; +inf [ 3

Definiuje się ją poprzez polecenie:

> f := x -> piecewise( x<1, -1, x<2, 1, 3 );

f := x -> piecewise(x < 1, -1, x < 2, 1, 3)

Możemy wykonać wykres tej funkcji w celu poznania jej przebiegu:

> plot(f(x), x=0..3)

3 + AAAAAAAAAAAAAAAAAAAAAAAAAA + A + A + A + A2 + A + A + A + A + A1 + AAAAAAAAAAAAAAAAAAAAAAAAA + A + A + A + A +-+--+-+--+-+--+-+--+-+--*-+--+-+--+-+-+--+-+--+-+--+-+--+-+--+-+--+-+--+-+0 + A

+ 0.5 1 1.5 2 2.5 3 + A + A-1*AAAAAAAAAAAAAAAAAAAAAAAAA

10.4. Wyrażenie funkcyjne

Jest jeszcze inna metoda wykonywania operacji matematycznych na funkcjach, a właściwie na wyrażeniach funkcyjnych. Wyrażeniem funkcyjnym nazywam zmienną zależną od innych zmiennych, na przykład:

> f:=(4*x+1)/(x^4-13*x^2+36);

4 x + 1 f := --------------- 4 2 x - 13 x + 36

Wartość tego wyrażanie można wyznaczyć na dwa sposoby. Pierwszym z nich jest użycie funkcji subs:

> subs(x=1/2,f);

16 --- 175

> evalf(subs(x=1/2,f));

0.09142857143

Drugą metodą jest zdefiniowanie zmiennej x i przypisanie jej wartości 1/2:

> x:=1/2;

x := 1/2

> f;

16 --- 175

11. Składanie funkcji11.1. Operator @

Operator @ reprezentuje złożenie dwóch funkcji: jeżeli f i g są funkcjami, to złożenie (f@g)(x) jest obliczane jako: f(g(x)). Na przykład:

> f:=x->(4*x-2)/(7*x+1); g:=x->(x+2)/(4-7*x);

4 x - 2 f := x -> ------- 7 x + 1

x + 2 g := x -> ------- 4 - 7 x

> (f@g)(x);

4 (x + 2) --------- - 2

4 - 7 x ------------- 7 (x + 2) --------- + 1 4 - 7 x

> simplify(%);

x

> (g@f)(x);

4 x - 2 ------- + 2 7 x + 1 --------------- 7 (4 x - 2) 4 - ----------- 7 x + 1

> simplify(%);

x

Z tego przykładu widzimy, że złożenie f@g jest równe złożeniu g@f, czyli możemy powiedzieć, że funkcje f i g są wzajemnie odwrotne.

11.2. Operator @@

Symbol @@ reprezentuje wielokrotne złożenie funkcji. Jeżeli f jest funkcją, to (f@@n)(x) odpowiada n-krotnemu złożeniu funkcji f: f(f(...f(x)...)) = f(n)(x)

12. Wyrażenia wymierne12.1. Przykład wyrażenia wymiernego> f:=(4*x+1)/(x^4-13*x^2+36);

4 x + 1 f := --------------- 4 2 x - 13 x + 36

> ff:=factor(f);

4 x + 1 ff := ------------------------------- (x - 2) (x - 3) (x + 3) (x + 2)

12.2. Licznik wyrażenia> numer(f);

4 x + 1

12.3. Mianownik wyrażenia> denom(f);

4 2 x - 13 x + 36

> denom(ff);

(x - 2) (x - 3) (x + 3) (x + 2)

12.4. Usuwanie niewymierności z mianownika

Weźmy takie wyrażenie wymierne, zawierające niewymierność w mianowniku (w tym przypadku pierwiastek trzeciego stopnia z 2):

> 1 / ( 2 + root[3](2) );

1 ---------- (1/3) 2 + 2

Niewymierność usuwa się stosując funkcję rationalize:

> rationalize( % );

1/3 2/3 2 2 2/5 - ---- + ---- 5 10

13. Rozkład wyrażenia wymiernego na ułamki proste13.1. Zadanie

Weźmy taką funkcję wymierną zmiennej x:

> f:=(4*x+1)/(x^4-13*x^2+36);

4 x + 1 f := --------------- 4 2 x - 13 x + 36

13.2. Metoda pierwsza

Rozłóżmy mianownik wyrażenia f:> ff:=factor(f); 4 x + 1 ff := ------------------------------- (x - 2) (x - 3) (x + 3) (x + 2)

Wiemy teraz, że nasze wyrażenie f można zapisać w postaci następującej:

> p:=A/(x+2)+B/(x+3)+C/(x-3)+D/(x-2);

A B C D p := ----- + ----- + ----- + ----- x + 2 x + 3 x - 3 x - 2

gdzie A, B, C oraz D są poszukiwanymi współczynnikami rozkładu. Teraz wystarczy tylko utworzyć równanie ff = p.

> r:=ff=p;

4 x + 1 A B C D r := ------------------------------- = ----- + ----- + ----- + ----- (x - 2) (x - 3) (x + 3) (x + 2) x + 2 x + 3 x - 3 x - 2

> rr:=simplify((r*mian));

3 2 3 2rr := 4 x + 1 = A x - 2 A x - 9 A x + 18 A + B x - 3 B x - 4 B x + 12 B

3 2 3 2 + C x + 3 C x - 4 C x - 12 C + D x + 2 D x - 9 D x - 18 D

Rozwiązania tego równania ff = p są poszukiwanymi współczynnikami:

> solve({subs(x=-2,rr),subs(x=-3,rr),subs(x=3,rr),subs(x=2,rr)},{A,B,C,D});

13 11 -7 -9 {C = --, B = --, A = --, D = --} 30 30 20 20

13.3. Metoda druga

Można też trochę inaczej. Wydzielmy najpierw licznik i mianownik tego wyrażenia:

> l:=numer(f);

l := 4 x + 1

> mian:=denom(f);

4 2 mian := x - 13 x + 36

Zastosujmy funkcję factor do rozłożenia mianownika:

> factor(mian);

(x - 2) (x - 3) (x + 3) (x + 2)

Wiemy już na jakie ułamki można rozłożyć nasze wyrażenie. Zapiszmy więc:

> ulamki:=A/(x-2)+B/(x-3)+C/(x+2)+D/(x+3);

A B C D ulamki := ----- + ----- + ----- + ----- x - 2 x - 3 x + 2 x + 3

I dalej:

> p:=map(x->factor(mian)*x,ulamki);

p := (x - 3) (x + 3) (x + 2) A + (x - 2) (x + 3) (x + 2) B

+ (x - 2) (x - 3) (x + 3) C + (x - 2) (x - 3) (x + 2) D

> solve({subs(x=2,l=p),subs(x=3,l=p),subs(x=-2,l=p),subs(x=-3,l=p)},{A,B,C,D});

13 11 -7 -9 {B = --, D = --, C = --, A = --} 30 30 20 20

14. Wykresy14.1. Wykresy pojedynczych funkcji> f:=x->x^2;

2 f := x -> x

> plot(f(x),x=-3..3);

A + A AA + AA A 8 + A A + A AA + A A + A A + A A 6 + A A + A AA + AA AA + AA AAA 4 + AA AA + AA A + A AA + AA AA + AA AA 2 + AA AAA + AAA AAAA + AAAA AAAAA + AAAAA +-+--+-+--+-+--+-+--+-+--+-+--+-***********-+--+-+--+-+--+-+--+-+--+-+--+-+ -3 -2 -1 1 2 3

> plot(exp(-0.2*x)*sin(x),x = 0..8*Pi);

+ AAA + A A + AA A0.6 A A + A AA +AA A0.4A A +A AA +A A +A A AA0.2A A AAAAAA * AA A AA * A A AA AAAAAA *--+--+--*--+--+--*--+--+-+**+--+--+***--+--*****-+-***********************0 + AA A AAA AA AAAA + A 5 A 10AAAAA 15 20 25 + A A-0.2 A AA + A AA + AA A-0.4 AAA

14.2. Definiowanie zakresu na osi OY> plot(tan(x),x = -Pi/2..Pi/2);

+ A 3e+08 + A + A + A 2e+08 + A + A + A 1e+08 + A + A + A *************************************************************************** A + -1.5 -1 -0.5 + 0.5 1 1.5 A -1e+08 + A + A + A -2e+08 + A + A + A -3e+08 + A +

> plot(tan(x),x = -Pi/2..Pi/2,y=-6..6);

6 + A + A + A 4 + A + A + A + AAA 2 + AAA + AAAAAA + AAAAAAAAAA --+-+-+--+-+-+--+-+-+--+-+--+-+*************+-+--+-+--+-+-+--+-+-+--+-+-+-- -1.5 -1 AA-0.5AAAA 0 + 0.5 1 1.5 AAAAAA + AAAA -2 + AAA + A + AA + A -4 + A + A + A -6 +

14.3. Wykresy kilku funkcji> plot({sin(x),cos(x)},x=0..2*Pi);

1 *BBB AAAAAAAA BBBBB + BBB AAAA AAAA BBB + BB AA AAA BB + A** AA BB + AA BB AA BBB0.5 AA BB AA BB + A BB A BB + AA B AA B + AA B AA B +AA BB AA B *-+--+-+-+--+-+-+-**-+--+-+-+--+-+-+***-+-+--+-+-+--+-+**+-+-+--+-+-+--+-+*0 + B AA BB AA + 1 B 2 3 AA 4 B 5 6A + B AA B AA + BB A BB A-0.5 BB AA BB AA + BBB AA BBB AA + BB A** AAA + BBB BB AAA AAA + BBB BBB AAA AAAA-1+ BBBBBBBBB AAAAAAAA

14.4. Nieciągłości> plot((x-1)/(x+2), x = -8..6, y=-8..8);

A A +8 A A + AA A +6 A A + A A + AAA A +4 AAAA A + AAAAAAAA A +2 AAAAAAAAAAAAAAA A + A + AAAAAAAAAAAAAAAAA +-+-+-+-+--+-+-+-+-+-+-+-+-+--+-*-+-+-+-+-+-**************-+-+-+--+-+-+-+-+ -8 -6 -4 -2 AAA*0 2 4 6 A AA + A AA +-2 A AA + A A +-4 A AA + A A + A A +-6

A A + AAA +-8

> plot((x-1)/(x+2), x = -8..6, y=-8..8, discont=true);

A +8 A + AA +6 A + A + AA +4 AAAA + AAAAAAAA +2 AAAAAAAAAAAAAAA + + AAAAAAAAAAAAAAAAA +-+-+-+-+--+-+-+-+-+-+-+-+-+--+-+-+-+-+-+-+***************-+-+-+--+-+-+-+-+ -8 -6 -4 -2 AAA*0 2 4 6 AAA + AA +-2 A + A +-4 A + A + A +-6 A + A +-8

14.5. Wykresy punktowe> plot([[1,-3],[2,-2.5],[3,-1],[4,0],[5,2],[6,4],[7,3.5],[8,1]],style = point,symbol=circle);

4 + A + A +3 + + +2 + A + +1 + A + ++-+-+-+--+-+-+-+-+-+-+-+-+-+-+-*-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+--+-+-+-0 + +1 2 3 4 5 6 7 8-1+ A + +-2+ + + A-3+A

> l := [[ n, (2*n^2+n-1)/(3*n^2-2*n+1)] $n=1..30];

10 35 77 52 45l := [[1, 1], [2, 1], [3, --], [4, --], [5, 9/11], [6, --], [7, --], [8, --],

11 41 97 67 59

85 209 14 299 175 135 232 [9, ---], [10, ---], [11, --], [12, ---], [13, ---], [14, ---], [15, ---], 113 281 19 409 241 187 323

527 99 665 370 91 451 [16, ---], [17, ---], [18, ---], [19, ---], [20, ---], [21, ---], 737 139 937 523 129 641

989 180 1175 637 459 742 [22, ----], [23, ---], [24, ----], [25, ---], [26, ---], [27, ----], 1409 257 1681 913 659 1067

1595 95 1829 [28, ----], [29, ---], [30, ----]] 2297 137 2641

> plot(l, x=0..20, style=point,symbol=circle);

1 + A A + +0.95 + +0.9 A + + +0.85 A + + A0.8 A + + A A0.75 A + A A + A A A A + A A A A A0.7+-++-++-++-++-++-++-++-++-++-++-++-+++-++-++-++-++-++-++-++-++-++-++-++-++ 0 2 4 6 8 10 12 14 16 18 20

14.6. Wykresy parametryczne> plot( [ cos(t/2), sin(t), t=0..4*Pi ] );

AAAAAAAAA 1 + AAAAAAAAA AAA AAA + AAA AAA AA AAA + AAA AA A AAA + AAA A A AA + AA A

A AA 0.5 + AAA A A AA + AA A A AA + AA A A AA + AA A A A + A A -*---+--+---+---+--+---+--+---+--+--***--+--+---+--+---+--+---+--+---+---*- A A +AA A -1A -0.5 AA + AA 0.5 A1 A AA + AA A A AAA + AA A A AA -0.5 + AAA A A AA + AA A A AAA + AA A AA AAA + AAA AA AAA AAA + AAA AAA AAAAAAAAA -1 + AAAAAAAAA

14.7. Wykresy w zmiennych biegunowych> polarplot( sin(3*theta), theta=0..2*Pi );

> polarplot(theta, theta=0..4*Pi);

> polarplot( [ r-expr, angle-expr, parameter=range ] )

14.8. Wykres parametryczny w zmiennych biegunowych> polarplot( [ sin(t), cos(t), t=0..2*Pi ] );

> polarplot( [ r, sin(3*r), r=0..7 ] );

15. Rozwiązywanie równań i nierówności

15.1. Definicja równania (nierówności)> r := 2*x+12 = 3*x+1;

r := 2 x + 12 = 3 x + 1

15.2. Prawa i lewa strona równościlhs(r)

zwraca lewą stronę równania: lhs(r) = 2 x + 12rhs(r)

zwraca prawą stronę równania: rhs(r) = 3 x + 1

15.3. Rozwiązywanie> solve(r,x);

Znajduje symboliczne rozwiązanie równania (nierówności) lub układu równań (nierówności):

> solve(r,x);

11Możemy sprawdzić równanie za pomocą funkcji subs, która umożliwia podstawianie wyrażeń do innych wyrażeń: > subs(x = %,r); 34 = 34 Przypomnijmy, że procent % oznacza rezultat ostatniej komendy.> solve(x^4-2*x^3=1-x^2,x);

1/2 1/2 1/2 1/2 5 5 1/2 + 1/2 I 3 , 1/2 - 1/2 I 3 , 1/2 + ----, 1/2 - ---- 2 2

> solve(x^2-3*x+2<0,x);

RealRange(Open(1), Open(2))

Jeśli w równaniu występuje wiele symboli, to trzeba określić, względem której zmiennej rozwiązujemy równanie.

> solve(a*x^2+b*x+c=0,x);

2 1/2 2 1/2 b - (b - 4 a c) b + (b - 4 a c) - -------------------, - ------------------- 2 a 2 a

> solve(a*x^2+b*x+c=0,b);

2 a x + c - -------- x

15.4. Układy równań (nierówności)> r1:= x+2*y-4*z=1;

r1 := x + 2 y - 4 z = 1

> r2:= x+4*y-2*z=2;

r2 := x + 4 y - 2 z = 2

> r3:= x-y+z=1;

r3 := x - y + z = 1

> solve({r1, r2, r3},{x, y, z});

{z = 3/16, y = 5/16, x = 9/8}Sprawdzamy rozwiązanie: > subs(%,{r1,r2,r3}); {1 = 1, 2 = 2}

Można przypisać wyznaczone wartości zmiennym x, y oraz z. > solve({r1, r2, r3},{x, y, z}); {z = 3/16, y = 5/16, x = 9/8} > assign(%); Teraz program MAPLE pamięta, że x = 9/8, y = 5/16 a z = 3/16 o czym możemy się przekonać prosząc o wypisanie wartości zmiennej (na przykład) x: > x; 9/8

> solve(x^4 + 3*x^2 + 5*x = 7, x);

RootOf(%1, index = 1), RootOf(%1, index = 2), RootOf(%1, index = 3),

RootOf(%1, index = 4)

4 2%1 := _Z + 3 _Z + 5 _Z - 7

> fsolve(x^4 + 3*x^2 + 5*x = 7, x);

-1.635412233, 0.8548042112

16. Sumy, iloczyny i granice16.1. Sumy> Sum(x/(x-1), x=2..10);

10 ----- \ x ) ----- / x - 1 ----- x = 2

> sum(x/(x-1), x=2..10);

29809 ----- 2520

> sum(1/2^x, x=0..infinity);

2

16.2. Iloczyny> Product(x, x=3..5);

5 --------' ' | | | | x | | | |

x = 3

> product(x, x=3..5);

60

16.3. Granice> Limit(sin(x)/x, x=0);

sin(x) lim ------ x -> 0 x

> limit(sin(x)/x, x=0);

1

16.4. Rozwinięcie w szereg

16.4.1. Szereg potęgowy> series(sin(x), x=0, 10);

3 5 7 9 10 x - 1/6 x + 1/120 x - 1/5040 x + 1/362880 x + O(x )

16.4.2. Szereg TayloraFunkcja taylor(f,x,n) rozwija w szereg Taylora wyrażenie f będące funkcją zmiennej x względem x (domyślne x = 0) i wypisuje wyrazy rzędu co najwyżej n.

> taylor(1/(1-x),x,5);

2 3 4 5 1 + x + x + x + x + O(x )

> taylor(1/(1-x),x=0,5);

2 3 4 5 1 + x + x + x + x + O(x )

> taylor(1/(1-x),x=1,5);

Error, does not have a taylor expansion, try series()

16.4.3. Szereg Taylora funkcji wielu zmiennychFunkcja mtaylor(f,var,n) rozwija w szereg Taylora wyrażenie f będące funkcją zmiennych var (na przykład: [x,y]) i wypisuje wyrazy rzędu co najwyżej n.

> f:=(x,y)->exp(-(x^2+y^2)*cos(x^2+y^2)^2);

2 2 2 2 2 f := (x, y) -> exp(-(x + y ) cos(x + y ) )

> mtaylor(f(x,y),[x,y],8);

2 2 4 2 2 4 6 4 2 2 41 - x - y + 1/2 x + x y + 1/2 y + 5/6 x + 5/2 x y + 5/2 x y

6 + 5/6 y

17. Różniczkowanie17.1. Pierwsza pochodna

W celu wyznaczenia pochodna z zależności f będącej funkcją zmiennej x po tej zmiennej x należy użyć funkcji diff(f,x), na przykład:

> diff((x+1)^2/(2*x-x),x);

2 2 (x + 1) (x + 1) --------- - -------- x 2 x

17.2. Druga pochodna> diff((x+1)^2/(2*x-x),x$2);

2 4 (x + 1) 2 (x + 1) 2/x - --------- + ---------- 2 3 x x

18. Równania różniczkowe18.1. Proste równanie różniczkowe

Rozwiążmy równanie różniczkowe: x'(t) = x(t)

> eq := diff( x(t), t ) = x(t);

d eq := -- x(t) = x(t) dt

> dsolve( eq, x(t) );

x(t) = _C1 exp(t)

Wynik jest oczywisty: x(t) = C exp(t)

18.2. Warunek początkowy

Aby wyznaczyć rozwiązanie naszego równania z warunkiem początkowym, np. x(0) = 1, wystarczy podać te informacje w pierwszym argumencie dsolve:

> dsolve( {eq, x(0) = 1}, x(t) );

x(t) = exp(t)

18.3. Wykres wyniku> plot( rhs(%), t = -1..1 );

+ A +

AA 2.5 + AA + A + AAA + AAA 2 + AAA + AAA + AA + AAA 1.5 + AAA + AAA + AAAA + AAAA +AAAAA AA1A*A AAAAAA + AAAAAAA + AAAAAAAA + AAAAAAAAAA 0.5 + ******++-++-++-++-++-++-++-++-++-++-+++-++-++-++-++-++-++-++-++-++-++-++-++ -1 -0.8 -0.6 -0.4 -0.2 0 0.2 0.4 0.6 0.8Funkcja rhs(%) zwraca prawą stronę równości % (ang. right hand side), czyli u nas exp(t) - i właśnie to wyrażenie podstawia się jako pierwszy argument (tzn. co narysować?) funkcji plot()

18.4. Układ równań różniczkowych

x'(t) = y(t)y'(t) = -x(t)

> eq := {diff(x(t),t)=y(t) , diff(y(t), t) = -x(t)};

d d eq := {-- x(t) = y(t), -- y(t) = -x(t)} dt dt

> dsolve( eq, {x(t),y(t)} );

{x(t) = _C1 sin(t) + _C2 cos(t), y(t) = _C1 cos(t) - _C2 sin(t)}

Z warunkiem początkowych wygląda to tak:

> ini := {x(0) = 0, y(0) = 1};

ini := {x(0) = 0, y(0) = 1}

> dsolve( eq union ini, {x(t),y(t)} );

{x(t) = sin(t), y(t) = cos(t)}

19. Całkowanie19.1. Całka nieoznaczona> int(f,x);

Oblicza całkę nieoznaczoną po x z wyrażenia f będącego funkcją tej zmiennej x, na przykład:

> int(x*sin(x),x);

sin(x) - x cos(x)

19.2. Całka oznaczona> int(f,x=a..b);

Oblicza całkę oznaczoną po x od a do b z wyrażenia f będącego funkcją tej zmiennej x, na przykład:

> int(x^2,x=0..1);

1/3

19.3. Całkowanie po R (od -inf do +inf)> int(x^2*exp(-x^2),x=-infinity..infinity);

1/2 Pi ----- 2

19.4. Dodawanie informacji o parametrach> int(exp(-a^2*x^2),x=0..infinity);

1/2 Pi erf(a x) lim 1/2 -------------- x -> infinity a

> int(exp(-a^2*x^2),x=0..infinity) assuming a::real;

1/2 Pi --------- 2 1/2 2 (a )

assuming a>0; a > 0assuming a::positive a jest nieujemnaassuming r::real; r jest liczbą rzeczywistąassuming z::complex; z jest liczbą zespoloną

> int(sin(x^2)/x^2, x = 0..1);

1/2 1/2 1/2 2 -sin(1) + 2 Pi FresnelC(-----) 1/2 Pi

> evalf(int(sin(x^2)/x^2, x = 0..1));

0.9675774902

> int(exp(x^3),x=1..2);

2 /

| 3 | exp(x ) dx | / 1

> evalf(%);

275.5109838

20. Całkowanie przez zamianę zmiennych20.1. Całkowanie metodą "tradycyjną"> Int((cos(x)+1)^3*sin(x),x);

/ | 3 | (cos(x) + 1) sin(x) dx | /

> value(%);

4 -1/4 (cos(x) + 1)

20.2. Całkowanie metodą zamiany zmiennych> with(student);

[D, Diff, Doubleint, Int, Limit, Lineint, Product, Sum, Tripleint, changevar,

completesquare, distance, equate, integrand, intercept, intparts, leftbox,

leftsum, makeproc, middlebox, middlesum, midpoint, powsubs, rightbox,

rightsum, showtangent, simpson, slope, summand, trapezoid]

> changevar(cos(x)+1=u,Int((cos(x)+1)^3*sin(x),x),u);

/ | 3 | -u du | /

> value(%);

4 u - ---- 4

> subs(u=cos(x)+1,%);

4 -1/4 (cos(x) + 1)

20.3. Całka oznaczona> changevar(cos(x)+1=u,Int((cos(x)+1)^3*sin(x),x=0..Pi),u);

2 / | 3 | u du | / 0

> value(%);

4

Dla porównania wynik otrzymany metodą "tradycyjną":

> Int((cos(x)+1)^3*sin(x),x=0..Pi);

Pi / | 3 | (cos(x) + 1) sin(x) dx | / 0

> value(%);

4

21. Tabele i tablice21.1. Tabele

21.1.1. Definicja tabeliTabelę definiuje się przy pomocy funkcji table([lista]) gdzie lista zawiera pary: index=wartość, na przykład polecenie:

> t:=table([a=1,b=2,c=3]);

t := table([c = 3, b = 2, a = 1])

tworzy tabelę:a 1b 2c 3

21.1.2. Dodawanie pozycji do tabeli> t[e]:=5;

t[e] := 5

> print(t);

table([c = 3, e = 5, b = 2, a = 1])

21.1.3. Odczytywanie wartości z tabeliAby odczytać jaka wartość jest przypisana w tabeli do litery "a" należy wpisać:

> t[a];

1

Jeżeli spróbujemy odczytać wartość nieistniejącą w tabeli (np. liczbę odpowiadającą literze "d") uzyskamy:

> t[d];

t[d]

21.2. Tablice

Tablicę w programie MAPLE definiuje się przy pomocy instrukcji array jak następuje:

21.2.1. Tablice jednowymiarowe> v:=array(1..3);

v := array(1 .. 3, [])

> print(v);

[v[1], v[2], v[3]]

21.2.2. Tablice dwuwymiarowe> v:=array(1..2,1..2);

v := array(1 .. 2, 1 .. 2, [])

> print(v);

[v[1, 1] v[1, 2]] [ ] [v[2, 1] v[2, 2]]

21.2.3. Dostęp do komórek tablicy> for i from 1 to 2 dofor j from 1 to 2 dov[i,j]:=i*j*5od od;

> print(v);

[ 5 10] [ ] [10 20]

> v[2,2];

20

22. MacierzeNajpierw załadujemy moduł linalg do obliczeń algebraicznych z zakresu algebry liniowej.

> with(linalg);

Warning, the protected names norm and trace have been redefined and unprotected[BlockDiagonal, GramSchmidt, JordanBlock, LUdecomp, QRdecomp, Wronskian,

addcol, addrow, adj, adjoint, angle, augment, backsub, band, basis, bezout,

blockmatrix, charmat, charpoly, cholesky, col, coldim, colspace, colspan,

companion, concat, cond, copyinto, crossprod, curl, definite, delcols,

delrows, det, diag, diverge, dotprod, eigenvals, eigenvalues, eigenvectors,

eigenvects, entermatrix, equal, exponential, extend, ffgausselim,

fibonacci, forwardsub, frobenius, gausselim, gaussjord, geneqns, genmatrix,

grad, hadamard, hermite, hessian, hilbert, htranspose, ihermite, indexfunc,

innerprod, intbasis, inverse, ismith, issimilar, iszero, jacobian, jordan,

kernel, laplacian, leastsqrs, linsolve, matadd, matrix, minor, minpoly,

mulcol, mulrow, multiply, norm, normalize, nullspace, orthog, permanent,

pivot, potential, randmatrix, randvector, rank, ratform, row, rowdim,

rowspace, rowspan, rref, scalarmul, singularvals, smith, stackmatrix,

submatrix, subvector, sumbasis, swapcol, swaprow, sylvester, toeplitz,

trace, transpose, vandermonde, vecpotent, vectdim, vector, wronskian]

22.1. Definicja macierzy

Macierz definiuje się przy pomocy polecenia matrix(...) w jednej z dwóch wersji:

22.1.1. Definicja macierzy o zadanych rozmiarachPolecenie matrix(m, n, [lista]) tworzy macierz o wymiarach m×n o elementach pobranych z listy. Elementy z listy umieszczane są macierzy wierszami, od prawej do lewej i od góry do dołu:

> M := matrix(3,4,[4,-3,1,0,3,7,0,-5,6,0,-1,2]);

[4 -3 1 0] [ ] M := [3 7 0 -5] [ ] [6 0 -1 2]

22.1.2. Definicja macierzy poprzez podanie wierszy.

Polecenie matrix([lista]) gdzie lista jest listą list, tworzy macierz, której wierszami są listy wymienione na liście podanej jako argument.

> N := matrix([[2,-1,0,6],[-5,0,7,3],[0,1,-3,4]]);

[ 2 -1 0 6] [ ] N := [-5 0 7 3] [ ] [ 0 1 -3 4]

22.2. Wydzielanie fragmentów macierzy

22.2.1. Wycinanie kolumny> col(M,1);

[4, 3, 6]

> [seq(col(M,k),k=1..4)];

[[4, 3, 6], [-3, 7, 0], [1, 0, -1], [0, -5, 2]]

22.2.2. Wycinanie wiersza> row(M,2);

[3, 7, 0, -5]

> [seq(row(M,k),k=1..3)];

[[4, -3, 1, 0], [3, 7, 0, -5], [6, 0, -1, 2]]

22.2.3. Wycinanie "podmacierzy"> evalm(M);

Dla przypomnienia - postać macierzy M: [4 -3 1 0] [ ] [3 7 0 -5] [ ] [6 0 -1 2]

Aby z macierzy m wyciąć fragment zaweirający komówrki z wierszy w i jednocześnie kolumn k (gdzie w i k może być przedziałem, na przykład 2..4, lub listą [2,1,3] - patrz przykłady), należy użyć polecenia submatrix(m,w,k):

> submatrix(M,2..3,1..2);

[3 7] [ ] [6 0]

> submatrix(M,[3,1,2],[4,1]);

[ 2 6] [ ] [ 0 4] [ ] [-5 3]

22.3. Właściwości macierzy

22.3.1. Określanie rozmiaru macierzy

22.3.1.1. Ilość kolumn - szerokość> coldim(M);

4

22.3.1.2. Ilość wierszy - wysokość> rowdim(M);

3

22.3.2. Wyznacznik macierzyWyznacznik macierzy M wyznaczamy poleceniem det(M), gdzie macierz M musi być kwadratowa.

> det(M);

Error, (in linalg:-det) expecting a square matrix

> M2 := matrix(2,2,[2,-1,3,-1]);

[2 -1] M2 := [ ] [3 -1]

> det(M2);

1

22.4. Przekształcenia macierzy

22.4.1. Macierz odwrotna> evalm(M2^(-1));

[-1 1] [ ] [-3 2]

Można też tak:

> inverse(M2);

[-1 1] [ ] [-3 2]

22.4.2. Macierz transponowana> transpose(M2);

[ 2 3] [ ] [-1 -1]

22.4.3. Usuwanie wierszy lub kolumn

22.4.3.1. Usuwanie kolumn

W celu usunięcia z macierzy M kolumny od m-tej do n-taj należy użyć polecenia

delcols(M,m..n):

> delcols(M,2..3);

[4 0] [ ] [3 -5] [ ] [6 2]

22.4.3.2. Usuwanie wierszy

W celu usunięcia z macierzy M wierszy od m-tej do n-taj należy użyć polecenia delrows(M,m..n):

> delrows(M,1..2);

[6 0 -1 2]

22.5. Działania na macierzach

22.5.1. Łączenie macierzy> concat(M,N);

[4 -3 1 0 2 -1 0 6] [ ] [3 7 0 -5 -5 0 7 3] [ ] [6 0 -1 2 0 1 -3 4]

22.5.2. Dodawanie macierzy> evalm(M+N);

[ 6 -4 1 6] [ ] [-2 7 7 -2] [ ] [ 6 1 -4 6]

22.5.3. Mnożenie macierzyWykonajmy działanie: M2TM2-1

> evalm(transpose(M2)*M2^(-1));

[-11 8] [ ] [ 4 -3]

Można też i tak:

> multiply(transpose(M2),M2^(-1));

[-11 8] [ ] [ 4 -3]

22.6. Operacje elementarne

22.6.1. Dodanie krotności kolumny do innej kolumny

W celu zastąpienia j-tej kolumny macierzy M kolumną i-tą przemnożoną przez m (j ← j + m*i) należy użyć polcenia: addcol(M,i,j,m) jak następuje:

> addcol(M,3,1,-2);

[2 -3 1 0] [ ] [3 7 0 -5] [ ] [8 0 -1 2]

22.6.2. Dodanie krotności wiersza do innego wierszaW celu zastąpienia j-tego wiersza macierzy M wierszem i-tą przemnożonym przez m (j ← j + m*i) należy użyć polcenia: addrow(M,i,j,m) jak następuje:

> addrow(M,2,3,-2);

[4 -3 1 0] [ ] [3 7 0 -5] [ ] [0 -14 -1 12]

22.6.3. Przemnożenie kolumny przez liczbę> mulcol(M,3,5);

[4 -3 5 0] [ ] [3 7 0 -5] [ ] [6 0 -5 2]

22.6.4. Przemnożenie wiersza przez liczbę> mulrow(M,1,0.5);

[2.0 -1.5 0.5 0.] [ ] [ 3 7 0 -5] [ ] [ 6 0 -1 2 ]

22.6.5. Przestawienie kolumn> swapcol(M,3,1);

[ 1 -3 4 0] [ ] [ 0 7 3 -5] [ ] [-1 0 6 2]

22.6.6. Przestawienie wierszy> swaprow(M,3,1);

[6 0 -1 2] [ ] [3 7 0 -5] [ ] [4 -3 1 0]

22.7. Wartości i wektory własne> A := matrix([[2,-3,1],[3,1,3],[-5,2,-4]]);

[ 2 -3 1] [ ] A := [ 3 1 3] [ ] [-5 2 -4]

> eigenvalues(A);

0, 1, -2

> eigenvectors(A);

[ -11] [-2, 1, {[1, 3/4, -7/4]}], [0, 1, {[1, 3/10, ---]}], [1, 1, {[-1, 0, 1]}] [ 10 ]

Funkcja eigenvectors zwraca w każdej liście następujące wartości:

• wartość• własną;

• krotność• ;

• wektor własny

czyli w przykładzie otrzymaliśmy trzy wektory własne, wszystkie jednokrotne. Wartości własnej -2 odpowiada wektor [1, 3/4, -7/4], wartości własnej 0: [1, 3/10, -11/10], a wartości własne -1: [-1, 0, 1]

23. Liczby zespolone23.1. Definicja

Liczbę zespoloną definiujemy jako a + b*I gdzie a oraz b są dowolnymi liczbami rzeczywistymi, a I jest jednostką urojoną: I2 = -1.

> z:=3+5*I;

z := 3 + 5 I

23.2. Część rzeczywista i urojona liczby z> Re(z);

3

> Im(z);

5

24. Kombinatoryka24.1. Początek> with(combinat);

Warning, the protected name Chi has been redefined and unprotected[Chi, bell, binomial, cartprod, character, choose, composition, conjpart,

decodepart, encodepart, fibonacci, firstpart, graycode, inttovec, lastpart,

multinomial, nextpart, numbcomb, numbcomp, numbpart, numbperm, partition,

permute, powerset, prevpart, randcomb, randpart, randperm, setpartition,

stirling1, stirling2, subsets, vectoint]

24.2. Symbol Newton'a

Polecenie binomial(n,k) oblicza wartość symbolu Newton'a

> binomial(13,10);

286

> binomial(z+2,z-2);

binomial(z + 2, z - 2)

> expand(binomial(z+2,z-2));

4 3 2 1/24 z + 1/12 z - 1/24 z - 1/12 z

24.3. Permutacje bez powtórzeń

Możliwe permutacje bez powtórzeń zbioru n-elementowego otrzymuje się przy pomocy funkcji permute(n):

> permute(4);

[[1, 2, 3, 4], [1, 2, 4, 3], [1, 3, 2, 4], [1, 3, 4, 2], [1, 4, 2, 3],

[1, 4, 3, 2], [2, 1, 3, 4], [2, 1, 4, 3], [2, 3, 1, 4], [2, 3, 4, 1],

[2, 4, 1, 3], [2, 4, 3, 1], [3, 1, 2, 4], [3, 1, 4, 2], [3, 2, 1, 4],

[3, 2, 4, 1], [3, 4, 1, 2], [3, 4, 2, 1], [4, 1, 2, 3], [4, 1, 3, 2],

[4, 2, 1, 3], [4, 2, 3, 1], [4, 3, 1, 2], [4, 3, 2, 1]]

> permute({a,b,c,d});

[[c, b, a, d], [c, b, d, a], [c, a, b, d], [c, a, d, b], [c, d, b, a],

[c, d, a, b], [b, c, a, d], [b, c, d, a], [b, a, c, d], [b, a, d, c],

[b, d, c, a], [b, d, a, c], [a, c, b, d], [a, c, d, b], [a, b, c, d],

[a, b, d, c], [a, d, c, b], [a, d, b, c], [d, c, b, a], [d, c, a, b],

[d, b, c, a], [d, b, a, c], [d, a, c, b], [d, a, b, c]]

Ilość możliwych permutacji bez powtórzeń Zbioru n-elementowego (tj. n!) zwraca funkcja numbperm(n)

> numbperm(4);

24

> numbperm({a,b,c,d});

24

24.4. Permutacje z powtórzeniami

Ilość możliwych permutacji z powtórzeniami elementów zbioru n-elemetowego, gdzie elementy powtarzają się k1, k2... kn razy, oraz k1+k2+...+kn = n (czyli ) zwraca funkcja multinomial(n,k1,k2,...,kn).

> multinomial(26,6,6,2,2,3,7);

6431499730656000

24.5. Wariacje bez powtórzeń

Możliwe k-elementowe wariacje bez powtórzeń elementów zbioru n-elementowego można otrzymać przy użyciu funkcji permute(n,k):

> permute(4,2);

[[1, 2], [1, 3], [1, 4], [2, 1], [2, 3], [2, 4], [3, 1], [3, 2], [3, 4],

[4, 1], [4, 2], [4, 3]]

> permute({a,b,c,d},2);

[[c, b], [c, a], [c, d], [b, c], [b, a], [b, d], [a, c], [a, b], [a, d],

[d, c], [d, b], [d, a]]

Ilość możliwych wariacji bez powtórzeń (tj. ) zwraca funkcja numbperm(n,k):

> numbperm(4,2);

12

> numbperm({a,b,c,d},2);

12

24.6. Kombinacje

24.6.1. Kombinacje k-elementoweMożliwe k-elementowe kombinacje zbioru n-elementowego można otrzymać przy pomocy funkcji choose(n,k):

> choose(4,2);

[[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

> choose({a,b,c,d},2);

{{c, d}, {b, d}, {a, d}, {c, b}, {c, a}, {b, a}}

Ilość możliwych k-elementowych kombinacji zbioru n-elementowego (tj. ) zwraca funkcja numbcomb(n,k):

> numbcomb(4,2);

6

> numbcomb({a,b,c,d},2);

6

24.6.2. Wszystkie możliwe kombinacjeW celu wypisania wszystkich możliwych k-elementowych kombinacji zbioru n-elementowego, gdzie k = 0, 1, ... n należy zastosować funkcję choose(n):

> choose(4);

[[], [1], [2], [3], [4], [1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4],

[1, 2, 3], [1, 2, 4], [1, 3, 4], [2, 3, 4], [1, 2, 3, 4]]

> choose({a,b,c,d});

{{}, {d}, {c, d}, {b, d}, {c, b, d}, {a, d}, {c, a, d}, {b, a, d},

{c, b, a, d}, {c}, {b}, {c, b}, {a}, {c, a}, {b, a}, {c, b, a}}

Ilość możliwych k-elementowych kombinacji zbioru n-elementowego, gdzie k = 1, 2, ... n (tj. ) zwraca funkcja numbcomb(n):

> numbcomb(4);

16

> numbcomb({a,b,c,d});

16

24.6.3. Kombinacje liczb naturalnychFunkcja composition(m,n) wypisuje wszystkie n-elementowe listy liczb naturalnych, których suma równa jest m:

> composition(6,3);

{[4, 1, 1], [3, 2, 1], [2, 3, 1], [1, 4, 1], [3, 1, 2], [2, 2, 2], [1, 3, 2],

[2, 1, 3], [1, 2, 3], [1, 1, 4]}

O ilości zwracanych list dowiemy się po użyciu polecenia numbcomp(m,n):

> numbcomp(6,3);

10

W połączeniu z poleceniem wykonywania sekwencyjnego seq funkcja composition może być użyta do znalezienia wszystkich możliwych sum liczb naturalnych nie większych niż zadana liczba naturalna, na przykład:

> seq(composition(5,i),i=1..5);

{[5]}, {[4, 1], [3, 2], [2, 3], [1, 4]},

{[3, 1, 1], [2, 2, 1], [1, 3, 1], [2, 1, 2], [1, 2, 2], [1, 1, 3]},

{[2, 1, 1, 1], [1, 2, 1, 1], [1, 1, 2, 1], [1, 1, 1, 2]},

{[1, 1, 1, 1, 1]}

Jednakże zauważamy, że takie postępowanie w wyniku daje powtarzające się

odpowiedzi (na przykład [2,1,2] oraz [1,2,2]). Aby wypisać niepowtarzające się rozkłady liczby naturalnej n na sumę liczba naturalnych należy użyć funkcji partition(n):

> partition(5);

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

O ilości zwracanych list dowiemy się po użyciu polecenia numbpart(n):

> numbpart(5);

7

25. Programowanie25.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/fiOperacje 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/odJest 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/odTo 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/odTaka 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 powtarzaniaPoleceniem 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) thenERROR(`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.

26. Innerand()

zwraca 12-cyfrową liczbę losowąlength(expr)

zwraca długość wyrażenia expr: jeżeli jest to wyraz (ciąg znaków), to zwraca ilość znaków; jeżeli jest to liczba całkowita, to zwraca ilość cyfr

restart

restart programu Maple i przejście do takiej postaci, jaka jest tuż po jego uruchomieniu.

simplify(%)prośba o uproszczenie wyniku ostatniego obliczenia.