1.4.

Tipuri de date şi operaţii de bază asupra lor

 Tipuri de date simple

Prin tip de date se întelege o mulţime de valori şi o mulţime de operaţii care pot fi efectuate
cu valorile respective.
Integer – prin număr întreg se înţelege o succesiune formată din una sau mai multe cifre (0..9).
Numerele întregi pot fi folosite cu semn sau fără. Operaţii admise asupra numerelor întregi:
suma:=12524+19; diferenta:=1254-89;
suma := 12543 diferenta := 1165
produs:=78*9; cit:=87/9;
produs := 702 29
cit :=
3
factorialul:=9!; a:=123456789;
factorialul := 362880 a := 123456789
length(a);
9

Înafară de operaţiile aritmetice prezentate mai sus pentru prelucrarea numerelor întregi mai
există un şir de comenzi specifice, prezentate în exemplul 1.6.

Exemplul 1.6
ifactor(36); returnează descompunerea în factori primi a numărului dat
( 2 )2 ( 3 )2

iquo(43,7); returnează partea întreagă

6
irem(43,7); returnează restul
1
7*%%+%;
43
igcd(25,15); returnează cel mai mare divizor comun
5
isprime(125); verifică dacă numărul este prim sau nu
false
isprime(5);
true
Notă: Pentru a obţine lista completă a comenzilor definite pentru tipul Integer se scrie în linia de
comenzi opţiunea ?integer;.

Float – real poate fi definit în 2 moduri:

1. cu virgulă mobilă pot fi reprezentate sub forma
2544.578; 355125.; .51345;
2544.578 355125. .51345
2. în formă exponenţială Float(mantisa,exponent), adică mantisa*10^exponent.
1.265*10^(-19);
.1265000000 10 -18
Rational, fraction – raţional, reprezintă numere de forma [semn]a/b, unde a, b numere întregi.
Pentru evaluarea numerelor raţionale se foloseşte funcţia evalf.

Exemplul 1.7
evalf(124/15);
8.266666667
evalf(8/7,20);
1.1428571428571428571
Expresiile ce conţin radical sunt scrise în Maple sub formă de ridicare la putere. Pentru radicalul
de ordinul 2 se foloseşte funcţia sqrt, iar pentru rădăcină de ordin mai mare sau egală cu 2 se aplică
simbolurile ** sau ^. Funcţia surd(a,n) calculează rădăcina de ordinul n din expresia a.

Exemplul 1.8
4^(1/8); sqrt(45/7); surd(8/27,3);
3 2
( 1/8 ) 35
4 7 3
Complex – reprezintă numere de forma a+bI (b0), unde a şi b numere reale, I – unitate complexă

( I   1 ). a se numeşte partea reală, iar b partea imaginară.

Asupra numerelor complexe sunt definite operaţiile aritmetice de bază, redate în exemplul de mai
jos:

Exemplul 1.9
a:=6+5*I; b:=8-9*I; Re(a); Im(b);
a := 65 I b := 89 I 6 -9
suma:=a+b; diferenta:=a-b; produs:=a*b; conjugate(a);
suma := 144 I diferenta := -214 I produs := 9314 I 65 I
argument(b); Complex(12,15);
1215 I
arctan  
9
8

Boolean – logic, conţine valorile true (adevăr), false (fals), FAIL (nedeterminare). Expresiile
logice se formează cu ajutorul operatorilor logici {and, or, not} şi operatorilor relaţionali.
String – caracter: o valoare de tip caracter reprezintă un set finit şi ordonat de caractere cuprins
între simbolurile " ".

Symbol, name – linie: o valoare de tip simbol reprezintă un set finit de caractere cuprins între
simbolurile ` `.

 Tipuri de date structurate şi operaţii de bază asupra lor

Sequence – șir: mai multe expresii separate prin virgulă formează un şir (o consecutivitate). Tipul
dat nu reprezintă nici tipul listă nici tipul mulţime, dar stă la baza definirii acestor tipuri. Există
mai multe moduri de redare a şirurilor.
Exemplul 1.10
6*a,7*y+m,k*h,sqrt(25);
6 a, 7 ym, k h, 5
Un alt mod de creare a şirurilor este cu ajutorul operatorilor „ $ ” şi „ .. ”

Exemplul 1.11
5$10;
5, 5, 5, 5, 5, 5, 5, 5, 5, 5
$1..10;
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
i^3$i=-5..5;
-125, -64, -27, -8, -1, 0, 1, 8, 27, 64, 125
a[i]$i=1..10;
a1, a2, a3, a4, a5, a6, a7, a8, a9, a10

O a treia modalitate de definire a şirului este cu ajutorul comenzii seq.

