Prosedürler
Bir Maple oturumunda bir işlem farklı argümanlar için çok defa tekrarlanacaksa
prosedür kullanmak uygun olacaktır. Genel kullanımı,
Prosedür adı:= proc(prosdür değişkenleri)
komut1;
komut2;
...
end proc;
şekindedir. Aşağıdaki örnekleri inceleyelim.
> kare:=proc(n)
n*n;
end proc;
kare := proc(n) nn end proc
> kare(2);
4
> kare([1,3]);
[ 1, 3 ]2
> kare(x);
x2
> kare(1.2);
1.44
> n;
n
Prosedür değişkenleri belli özellikte olsun istenirse komut proc(n::istenilen özellik)
şeklinde kullanılmalıdır.
> küb:=proc(n::integer)
n*n*n;
end proc;
küb := proc(n::integer ) nnn end proc
> küb(4);
64
> küb(-3);
-27
> küb(a);
Error, invalid input: küb expects its 1st argument, n, to be of type
integer, but received a
> küb(ali);
Error, invalid input: küb expects its 1st argument, n, to be of type
integer, but received ali
> küb(1.2);
Error, invalid input: küb expects its 1st argument, n, to be of type
integer, but received 1.2
> n;
n
Eğer bir prosedürdeki değişenin hem tamsayı hem de ondalıklı sayı olması istenirse
komut proc(n::{integer,float}) şeklinde kullanılmalıdır.
> restart;
> küb:=proc(n::{integer,float})
n*n*n;
end proc;
küb := proc(n::{ float , integer }) nnn end proc
> küb(2);
8
> küb(-2);
-8
> küb(0.5);
0.125
> küb(a);
Error, invalid input: küb expects its 1st argument, n, to be of type
{float, integer}, but received a
Eğer yazılan prosedür bir x değeri için tanımsızsa hata mesajı yerine isminin verilmesi
daha uygun olabilir.
> restart;
> küp:=proc(n)
if type(n, integer) or type(n,float) then
n*n*n;
else
'procname(args)';
end if;
end proc;
küp := proc(n)
if type( n, integer ) or type( n, float ) thennnn els e 'procname( args )' end if
end proc
> küp(2);
8
> küp(-2.1);
-9.261
> küp(a);
küp( a )
> küp(0.5);
0.125
> küp(1/2);
1
küp 
2
> küp(evalf(1/2));
0.1250000000
Bir sayının ondalıklı kısmını atarak kalan kısmı veren komut trunc(sayı) komutudur.
Aşağıdaki örnekleri inceleyelim.
> restart;
> trunc(1.2);
1
> trunc(5);
5
> trunc(1/2);
0
> trunc(-5/4);
-1
> plot(trunc(x),x=-3..3,discont=true);
Örnek: Verilen bir pozitif tamsayının 1 ve kendisinden başka bölenlerini hesaplayan bir
prosedür yazınız.
> restart;
> bölen:=proc(n)
for i from 1 to n-1 do
if evalf(n/i)=trunc(evalf(n/i)) then
print(i)
end if;
end do;
end proc;
Warning, `i` is implicitly declared local to procedure `bölen`
bölen := p roc(n)
local i;
for i to n1 do if evalf( n/i )trunc( evalf( n/i ) ) thenprint( i ) end if end do
end p roc
> bölen(20);
1
2
4
5
10
> bölen(13);
1
Bir prosedür içinde yer alan değişken veya değişkenler sadece o prosedürün içinde kalır.
> k;
k
> k:=13;
k := 13
> kuv:=proc(x,n::posint)
for k from 1 to n do
print(x^k);
end do;
end proc;
Warning, `k` is implicitly declared local to procedure `kuv`
kuv := proc(x, n::posint ) local k; for k to n do print( x^k ) end doend proc
> kuv(5,3);
5
25
125
> kuv(12,7);
12
144
1728
20736
248832
2985984
35831808
> k;
13
> x;
x
> n;
n
> kuv(2,-3);
Error, invalid input: kuv expects its 2nd argument, n, to be of type
posint, but received -3
Eğer bir x değişkeninin prosedür içinde aldığı değerin prosedür dışında da korunması
isteniyorsa prosedür içine glabal x; komutu yerleştirilmelidir.
> k;
13
> kuv:=proc(x,n::posint)
global k;
for k from 1 to n do
print(x^k);
end do;
end proc;
kuv := proc(x, n::posint ) global k; for k to n do print( x^k ) end doend proc
> kuv(2,3);
2
4
8
> k;
4
Bir prosedür yazılırken içinde kendisini de kullanmak mümkündür. Örneğin faktöriyel
hesabı yapan bir prosedür yazalım.
> car:=proc(n::nonnegint)
if n=0 then 1 else n*car(n-1) end if;
end proc;
car := proc(n::nonnegint ) if n0 then1 else ncar( n1 ) end if end proc
> car(0);
1
> car(3);
6
> 3!;
6
> car(111);
176295255109024466387216104710707578876140953602656551604157406334
734695508724831643655557459846231577319604766283797891314584749
7199871623320096254145331200000000000000000000000000
\
\
> 111!;
176295255109024466387216104710707578876140953602656551604157406334
734695508724831643655557459846231577319604766283797891314584749
7199871623320096254145331200000000000000000000000000
\
\
Örnek: Bir x tamsayısı için 1’den x’e kadar olan sayıların toplamını bulan Maple prosedürü
yazınız. Aynı prosedürü for-while döngüsü ile yazınız.
> restart;
> toplam:=proc(n::posint)
top:=0;
for i from 1 to n do
top:=top+i
end do;
end proc;
Warning, `top` is implicitly declared local to procedure `toplam`
Warning, `i` is implicitly declared local to procedure `toplam`
toplam :=
p roc(n:: posint ) local top , i; top := 0 ; for i to n do top := top i end do end p roc
> toplam(10);
55
> toplam(0);
Error, invalid input: toplam expects its 1st argument, n, to be of type
posint, but received 0
> toplam(-3);
Error, invalid input: toplam expects its 1st argument, n, to be of type
posint, but received -3
***
> toplam1:=proc(n::posint)
top:=0;
for i from 1 while i<=n do
top:=top+i;
end do;
end proc;
Warning, `top` is implicitly declared local to procedure `toplam1`
Warning, `i` is implicitly declared local to procedure `toplam1`
toplam1 := p roc(n:: posint )
local top , i;
top := 0 ; for i w hile in do top := top i end do
end p roc
> toplam1(10);
55
> toplam(0);
Error, invalid input: toplam expects its 1st argument, n, to be of type
posint, but received 0
Bir sayının mükemmel sayı olup olmadığına dair bir örnek verelim.
> mukemmel:=proc(n::posint)
local bolenler,t,top;
bolenler:=numtheory[divisors](n);
t:=convert(bolenler,`+`);
top:=t-n;
if n=top then print(n, mükemmeldir) else
print(n, "mükemmel değildir")
end if;
end proc;
mukemmel := p roc(n:: posint )
if ntop thenprint( n, `mükemmeldir` )
local bolenler , t, top ;
els e print( n, "mükemmel deðildir" )
bolenler := numtheory[ divisors ]( n ) ;
end if
end p roc
t := convert( bolenler , `+` ) ;
top := tn;
> mukemmel(6);
6, mükemmeldir
> mukemmel(28);
28, mükemmeldir
> mukemmel(8128);
8128 , mükemmeldir
> mukemmel(100);
100 , "mükemmel deðildir"
Download

end proc