w02 b, Inżynierskie, Semestr III, Metody obliczeniowe, Wyklady

>
WPROWADZENIE DO MAPLE'A CZ. II
* OPERATORY
* STRUKTURY DANYCH
* PRZEKSZTAŁCANIE WYRAŻEŃ
*DZIAŁANIA NA WIELOMIANACH
OPERATORY
>
?operators
>
?operators[binary]
>
?operators[unary]
>
?operators[nullary]
>
Wybrane operatory
>
# (:=) operator przypisania
>
# (||) operator łączenia
>
# cat - funkcja speniająca rolę operatora łączenia
>
# (..) operator zakresu
>
# ( = , < , > , <= , >= , <> ) - operatory relacji
>
# ( and , or , not ) - operatory logiczne
>
Przykłady zastosowań
>
q:=5;
q
5
>
ma||gnes;
magnes
>
i:=7; z||i;
i
7
z7
>
cat(lo,ko,mo,ty,wa); # concatenate (j. angielski), catena (j.
włoski)
:=
lokomotywa
>
a..b; # liczb kropek >= 2
..
ab
>
sum(1/k,k=1..n);
Ψ +
n
1 γ
)
+
>
evalf(eval(%,n=1000));
7.485470861
>
sum(1/k,k=1..infinity);
:=
(
∞
>
x||(1..10);
x1 x2 x3 x4 x5 x6 x7 x8 x9 x10
, , , , , , , , ,
>
x||(1..4)||(1..2);
x11 x12 x21 x22 x31 x32 x41 x42
>
cos(x)=x; # równanie
,
,
,
,
,
,
,
cos
xx
()
=
>
x^3-2*x>0; # nierówność
x
3
2
x
>
wl:=x>0 and x<1; # wyrażenie logiczne
:=
<0 −
wl
<0
x
<
x
1
and
>
x:=2;
:=
x
2
>
wl;
false
>
not wl;
true
>
restart:
>
STRUKTURY DANYCH
sekwencje (ciągi), listy, zbiory, listy uogólnione (
arrays
), tablice, łańcuchy znaków (napisy)
SEKWENCJE (
ang. - sequence
)
>
s:=2,x,sin(Pi/7);
s
:=
,,
sin


π
7


>
whattype(s);
exprseq
>
s[3];
sin
π
7




>
s[4];
Error, invalid subscript selector
149162536496481100
>
euro $ 10; # ( $ ) - operator generujący sekwencje
,
kw
, , , , , , , , ,
euro euro euro euro euro euro euro euro euro euro
>
x[i] $ i=1..10;
,
,
,
,
,
,
,
,
x
1
, , , , , , , , ,
x
2
x
3
x
4
x
5
x
6
x
7
x
8
x
9
x
10
LISTY (
ang. - list
)
>
lst:=[s];


2
x


>
kw:=seq(i^2,i=1..10); # seq - funkcja generująca sekwencje
:=
lst
:=

2
x
,,
sin

π
7


>
whattype(lst);
list
>
type(lst,list);
true
>
L:=[a,b,c,d,e,d,f,g];
L
[
:=
abcdedfg
,,,,,,,
]
>
L1:=L[1];
L1 a
:=
>
L1:=L[4..6];
L1
[
:=
ded
,,
]
>
L2:=L[4..-3];
L2
[
:=
ded
,,
]
>
L1-L2;
000
>
map(sin,L); # map - funkcja kierująca zadane działanie na każdy
element listy lub zbioru
[
[
,,
]
sin
a
()
,
sin
b
()
,
sin
c
()
,
sin
d
()
,
sin
e
()
,
sin
d
()
,
sin
f
()
,
sin
g
()
]
>
ZBIORY (
ang. - set
)
>
zbiór:={s};
zbiór
{
:=
2
x
,,
sin


π
7


}
>
whattype(zbiór);
set
>
type(zbiór,set);
true
>
z:={A,A,a,a,b,c,B,B,A};
z
{
:=
abcAB
,,, ,
}
>
z[1];
a
>
z[3..4];
cA
>
{a,b} union {c,d}; # suma zbiorów
{
{}
abcd
>
{a,b,c,d} minus {c}; # różnica zbiorów
{
,,,
}
abd
>
{a,b,c,d} intersect {b,x,y}; # iloczyn zbiorów
{}
,,
}
b
>
LISTY UOGÓLNIONE (
ang. - array, Array
)
>
ar:=array(0..4,[a,b,c,d,e]);






ar
:=
array(
..04
, [
()
0
=
a
()
1
=
b
()
2
=
c
()
3
=
d
()
4
=
e
])
>
ar[0];
a
>
>
ar:=array([[1,2,3],[4,5,6]]);
ar
:=


123
456


>
ar[2,1];
4
>
ar;
ar
>
print(ar); eval(ar); op(ar);


123
456



123
456

123
456
>
ar:=array([[[1,2],[3,4]],[[5,6],[7,8]]]);
ar


:=
array(
..12 .12 .12
,
,
, [
(
111 1
=
,,
)
=
(
112 2
=
,,
)
(
121 3
=
,,
)
(
122 4
=
,,
)
(
211 5
=
,,
)
(
212 6
=
,,
)
(
221 7
=
,,
)
222 8
])
>
ar[2,2,1];
(
,,
)
7
>
ar;
ar
>
A1:=Array([seq(x^i,i=1..5)]);
:=
A1
[
xx
2
, , , ,
x
3
x
4
x
5
]




>
A1;
[
xx
2
, , , ,
x
3
x
4
x
5
]
>
A2:=Array(1..2,1..4);
A2
:=

0000
0000

>
A2[1,1]:=alpha;
A2
11
:=
α
>
A2;

α 000
0000

>
restart;
TABLICE (
ang. - table
)
>
>
T1:=table([a=alpha,b=beta,g=gamma,d=delta]); # szybki dostęp do
danych
T1
table([
:=
d
δ =
=
,
b
β =
,
a
α =
,
g
γ
])
>
T1[g];
γ
>
T2:=table({y1=x^2, y2=x^3-1, y3=1/x});
T2
table([
:=
y1 x
2
=
,
y3
=
1
x
,
y2
−
=
x
3
1
])
>
T2[y3];
1
x
>
?table
>
ŁAŃCUCHY ZNAKÓW (NAPISY) (
ang. - string
)
>
>
"można pisać abolutnie wszystko: <>?+_!= @# i nic się nie stanie
złego";
"można pisać abolutnie wszystko: <>?+_!= @# i nic się nie stanie złego"
>
WEKTORY (
ang. - vector
)
>
with(LinearAlgebra):
>
v:=Vector([1,2,3]);

1
2
3

v
:=


>
w:=Vector([a,b,c]);

a
b
c

w
:=


>
DotProduct(v,w);
a
2
b
3
c
+ +









zanotowane.pl

doc.pisz.pl

pdf.pisz.pl

alter.htw.pl