Exemplul 1.12
seq(i,i=1..10);
1, 2, 3, 4, 5, 6, 7, 8, 9, 10
seq(sqrt(i),i=10..20);
10 , 11 , 2 3 , 13 , 14 , 15 , 4, 17 , 3 2 , 19 , 2 5
cat(seq(i,i="a".."z"));
"abcdefghijklmnopqrstuvwxyz"
seq(i,i="a".."z");
"a" , "b" , "c" , "d" , "e" , "f" , "g" , "h" , "i" , "j" , "k" , "l" , "m" , "n" , "o" , "p" , "q" , "r" , "s" , "t" ,
"u" , "v" , "w" , "x" , "y" , "z"
La formarea unui şir poate fi folosit şi operatorul de concatenare | |.

Exemplul 1.13
a:=1:b:=10:k:=d||(1..10);
k := d1, d2, d3, d4, d5, d6, d7, d8, d9, d10
Lungimea succesiunii este determinată de funcţia nops[]:
a:=1,2,8,9,8; nops([a]);
a := 1, 2, 8, 9, 8 5
Elementul k al căruiva şir se determină cu ajutorul apelului:
a[4];
9
List – liste: sunt şiruri ordonate de expresii, separate între ele prin virgulă şi incluse între paranteze
pătrate [ ]. Ordinea expresiilor este dată de poziţia în care apar în listă. Dacă x este o lista, x[i]
desemnează elementul de pe poziţia i. Lista vidă este desemnată prin [ ].
x:=[8,7,a,b,9];
x := [ 8, 7, a, b, 9 ]
Asupra elementelor listei se pot efectua următoarele operaţii:
select( ) – selectează elementele după regula indicată, remove( ) – exclude din listă elementele care
nu respectă regula stabilită şi returnează elementele rămase, zip( ) – uneşte elementele a două liste
în una singură după careva regulă, op( ) - uneşte elementele a două liste în una singură (fără regulă)
sort( ) – sortează o listă după careva lege indicată.
Lungimea listei se consideră numărul de elemente ce o formează şi este redată de funcţia nops(x).
nops(x);
5
Următoarea operaţie redă elementul de pe poziţia i.
x[2];
7
Funcţia op(list) converteşte structura de listă în structură de tipul succesiune.
op(x);
8, 7, a, b, 9
Careva element din listă poate fi înlocuit. Acest lucru poate fi făcut în felul următor:
x; x[3]:=5;
[ 8, 7, 5, b, 9 ] x3 := 5

Pentru a şterge careva element din listă se foloseşte operatorul NULL:

subsop(1=NULL,x);
[ 7, 5, b, 9 ]
sau
x[2]:='NULL';
x2 := NULL

x;
[ 8, a, b, 9 ]
Set – mulţime: o colecţie de obiecte distincte, de acelaşi tip. Valorile unei mulţimi sunt separate
prin spaţiu şi incluse în { }.
x:={a,b,c,d,e};
x := { a, b, c, d, e }
Puterea unei mulţimi este definită de numărul de elemente ce se conţin în ea şi se calculează cu
ajutorul funcţiei:
nops(x);
5
Pentru a selecta careva element din mulţime se foloseşte construcţia:
x[3];
c
Funcţia op converteşte mulţimea în succesiune:
op(x);
a, b, c, d, e
Mulţimea vidă se defineşte în felul următor:
y:={}; nops(y);
y := { } 0
Asupra mulţimilor pot fi efectuate operaţiile: reuniune, diferenţă, intersecţie.

Exemplul 1.14
x:={1,2,3,4,5,6}; y:={1,2,7,8,9};
x := { 1, 2, 3, 4, 5, 6 } y := { 1, 2, 7, 8, 9 }
x union y; x minus y;
{ 1, 2, 3, 4, 5, 6, 7, 8, 9 } { 3, 4, 5, 6 }
x intersect y;
{ 1, 2 }
Array – tablou: este o structură formată dintr-un număr fix de componente, toate de acelaşi tip,
numite elemente. Selectarea unui element al masivului se face cu ajutorul numelui variabilei urmat
de indice cuprins în paranteze pătrate. Indicele precizează poziţia elementului în cadrul masivului.
Masivele pot fi vectori (masiv unidimensional) şi matrice (masiv bidimensional). Declararea unui
masiv se face după următoarea construcţie:
A:=array(m..n, [elementele vectorului separate prin virgulă]);
A:=array(m..n,m..n, [[el liniei m1 separate prin virgulă],[el liniei m2 separate prin
virgulă],…,[el liniei mn separate prin virgulă]]);
unde m x n este dimensiunea tabloului.
Limbajul Maple nu defineşte în mod automat elementele masivului, deaceea imediat după
declararea tabloului, elementele lui se consideră nedefinite.
A:=array(1..9):print(A);
[ A1, A2, A3, A4, A5, A6, A7, A8, A9 ]

