subget

Kümeler
Küme ile liste kavramları matematikte de Maple’da da benzer biçimde tanımlıdır. Bir
kümede bir eleman bir defa yer alırken listede birden fazla yer alabilir.
Maple’da küme gösterimi için { } , liste gösterimi için ise [ ] kullanılır.
Elemanları 1,1,2,2,2,3,4,5 ‘ten oluşan küme ve liste aşağıdaki şekildedir.
> B:={1,1,2,2,2,3,4,5}; C:=[1,1,2,2,2,3,4,5];
B := { 1, 2, 3, 4, 5 }
C := [ 1, 1, 2, 2, 2, 3, 4, 5 ]
Küme ve liste vesair gibi çok elemanlı nesnelerin eleman sayısını bulmak için nops( );
komutu kullanılır.
> nops(A);
5
> nops(B);
5
> nops(C);
8
B ve C’deki üçüncü elemanları bulmak için
> B[3];
3
> C[3];
2
komutu kullanılır. Eğer B ve C’deki kendileri de dahil olmak üzere 2 ila 4 arasındaki
elemanları bulmak istersek;
> B[2..4];
{ 2, 3, 4 }
> C[2..4];
[ 1, 2, 2 ]
komutu kullanılır.
Bir nesnenin bir kümede olup olmadığı member(nesne,küme); komutu ile bulunur. Çıktı
olarak true yada false cevabı verilir.
> A:={-1,2,3,a,nisan};
A := { -1, 2, 3, a, nisan }
> member(-1,A);
true
> member(4,A);
false
Bir nesnenin bir A kümesinin elemanı olup olmadığı şu şekilde de kontrol edilebilir.
> restart;
> A:={1,2,3,4,5,6};
A := { 1, 2, 3, 4, 5, 6 }
> 1 in A;
1  { 1, 2, 3, 4, 5, 6 }
> is (1 in A);
true
> evalb(1 in A);
true
> 0 in A;
0  { 1, 2, 3, 4, 5, 6 }
> is(0 in A);
false
> evalb(0 in A);
false
AltKüme
Bir A kümesinin bir B kümesinin altkümesi olup olmadığı verify(A,B,`subset`); komutu ile
bulunur.
> restart;
> A:={a,b,c};
A := { a, b, c }
> B:={b};
B := { b }
> verify(B,A,`subset`);
true
> A subset B;
false
> B subset A;
true
> verify({a,b,c},{a,b,c,d,e},`subset`);
true
Bir A kümesinin tüm altkümelerini bulmak için comsturct[allstructs](Subset(A)); komutu
kullanılır.
> restart;
> A:={a,b,c};
A := { a, b, c }
> combstruct[allstructs](Subset(A));
{ { }, { a }, { b }, { c }, { a, b }, { a, c }, { b, c }, { a, b, c } }
> combstruct[allstructs](Subset({a,b,c}));
{ { }, { a }, { b }, { c }, { a, b }, { a, c }, { b, c }, { a, b, c } }
Bir kümenin tüm altkümelerini buldurmanın bir başka yolu da aşağıda verilmiştir;
> with(combinat):
> S:=subsets({a,b,c}): while not S[finished] do S[nextvalue]()
od;
{ }
{a}
{b}
{c}
{ a, b }
{ a, c }
{ b, c }
{ a, b, c }
n elemanlı bir kümenin r elemanlı altkümelerinin sayısı binomial(n,r); komutu ile bulunur.
> binomial(3,2);
3
> binomial(12,8);
495
A ve B kümelerinin arakesiti A intersect B; , birleşimi A union B; , A-B kümesi ise A
minus B; komutları ile bulunur.
> restart;
> A:={a,b,c,d,e,f,g};
A := { a, b, c, d, e, f, g }
> B:={b,c,e,k,l,m};
B := { b, c, e, k, l, m }
> A intersect B;
{ b, c, e }
> A union B;
{ a, b, c, d, e, f, g, k, l, m }
> A minus B;
{ a, d, f, g }
> C:={1,2,3,a,b,d,e};
C := { 1, 2, 3, a, b, d, e }
> A union B union C;
{ 1, 2, 3, a, b, c, d, e, f, g, k, l, m }
> (A union B) intersect C;
{ a, b, d, e }
> (A intersect C)union(B intersect C);
{ a, b, d, e }
Maple’ın hızlı çalışabilmesi için başlangıçta temel matematik işlemlerini yazabileceğimiz
komutlar yüklenir. Çok özel veya sık kullanılmayan komutlar yüklü değildir. Gerektiğinde
komutların yüklü olduğu paketler açılmalıdır. Paketler with(paket adı) şeklinde açılır.
A ve B kümelerinin kartezyen çarpımı cartprod([A,B]); komutu ile bulunur. Bu komut
combinat paketi içerisindedir. Aşağıdaki örneği inceleyiniz.
> restart;
> A:={1,2,3}; B:={a,b};
A := { 1, 2, 3 }
B := { a, b }
> with(combinat);
[ Chi, bell , binomial , cartprod , character , choose, composition , conjpart , decodepart ,
encodepart , eulerian1 , eulerian2 , fibonacci , firstpart , graycode , inttovec , lastpart ,
multinomial , nextpart , numbcomb, numbcomp, numbpart, numbperm, partition ,
permute, powerset, prevpart, randcomb, randpart, randperm, setpartition , stirling1 ,
stirling2 , subsets, vectoint ]
> cartprod([A,B]);
table([finished false, nextvalue( proc() ... end proc)])
> K:=cartprod([A,B]);
K := table([finished false, nextvalue( proc() ... end proc)])
> while not K[finished] do K[nextvalue]() end do;
[ 1, a ]
[ 1, b ]
[ 2, a ]
[ 2, b ]
[ 3, a ]
[ 3, b ]
> C:={ali,veli};
C := { ali, veli }
> L:=cartprod([A,B,C]);
L := table([finished false, nextvalue( proc() ... end proc)])
> while not L[finished] do L[nextvalue]() od;
[ 1, a, ali ]
[ 1, a, veli ]
[ 1, b, ali ]
[ 1, b, veli ]
[ 2, a, ali ]
[ 2, a, veli ]
[ 2, b, ali ]
[ 2, b, veli ]
[ 3, a, ali ]
[ 3, a, veli ]
[ 3, b, ali ]
[ 3, b, veli ]