INTERNI DATOVA REPREZENTACE A SUBSTITUCE
Interni datova reprezentace
> pol:=x^4+x^3-x^2-x;
:=pol + - -x4
x3
x2
x
> subs(1=7, pol);
+ - -7 x4
7 x3
x2
x
> whattype(pol);
+
Pomoci nops ziskame pocet scitancu.
> nops(pol);
4
Posloupnost komponent (operandu) ziskame
procedurou op.
> op(pol);
, , ,x4
x3
-x2
-x
Nyni si vsimneme kazdeho clenu zvlast.
> `prvni clen`:=op(1,pol);
:=prvni clen x4
Na prvni operand se muzeme odkazat i pomoci
> op(pol)[1];
x4
> whattype(%);
^
> dismantle(x^4);
PROD(3)
NAME(4): x
INTPOS(2): 4
Symbol ^ predstavuje datovy typ power
(mocnina), pokud je exponent typu numeric,
Maple provadi automaticke zjednoduseni na
typ product (soucin).
> dismantle(x^a);
POWER(3)
NAME(4): x
NAME(4): a
> op(op(pol)[1]);
,x 4
> op([1,1],pol),op([1,2],pol);
,x 4
> `treti clen`:=op(3,pol);
:=treti clen -x2
> dismantle(`treti clen`);
SUM(3)
PROD(3)
NAME(4): x
INTPOS(2): 2
INTNEG(2): -1
> op(`treti clen`);
,-1 x2
> `ctvrty clen`:=op(4,pol);
:=ctvrty clen -x
> op(`ctvrty clen`);
,-1 x
> op([4,2],pol);
x
> whattype(%);
symbol
Podobnym zpusobem muzeme v Maplu
rozebrat jakykoliv vyraz, nejen polynomy.
Musime vsak neustale byt vedomi, ze
identicke podvyrazy jsou interne ulozeny
pouze jednou.
> dismantle(pol);
SUM(9)
PROD(3)
NAME(4): x
INTPOS(2): 4
INTPOS(2): 1
PROD(3)
NAME(4): x
INTPOS(2): 3
INTPOS(2): 1
PROD(3)
NAME(4): x
INTPOS(2): 2
INTNEG(2): -1
NAME(4): x
INTNEG(2): -1
Vidime take, ze delka datoveho vektoru pro
promennou je 4 - krome jmena promenne
promennou je 4 - krome jmena promenne
jeden ukazatel urcuje, ze promenna je
nevyhodnocenna a druhy, ze nema zadne
attributy.
> dismantle(x-5);
SUM(5)
NAME(4): x
INTPOS(2): 1
INTNEG(2): -5
INTPOS(2): 1
> dismantle(x^2*y^3*z^4);
PROD(7)
NAME(4): x
INTPOS(2): 2
NAME(4): y
INTPOS(2): 3
NAME(4): z
INTPOS(2): 4
Tento priklad ukazuje, ze pouziti datoveho
typu PROD je z pametoveho hlediska
vyhodnejsi, nez kombinace datovych typu
POWER a PRODUCT.
Odhadnete vysledek nasledujici substituce:
> pol2:=Pi*x+x+1;
:=pol2 + + x x 1
> dismantle(pol2);
SUM(7)
PROD(5)
NAME(4): Pi #[protected]
INTPOS(2): 1
NAME(4): x
INTPOS(2): 1
INTPOS(2): 1
NAME(4): x
INTPOS(2): 1
INTPOS(2): 1
INTPOS(2): 1
> subs(1=3, pol2);
+ +3 
3
x3
3 x 9
> nops(pol2);op(pol2);
3
, , x x 1
> whattype(op(1,pol2));
*
> op(op(1,pol2));
, x
Dale si vsimneme interni reprezentace
racionalni lomene funkce.
> r:=(y^2-1)/(y-1);
:=r
-y2
1
-y 1
> type(r, `ratpoly`);
true
> whattype(r);
*
> op(r);
,-y2
1
1
-y 1
> op(2,r);
1
-y 1
> whattype(%);
^
> op(%%);
,-y 1 -1
> normal(r);
+y 1
> dismantle(r);
PROD(5)
SUM(5)
PROD(3)
NAME(4): y
INTPOS(2): 2
INTPOS(2): 1
INTNEG(2): -1
INTPOS(2): 1
INTPOS(2): 1
SUM(5)
NAME(4): y
INTPOS(2): 1
INTNEG(2): -1
INTPOS(2): 1
INTNEG(2): -1
Opet vidime, ze interni datova struktura se
lisi od externi, zobrazene na obrazovce.
Racionalni funkce je soucinem citatele a
jemnovatele umocneneho na -1.
> r:=(sin(x)^2-1)/(sin(x)-1);
:=r
-( )sin x 2
1
-( )sin x 1
> type(r, `ratpoly`);
false
> type(r, `ratpoly`(`integer`,
sin(x)));
true
> dismantle(r);
PROD(5)
SUM(5)
PROD(3)
FUNCTION(3)
NAME(4): sin #[protected, _syslib]
EXPSEQ(2)
NAME(4): x
INTPOS(2): 2
INTPOS(2): 1
INTNEG(2): -1
INTPOS(2): 1
INTPOS(2): 1
SUM(5)
FUNCTION(3)
NAME(4): sin #[protected, _syslib]
EXPSEQ(2)
NAME(4): x
INTPOS(2): 1
INTNEG(2): -1
INTPOS(2): 1
INTNEG(2): -1
R je racionalni funce v "promenne" sin(x) s
racionalnimi koeficienty.
> normal(r);
+( )sin x 1
Maple povazuje r za zobecnenou racionalni
Maple povazuje r za zobecnenou racionalni
funkci.
Procedura normal automaticky "uzavira"
funkci sin(x) pouze do jmena, provede
zjednoduseni
a opet fci sin(x) "otevira". Obdobne se chova i
procedura factor.
Substituce
Nejjednodussi formou substituce je prikaz
subs(promenna=hodnota, vyraz).
> subs(x=0,
cos(x)*(sin(x)+x^2+1));
( )cos 0 ( )+( )sin 0 1
Vysledek je zjednodusen, ale ne automaticky
vyhodnocen.
> eval(%);
1
Nasobne substituce
> expression:=1+tan(x)^2;
:=expression +1 ( )tan x 2
> subs(tan(x)=sin(x)/cos(x),
sin(x)^2=1-cos(x)^2,
expression);
+1
-1 ( )cos x 2
( )cos x 2
> normal(%);
1
( )cos x 2
V tomto pripade se nejdrive provede prvni
substituce a v ziskanem vyrazu nasledne
substituce druha. Tomuto zpusobu se rikaz
posloupnost substituci.
Druhym zpusobem je tzv. soucasna
substituce, substitucni rovnice v tomto
pripade uzavreme do slozenych zavorek ({}).
> subs({x=y, y=z}, x*y^2);
#soucasna substituce
y z2
> subs(x=y, y=z, x*y^2);
#posloupnost substituci
z3
> subs(a=b, b=c, c=a, a+2*b+3*c);
6 a
> subs({a=b, b=c, c=a},
a+2*b+3*c);
+ +b 2 c 3 a
Muzeme provadet substituce i za casti vyrazu.
Podminkou provedeni je to, za Maple
internerne rozezna "podvyraz" (jako vystup
procedury op).
> expr1:=x*y+z; expr2:=x*y*z;
expr3:=(x*y)^2;
:=expr1 +x y z
:=expr2 x y z
:=expr3 x2
y2
> subs(x*y=product, expr1);
+product z
> subs(x*y=product, expr2);
x y z
> subs(x*y=product, expr3);
x2
y2
> op(expr1);
,x y z
> op(expr2);
, ,x y z
> op(expr3);
,x2
y2
Muzeme pouzit proceduru algsubs:
> algsubs(x*y=product, expr2);
z product
> algsubs(x*y=product, expr3);
product2
nebo pouzit proceduru applyrule (stanovit
pravidla, ktere "aplikujeme" na vyraz):
> applyrule(x*y=product, expr2);
z product
> applyrule(x*y=product, expr3);
x2
y2
Procedura algsubs (algebraic substitution)
funguje i pro casti souctu a neni tak uzce
spjata s interni strukturou jako subs.
> vyraz:=a+b+c;
:=vyraz + +a b c
> subs(a+b=d, vyraz);
+ +a b c
> algsubs(a+b=d, vyraz);
+d c
> p:=a+2*b+3*c;
:=p + +a 2 b 3 c
> applyrule(a+b=d, p);
+ +a 2 b 3 c
> algsubs(a+b=d,p);
+ +b d 3 c
Prikaz eliminoval a, chceme ale eliminovat b.
Jako dalsi argument procedury algsubs
muzeme zadat poradi (usporadani)
promennych.
> algsubs(a+b=d,p,[b,a]);
- + +a 2 d 3 c
Dalsim volitelnym parametrem je 'exact':
> algsubs(a+b=d,p,'exact');
+ +a 2 b 3 c
> algsubs(a+b=d,2*a+2*b+3*c,'exac
t');
+2 d 3 c
Dalsi moznosti, jak provadet substituce, je
nahrazovat primo operandy mapleovskeho
vyrazu. K tomu slouzi procedura subsop:
subsob(cislo_operandu1=nahrada1,
cislo_operandu2=nahrada2,vyraz)
Substituce se provadi pouze na dane urovni
(hloubce).
> vyraz:=x^2+x+1/x;
:=vyraz + +x2
x
1
x
> subsop(3=y, vyraz);
+ +x2
x y
> subsop(1=z, 2=y,vyraz);
+ +z y
1
x
> subs(x=y, vyraz);
+ +y2
y
1
y
Dalsi vyhodou procedury subsop je to, ze
nemusime opisovat
dlouhe casti vyrazu, ktere chceme nahrazovat.
> soucin:=(x^2+y^2+2*x*y) *
((x+y)^2+1);
:=soucin ( )+ +x2
y2
2 x y ( )+( )+x y 2
1
> factor(soucin);
( )+x y 2
( )+ + +x2
y2
2 x y 1
> subsop(1=factor(op(1, soucin)),
soucin);
( )+x y 2
( )+( )+x y 2
1
> applyop(factor,1,soucin);
( )+x y 2
( )+( )+x y 2
1
applyop(funkce,index, vyraz) je to same, jako
subsop(index=funkce(op(index,vyraz)),
vyraz).
> vyraz:=(x^2+2*x+1)^2+(x^2-2*x+1
)^2;
:=vyraz +( )+ +x2
2 x 1
2
( )- +x2
2 x 1
2
> factor(vyraz);
+ +2 x4
12 x2
2
> op(vyraz);
,( )+ +x2
2 x 1
2
( )- +x2
2 x 1
2
> subsop(1=factor(op(1,vyraz)),
2=factor(op(2,vyraz)), vyraz);
+( )+x 1 4
( )-x 1 4
Tohoto zjednoduseni muzeme dosahnut s
pomoci procedury map,
ktera aplikuje prikaz na vsechny operandy
daneho vyrazu (na kazdy zvlast).
> map(factor, vyraz);
+( )+x 1 4
( )-x 1 4
Zjednoduseni z prvniho prikladu je mozno
dosahnout i nasledujicim postupem:
> soucin;
( )+ +x2
y2
2 x y ( )+( )+x y 2
1
> subs(x+y=z, soucin);
( )+ +x2
y2
2 x y ( )+z2
1
> factor(%);
( )+x y 2
( )+z2
1
> subs(z=x+y, %);
( )+x y 2
( )+( )+x y 2
1
Toto je velmi casto pouzivana technika pri
upravach vyrazu.
> vyraz:=(x+y)^2+1/(x+y)^2;
:=vyraz +( )+x y 2
1
( )+x y 2
> normal(vyraz);
+ + + + +x4
6 x2
y2
4 x3
y 4 x y3
y4
1
( )+x y 2
> subs(x+y=z, vyraz);
+z2
1
z2
> normal(%);
+z4
1
z2
> subs(z=x+y, %);
+( )+x y 4
1
( )+x y 2
> subs(x+y=freeze(x+y), vyraz);
+freeze/R02
1
freeze/R02
> normal(%);
+freeze/R04
1
freeze/R02
> thaw(%);
+( )+x y 4
1
( )+x y 2
>
>