Apelul către tablou se face prin identificatorul său, iar către elementele tabloului prin
identificatorul indexat. Putem defini tablourile în mai multe moduri.
A:=array(1..3,1..3,[[1,2,3],[4,5,6],[7,8,9]]);
1 2 3
 
A :=  4 5 6
 
7 8 9
A:=array(1..2,1..2,[]): A[1,1]:=1: A[1,2]:=2: A[2,1]:=3: A[2,2]:=4: print(A);
1 2
 
3 4
Afişarea unui tablou se face cu ajutorul funcţiilor: print, eval, evalm.
eval(A); evalm(A);
1 2 3 1 2 3
   
4 5 6 4 5 6
 
   
7 8 9 7 8 9
Funcţiile eval, evalm au rolul nu numai de a afişa la ecran tabloul, dar şi a returna rezultatul
operaţiilor efectuate asupra tabloului.

Exemplul 1.15
A:=array(1..2,1..2,[]): A[1,1]:=1: A[1,2]:=2: A[2,1]:=3: A[2,2]:=4: print(A);
 1 2
 
3 4
B:=array(1..2,1..2,[[5,6],[7,8]]); evalm(A+B);

B := 
5 6  6 8
  
7 8 10 12

evalm(A &*B); evalm(B-A);

19 22 4 4
   
43 50 4 4
Hfarray – este un subtip al tipului tablou. Este folosit pentru crearea tablourilor elementele căruia
se formează din calculele numerice efectuate de calculator.
a:=hfarray([evalf([sqrt(15), sqrt(87)]), evalf([sqrt(124), sqrt(591)])]);

a :=  
3.87298334599999982 9.32737905299999959

11.1355287300000008 24.3104915599999991
Vectorul – este un masiv unidimensional. Formatul general este:
vector([X1, X2, ..., Xn]) sau vector(n, [X1, X2, ..., Xn]).

Exemplul 1.16
v:=vector([1,2,3]); v1:=vector(5,[1,2,3,6,5]);
v := [ 1, 2, 3 ] v1 := [ 1, 2, 3, 6, 5 ]
vector(4, 3);
[ 3, 3, 3, 3 ]
Matrix – matricea este un masiv bidimensional. Formatul general este:
M:=matrix(m,n,[elementele matricii separate prin virgulă]);
M:=matrix([[elementele primei linii separate prin virgulă], [elementele liniei 2 separate prin
virgulă],..., [elementele liniei n separate prin virgulă]]);
Operaţiile ce se pot efectua asupra matricilor şi vectorilor vor fi explicate mai detaliat în paragraful
2.1.
Table – este o continuare a tipului tablou, utilizat foarte des de Maple, în special atunci când se
lucrează cu diferite tipuri de obiecte de tip tabel. Tabelul este o generalizare a masivului
bidimensional. În calitate de indicele al matricii pot fi folosite nu numai valori întregi, dar și
expresii arbitrare. În calitate de linie şi coloană pot fi folosite valorile tipului char şi string.
Caracteristic tabelului este abilitatea de a lucra cu structurile de date care includ notaţii complete
(numele complet, titluri, etc.). Formatul general al tipului dat este:
T:=table( [x1,x2,...,xn]) sau T:= table({X1, X2 ,..., Xn})

Exemplul 1.17
d:=table([Maria=25, Victoria=30,Ion=15]);
d := table([Ion15, Maria25, Victoria30])
d[Ion];
15
d[1]:=NULL;
d1 :=

print(d);
table([1( ), Ion15, Maria25, Victoria30])
Asupra elementelor tipului tablou se poate de operat cu aceleaşi funcţii ca şi pentru tipul masiv
(print, eval, evalm).

 Numere aleatoare

rand: - iniţializarea procedurii. Procedura dată poate fi definită în unul din cele 3 moduri:
- rand(); - returnează în mod aleator un număr întreg nenegativ de lungimea 12.
914825136973
- Următorul mod de definire rand(n..p) (unde n, p valori întregi şi n<p ) returnează în mod
aleator un număr întreg nenegativ de pe intervalul [n .. p].

- rand(n) returnează în mod aleator un număr întreg nenegativ de pe intervalul [0 .. n].

Pentru stabilirea valorii iniţiale a generatorului de numere aleatoare se foloseşte procedura _seed,
care are iniţial valoarea 427419669081. Valoarea dată poate fi modificată de utilizator în orice
moment printr-o simplă atribuire.
O altă procedură care operează cu numerele aleatoare este randomize.