Войти Регистрация

Docx

  • Рефераты
  • Дипломные работы
  • Прочее
    • Презентации
    • Рефераты
    • Курсовые работы
    • Дипломные работы
    • Диссертациии
    • Образовательные программы
    • Инфографика
    • Книги
    • Тесты

Информация о документе

Цена 35000UZS
Размер 440.8KB
Покупки 0
Дата загрузки 21 Апрель 2025
Расширение docx
Раздел Курсовые работы
Предмет Алгебра

Продавец

Telzor Uchun

Дата регистрации 21 Апрель 2025

7 Продаж

Integrallarni taqribiy hisoblashda to'g'ri to'rtburchak formulasining matlab dasturi tadbig’i

Купить
O‘ZBEKISTON RESPUBLIKASI OLIY TA’LIM FAN VA
INNOVATSIYALAR VAZIRLIGI
URGANCH DAVLAT UNIVERSITETI
“FIZIKA MATEMATIKA” FAKULTETI
“Matematik injinering” yo‘nalishi 211-guruh talabasi
Sharipboyev Jumanazarning
“Sonli usullar ”
Fanidan tayyorlagan
KURS ISHI
Mavzu:  Integrallarni taqribiy hisoblashda to'g'ri to'rtburchak formulasining matlab
dasturi tadbig’i.
Topshirdi:                                                                    Sharipboyev J.
Qabul qildi:                                                                 Qurbandurdiyev.Sh. MAVZU: INTEGRALLARNI TAQRIBIY HISOBLASHDA TO'G'RI
TO'RTBURCHAK FORMULASINING MATLAB DASTURI TADBIG’I.
MUNDARIJA: 
KIRISH................................................................................................................3
I.BOB. KVADRATUR FORMULALAR YORDAMIDA INTEGRAL 
TENGLAMALARNI TAQRIBIY YECHISH................................................4
1.1.  Eng sodda kvadratur formulalar: to`g`ri to`rtburchak, trapetsiya va
Simpson formulalari ............................................................................................4
1.2.  Umumlashgan   to`g`ri to`rtburchak formulalasi va uning
qoldiq hadi .........................................................................................................10
II.BOB. DASTURINI ISHLAB CHIQISH...................................................14
2.1.  Dastur dizayni ............................................................................................13
2.2.  Amalga oshirish. Matlab dasturi ................................................................16
XULOSA..........................................................................................................44
FOYDALANILGAN ADABIYOTLAR........................................................46
2 KIRISH
Raqamli   integratsiya   hisoblash   matematikasining   asosiy   usuli   bo'lib,   aniq
integrallarning   qiymatini   taxmin   qilish   uchun   ishlatiladi.   Bunga   erishish   uchun
turli usullar ishlab chiqilgan, ularning har biri o'zining afzalliklari va cheklovlariga
ega.   Ushbu   usullar   orasida   to'rtburchaklar   usuli   tartibsiz   sohalar   bo'yicha
integrallarni   yaqinlashtirishda   soddaligi   va   samaradorligi   bilan   ajralib   turadi.
Ushbu   kurs   ishi   aniq   integrallarni   taxminiy   hisoblash   uchun   to'rtburchaklar   usuli
dasturini   ishlab   chiqish   va   amalga   oshirishni   o'rganadi.   Maqola   uchta   bobdan
iborat:   (1)   Nazariy   ma'lumot,   (2)   To'rt   tomonlama   metod  dasturini   ishlab   chiqish
va (3) Natijalar va tahlil.
Ushbu   kurs   ishining   maqsadi   aniq   integrallarni   yaqinlashtirishning
to'rtburchaklar   usulini   o'rganishdir.   O'rta   nuqta   yoki   Rieman   yig'indisi   usuli
sifatida ham tanilgan bu usul eng oddiy sonli integratsiya usullaridan biridir. Kurs
ishi quyidagi jihatlarni qamrab oladi:
To'rtburchaklar   usulining   matematik   formulasi   va   tamoyillarini   tushunish.
Implementation:   To'rtburchak   usulni   amalga   oshirish   uchun   kompyuter   dasturini
ishlab chiqish. Ilova: To‘rtburchak usuldan foydalanishni misollar bilan ko‘rsatish
va uning aniqligi va cheklovlarini muhokama qilish.
3 I BOB.    KVADRATUR FORMULALAR YORDAMIDA INTEGRAL
TENGLAMALARNI TAQRIBIY YECHISH
1.1. Eng sodda kvadratur formulalar: to`g`ri to`rtburchak, trapetsiya va
Simpson formulalari.
Berilgan   [a,b]   kesmada   uzluksiz   bo`lgan   f(x)   funksiya   uchun   F(x)
boshlang`ich   funksiyani   topish   mumkin   bo`lsa,   N`yuton   Leybnits   formulasi
bo`yicha     aniq   integralni   hisoblagan   edik.   Lekin   har   qanday   uzluksiz
funksiya   uchun   uning   boshlang`ich   funksiyasini   hamma   vaqt   topish   qiyin,   bazi
hollarda   esa   boshlang`ich   funksiyani   elementar   funksiyalar   orqali   ifodalab
bo`lmaydi. 
Masalan.
Bunday   hollarda   N`yuton   Leybnits   formulasidan   foydalana   olmaymiz.
Shuning   uchun   ularni   taqriban   bo`lsa   ham   hisoblashga   to`g`ri   keladi.   Aniq
integrallarni   taqribiy   hisoblaydigan   bir   qancha   usullar   mavjud.   Ushbu   paragrifda
ulardan   uchtasini:   to`g`ri   to`rtburchaklar,   trapetsiyalar   hamda   parabola   (Sinpson)
usullarini keltiramiz.
  kesmada     aniqlangan   va   uzluksiz   bo`lgan     funksiyadan   olingan
  integralni hisoblashni ko`raylik.
  Y                                 d
        )	(x	f	y
4	
)	(x	f           c 
         y
0    y
1  y
2   y
3            y
n
0         a=x
0    x
1  x
2           
 kesmani b	x	x	x	x	a	n						...	2	1	0  nuqtalar bilan uzunliklari birxil, ya`ni 	x  
bo`lgan  n ta teng bo`laklarga ajrataylik.
 bo`lsin. Endi 	
)	(x	f	y  funksiyaning 	nx	x	x	x	,...,	,	,	2	1	0  nuqtalardagi 
qiymatlarini mos ravishda 	
)	(	),...,	(	),	(	),	(	2	2	1	1	0	0	n	n	x	f	y	x	f	y	x	f	y	x	f	y				  deb belgilab
quyidagi yig`indilarni tuzaylik.
  va
Bu yig`indilarning har biri   funksiya uchun   kesmada tuzilgan 
integral yig`indi bo`ladi. Shuning uchun   integralning taqribiy qiymati 
                               (1)
                                  (2)
(1) va (2) formulalar to`g`ri to`rtburchaklar formulasi deyiladi. 
Chizmadan ko`rinadiki agar    musbat va o`suvchi funksiya bo`lsa, u holda (1)
formula   ichki   chizilgan   to`g`ri   to`rtburchaklardan   tuzilgan   zinapoyasimon
shaklning   yuzini   tasvirlaydi.   (2)   formula   esa   tashqi   to`rtburchaklardan   tuzilgan
zinapoyasimon   shaklning   yuzini   tasvirlaydi.   Bu   formulalar   bilan   hisoblanganda
qo`yiladigan   xatolik   n   soni   qancha   katta   bo`lsa,   ya`ni     qancha   kichik
bo`lsa, shuncha kam bo`ladi. 
5	
)	(x	f		b	а,	

b
a	
dx	x	f	)	(	

b
a	
dx	x	f	)	(		 1210	... 						n	y	y	y	y	n
a	b	

b
a	
dx	x	f	)	(	
)	(x	f	
n
a	b	x			 Misol.    integralni n=10 bo`lgan holda to`g`ri to`rtburchaklar 
formulasi bilan hisoblang.
Yechish.  
;
Agar (1) formula bo`yicha hisoblasak    
Endi Nyuton-Leybnis  formulasi bo`yicha hisoblaylik
=
haqiqatan integralning qiymati   kesmada bo`lar ekan.
Eng   sodda   kvadratur   formulalarni   oddiy   mulohazalar   asosida   qurish
mumkin.                           Aytaylik,   integralni   hisoblash   talab   qilinsin.   Agar
qaralayotgan        oraliqda   bo`lsa, u vaqtda
6 2
1 dxх1,0	10	
1	2	   ;	10	   ;	)	(								x	n	x	x	f	y	
4,1	   ;3,1	     ;2,1	1,0	1,1	 	   ;1,1	1,0	1	  ;1	  :	4	3	1	2	0	1	0														x	x	x	x	x	x	x	x	x	x	
.2	   ;9,1	   ;8,1	     ;7,1	   ;6,1	  ;5,1	 	10	9	8	7	6	5							x	x	x	x	x	x	
	2,1                                         (2.1)
 
   
                                                                     
1-rasm                                      2-rasm
                                                                                       
deb   olishimiz   mumkin   (1-rasm).   Bu   formula   to`g`ri   to`rtburchaklar
formulasi  deyiladi.
Faraz qilaylik,   f(x)  funksiya chiziqli funksiyaga yaqin bo`lsin, u holda tabiiy
ravishda   integralni   balandligi   ( b   -   a )   ga   va   asoslari   f(a)   va   f(b)     ga   teng   bo`lgan
trapetsiya yuzi bilan almashtirish mumkin (2-rasm),  u holda
                                     (2.2)
 
deb   olishimiz   mumkin.   Bu   formula   trapetsiya   formulasi   deyiladi.   Nihoyat,
f(x)  funksiya [ a, b ] oraliqda kvadratik funksiyaga yaqin bo`lsin, u holda   
ni   taqribiy   ravishda   O
x   o`qi   va   х = а ,   х =b   to`g`ri   chiziqlar   hamda   у   =   f(x)
funksiya   grafigining   absissalari  x=	a,x=	a+b
2	va	x=b   bo`lgan   nuqtalaridan
7 o`tuvchi   ikkinchi   tartibli   parabola   orqali   chegaralangan   yuz а   bilan   almashtirish
mumkin (3-rasm), u holda quyidagiga ega bo`lamiz:
                               (2.3)
3-rasm                                     4-rasm
Bu formulani ingliz matematigi Simpson 1743 yilda taklif etgan edi.
Bu formulaning hosil qilinishi usulidan ko`rinib  turibdiki, u barcha ikkinchi
darajali  
 
ko`phadlar   uchun   aniq   formuladir.   Shunday   qilib,   biz   uchta   eng   sodda
kvadratur   formulalarga   ega   bo`ldik.   (2.1)   formulani   tuzishda   u   o`zgarmas   son
f(x)=   с   ni aniq integrallashini talab qilgan edik. Lekin u   f(x) =   а
0   +   а1 х   chiziqli
funksiyani ham aniq integrallaydi, chunki:
  balandligi   (b-a)   va   o`rta   chiziqi     bo`lgan
ixtiyoriy trapetsiyaning yuziga teng (4-rasm). 
Shunga   o`xshash   Simpson   formulasi   ham   biz   kutgandan   ko`ra   ham
yaxshiroq formuladir. U uchinchi darajali   
  ko`phadlarni ham aniq integrallaydi.
Haqiqatan ham, uchinchi darajali  Р
3 ( х )   ko`phadni quyidagicha 
8  yozamiz:
u vaqtda   
P
3 (x)dx=      P
2 (x)dx +   a
3      x 3
dx  =      P
2 (x)dx+(    /4)(b 4
 - a 4
)     (2.4)
Lekin bizga ma`lumki, 
                                     
a
b
P2(x)dx	=	b−	a
6	[P2(a)+4P2(a+b
2	
)+a3b3
]
(2.5)                                                                                      
Ikkinchi tomondan,  
                    (2.6)                                 
ayniyat o`rinlidir  . Endi (2.5) - (2.6) ni (2.4) ga qo`yib, 	

a
b	
P3(x)dx	=	b−	a
6	{P3(a)+4P3(a+b
2	
)+P3(b)}
ni hosil qilamiz.
Shunday   qilib,   biz   uchta   kvadratur   formulani   ko`rdik.   Ulardan   ikkitasi
to`g`ri to`rtburchak va trapetsiya formulalari birinchi darajali ko`phad uchun aniq
formula   bo`lib,   Simpson   formulasi   uchinchi   darajali   ko`phad   uchun   aniq
formuladir.
9	

b
a	

b
a	
a3	
a
b	

a
b 1.2.  Umumlashgan to`g`ri to`rtburchak formulalasi va uning
qoldiq hadi
Berilgan   [a,b]   oraliqni     (k=0,   N)   nuqtalar   yordamida   uzunligi
  bo’lgan  N   ta   bo’lakka   bo’lamiz.   Xar   bir   qismiy   oraliq  [ ]   bo’yicha
olingan integralga (2.1) formulani qo’yamiz:
                    (2.7)
Qulaylik   uchun     kabi   belgilab   (2.7)   ni   barcha
  lar   bo’yicha   yig’ib   chiqsak,   natijada   umumlashgan   to’g’ri
to’rtburchaklar formulasiga ega bo'lamiz: 
                      (2.8)
Bu formulaning qoldiq hadi   ni toppish uchun (2.23) ning 
                      (2.9)
qoldiq hadini barcha   lar bo’yicha yig’amiz, natijada 
                                    (2.10)
Ravshanki, 
Ikkinchi   hosilaning   uzluksizligidan,   koshi   teoremasiga   ko’ra,   shunday
 mavjudki, 
Buni   (2.29)   ga   olib   borib   qo’ysak,   umumlashgan   to’g’ri   to’rtburchaklar
formulasining qoldiq hadi xosil bo’ladi:
                         (2.11)
10 To`g`ri to`rtburchak , trapetsiya va Simpson formulalarining qoldiq hadlari
Endi   yuqorida   qurilgan   kvadratur   formulalarning   qoldiq   hadlarini   aniqlash
bilan shug`ullanamiz.  To`g`ri to`rtburchak formulasining qoldiq hadi
ni topish uchun   f(x)   funksiya [ a, b ] oraliqda ikkinchi  tartibli uzluksiz   f"(x)
hosilaga ega bo`lsin deb faraz qilamiz. U holda Teylor formulasiga ko`ra:
bu yerda       Bu tenglikning har ikkala tomonini   a   dan   b
gacha integrallasak  
                        
kelib   chiqadi,   chunki    
a
b	
(x−	a+	b
2	)dx	=	0.     Quyidagicha   belgilash
kiritaylik:                                                          
т   = 	
min
a≤x≤b	
f''(x),M	=	max
a≤x≤b	
f''(x)
Integral ostidagi funksiya     o`z ishorasini saqlaydi, shuning uchun
(2.7) integralga umumlashgan o`rta qiymat haqidagi teoremani qo`llash mumkin:
            	
R0(f)=	L
a
b	
(x−	a+	b
2	)
2
dx	=	L	(b−	a)3	
24                           (2.13)                                                             
bunda  	
m≤	L≤	M	,	f'(x)   uzluksiz   bo`lgan   uchun   Koshi   teoremasiga   ko`ra
shunday  	
ξ , 	a≤	ξ≤	b  topiladiki,  L=	f''(ξ) . E ndi (2.8) tenglikni quyidagicha yozish
mumkin:
11                       R0(f)=	(b−	a)3	
24	f''(ξ)                                            (2.14)                                              
Bu esa qoldiq hadning izlanayotgan ko`rinishidir. 
Endi   trapetsiya   formulasining   qoldiq   hadini   topaylik.   Buning   uchun     f(x)
funksiyani   x   =   a   va   x   =   b   nuqtalardagi   qiymatlari   yordamida   interpolyatsiyalab,
interpolyatsion formulani qoldiq  hadi bilan yozamiz:
Bu tenglikning har  ikkala tomonini  a  dan  b  gacha integrallaymiz, natijada
hosil   bo`ladi.   Bu   yerda   [ a,b   ]   oraliqda   (x-a)(x-b)	
¿ 0   bo`lgani   uchun   R
1 (f)
integralga o`rta qiymat haqidagi umumlashgan teoremani qo`llash mumkin:
                          (2.15)                  
Nihoyat, Simpson formulasining qoldiq hadini aniqlaylik. Buning uchun 
с  = 0,5  (а +b)   deb olib, quyidagi 
,	
H	'(c)=	f'(c),H	(b)=	f(b)
shartlarni qanoatlantiruvchi Ermit interpolyatsion ko`phadini  tuzamiz:	
H	(x)=4
(a−b)3[(x−c)2(x−b)f(a)−(x−a)(x−b)(a−b)f(c)−	
−(x−a)(x−b)(x−c)(a−b)f'(c)−(x−a)(x−c)2f(b)]
Ravshanki,	

a
b
H	(x)dx	=	b−	a
6	[f(a)+4	f(
a+b
2	)+	f(b)]
Endi   funksiyalarni   interpolyatsiyalashga   ko`ra  
interpolyatsion formulaning qoldiq hadi
12 r(x) =1
24	
Ω	(x)fIV	(ς)	(a≤	ς≤	b)
bo`lib, bu yerda    
Demak, (2.3) formulaning qoldiq  hadi
R
2 (f) = 	
1
24	
a
b
Ω(x)fIV(ς)dx
bo`lib,    	
Ω (x)   ko`phad   [ a,   b ]   oraliqda   o`z   ishorasini   saqlaydi   va
umumlashgan o`rta qiymat teoremasiga ko`ra 	
R2(f)=−	(b−	a)5	
2880	fIV(ξ)(a≤ξ≤	b)
ga ega bo`lamiz.
Qoldiq  hadlar uchun chiqarilgan formulalar yana bir bor shuni ko`rsatadiki,
to`g`ri   to`rtburchak   va   trapetsiya   formulalari   birinchi   darajali   ko`phadlar   uchun
aniq   bo`lib,   Simpson   formulasi   uchinchi   darajali   kop`hadlar   uchun   aniq
formuladir.
 
13 II BOB.  TO'RT TOMONLAMA USUL DASTURINI ISHLAB CHIQISH.
2.1. Dastur dizayni.
Ushbu   bobda   tartibsiz   sohalarda   aniq   integrallarni   yaqinlashtirish   uchun
to'rtburchaklar   usuli   dasturini   loyihalash   va   amalga   oshirish   tafsilotlarini
muhokama   qilamiz.   Biz   dasturning   asosiy   komponentlarini,   jumladan,   domen
diskretizatsiyasini,   kvadratura   qoidalarini   amalga   oshirishni   va   dasturiy
ta'minotning umumiy tuzilishini ko'rib chiqamiz.
Amalga oshirish tafsilotlariga sho'ng'ishdan oldin, quyidagi dizayn jihatlarini
hisobga olish kerak:
Modullilik va qayta foydalanish imkoniyati
Dastur modullilikni hisobga olgan holda ishlab chiqilishi kerak, bu esa turli
integratsiya   vazifalari   uchun   osongina   moslashtirilishi   mumkin   bo'lgan   qayta
foydalanish mumkin bo'lgan komponentlarga imkon beradi. Modulli dizayn kodni
saqlash, disk raskadrovka va kelajakdagi yaxshilanishlarni osonlashtiradi.
Kirishning moslashuvchanligi
Dastur   integratsiya   domenini   va   integratsiya   qilinadigan   funktsiyani
belgilaydigan   ma'lumotlarni   qabul   qilishi   kerak.   U   foydalanuvchilarga
cho'qqilarning   koordinatalarini   taqdim   etish   yoki   chegara   tenglamalarini   aniqlash
orqali tartibsiz domenlarni belgilash imkonini berishi kerak.
Samaradorlik
Domenni   diskretlashtirish,   kvadratura   qoidalarini   qo'llash   va   global
integratsiyani   boshqarish   uchun   samarali   ma'lumotlar   tuzilmalari   va
algoritmlaridan   foydalanish   kerak.   Hisoblash   samaradorligini   oshirish   uchun
optimallashtirish   usullari   qo'llanilishi   mumkin,  ayniqsa   keng   ko'lamli   integratsiya
vazifalari uchun.
Xatolarni qayta ishlash va hisobot berish
Dastur   noto'g'ri   kirishlar,   raqamli   beqarorliklar   yoki   boshqa   ish   vaqtidagi
xatolar bilan kurashish uchun ishonchli xatolarni qayta ishlash mexanizmlarini o'z
ichiga   olishi   kerak.   Muammolarni   tashxislash   va   hal   qilishda   foydalanuvchilarga
14 yordam   berish   uchun   aniq   va   ma'lumot   beruvchi   xato   xabarlari   taqdim   etilishi
kerak.
Algoritm.   
To'rtburchaklar   usuli   dasturining   algoritmik   bajarilishi   tartibsiz   domenlar
bo'yicha aniq integrallarni aniq yaqinlashish uchun juda muhimdir. Ushbu bo'limda
biz dasturning bosqichma-bosqich algoritmini, jumladan domenni diskretlashtirish,
kvadratura qoidalarini qo'llash va global integratsiyani ko'ramiz.
Domenni diskretlashtirish
1.Kirish   domeni:   D   integratsiya   sohasini   belgilovchi   ma lumotniʼ
cho qqilarning koordinatalarini ko rsatish yoki chegara tenglamalarini taqdim etish	
ʻ ʻ
orqali qabul qiling.
2.Mesh   Generation:   Kirish   asosida   D   domenini   qoplaydigan   to'rtburchak
elementlar   to'rini   yarating.   Bu   domenni   kichikroq   to'rtburchak   elementlarga
bo'lish, tegishli qamrov va ruxsatni ta'minlashni o'z ichiga oladi.
3.Elementni   identifikatsiyalash:   Keyingi   hisob-kitoblar   davomida   mos
yozuvlar uchun har bir to'rtburchak elementga noyob identifikatorlarni tayinlang.
Kvadratlar qoidasini qo'llash
4.Kadratura   qoidasini   tanlash:   Kerakli   aniqlik   va   samaradorlik   asosida
tegishli kvadratura qoidasini (masalan, Gauss kvadraturasini) tanlang.
5.Kadratura   nuqtalari   va   vaznlari:   kvadratura   nuqtalarini   ( ??????
i , ??????
j )   va   mos
keladigan og irliklarni aniqlang. 	
ʻ
??????
j  tanlangan kvadratura qoidasi uchun.
6.Mahalliy yaqinlik: har bir to'rtburchak element Q
i  uchun , element ustidagi
integralni taxminan hisoblash uchun kvadratura qoidasini qo'llang:
bu erda m - kvadratura nuqtalari soni.
Global integratsiya
15 Xulosa:   butun   domen   bo'yicha   umumiy   integralni   olish   uchun   barcha
to'rtburchak elementlarning hissalarini yig'ing:
bu erda  ??????  - to'rtburchak elementlarning umumiy soni va 
i-element uchun og'irliklar va kvadratura nuqtalari 
O'z navbatida Q
i .
Xatolarni bartaraf etish
          Xatolarni   aniqlash:   Domen   diskretizatsiyasi,   kvadratura   qoidalarini
qo'llash   va   global   integratsiya   paytida   xatolarni   aniqlash   va   qayta   ishlash
mexanizmlarini amalga oshirish.
Xatolar   haqida   xabar   berish:   foydalanuvchilarga   muammolarni   hal   qilishda
va   integratsiya   natijalarining   ishonchliligini   ta'minlashda   yo'l-yo'riq   ko'rsatish
uchun informatsion xato xabarlarini taqdim eting.
  
16 2.2. Amalga oshirish.  Matlab dasturi
        Ushbu   bo'limda   biz   tartibsiz   domenlar   bo'yicha   aniq   integrallarni
yaqinlashtirish   uchun   to'rtburchak   usul   dasturini   amalga   oshirish   tafsilotlarini
muhokama qilamiz. Biz dasturning asosiy komponentlarini amalga oshirish uchun
ishlatiladigan   kod   tuzilishi,   ma'lumotlar   tuzilmalari   va   algoritmlarni   ko'rib
chiqamiz.  
Kod tuzilishi:
function main()
    % Domenni diskretlash uchun parametrlar
     x_min = 0; x_max = 4; % X koordinatlari
     y_min = 0; y_max = 3; % Y koordinatlari
    n = 2; % Har bir yo'nalishda elementlar soni
    % Domenni to'rtburchak elementlarga diskretlash
    elementlar = domenni_diskretlash(x_min, x_max, y_min, y_max, n);
    % Yaratilgan to'rtburchak elementlarni chiqarish
    for i = 1:length(elementlar)
                fprintf('Element   ID:   %d,  Koordinatalar:   [(%.2f,  %.2f),  (%.2f,   %.2f),
(%.2f, %.2f), (%.2f, %.2f)]\n', ...
            elementlar(i).id, ...
            elementlar(i).x1, elementlar(i).y1, ...
            elementlar(i).x2, elementlar(i).y2, ...
            elementlar(i).x3, elementlar(i).y3, ...
            elementlar(i).x4, elementlar(i).y4);
    end
end
function   elementlar   =   domenni_diskretlash(x_min,   x_max,   y_min,   y_max,
n)
    % Domenni diskretlash uchun to'rtburchak elementlarni yaratish
     elementlar = struct('id', {}, 'x1', {}, 'y1', {}, 'x2', {}, 'y2', {}, 'x3', {}, 'y3',
{}, 'x4', {}, 'y4', {});
17      % X va Y yo'nalishlarida qadamlar
    dx = (x_max - x_min) / n;
     dy = (y_max - y_min) / n;
    id = 1; % Element identifikatori
    % Domenni qamrab oluvchi to'rtburchak elementlarni yarating
     for i = 0:n-1
        for j = 0:n-1
             % To'rtburchakning uchlarini aniqlash
            x1 = x_min + i * dx; y1 = y_min + j * dy;
            x2 = x_min + (i + 1) * dx; y2 = y1;
            x3 = x2; y3 = y_min + (j + 1) * dy;
            x4 = x1; y4 = y3;
            % Elementni qo'shish
            elementlar(end + 1) = struct('id', id, 'x1', x1, 'y1', y1, ...
                                          'x2', x2, 'y2', y2, ...
                                          'x3', x3, 'y3', y3, ...
                                          'x4', x4, 'y4', y4);
            id = id + 1; % Noyob identifikatorni oshirish
        end
    end
end
  Kvadratchalar qoidasini qo'llash
Kod tuzilishi:
function main()
    % To'rtburchak elementlarni yaratish
    elementlar = createElements();
    % Har bir element ustida kvadratchalar va taqribiy integralni hisoblash
18     element_integrallari = Kvadratlar_qoidasini_qollang(elementlar);
    % Har bir element uchun taxminiy integrallarni chiqarish
    for i = 1:length(element_integrallari)
                fprintf('Element   ID:   %d,   Integral:   %.2f\n',   elementlar(i).id,
element_integrallari(i));
    end
end
function elementlar = createElements()
    % To'rtburchak elementlarni yaratish
       elementlar(1) = struct('id', 1, 'x1', 0, 'y1', 0, 'x2', 4, 'y2', 0, 'x3', 4, 'y3', 3,
'x4', 0, 'y4', 3);
       elementlar(2) = struct('id', 2, 'x1', 1, 'y1', 1, 'x2', 5, 'y2', 1, 'x3', 5, 'y3', 4,
'x4', 1, 'y4', 4);
    % Qo'shimcha elementlar qo'shish mumkin
end
function element_integrallari = Kvadratlar_qoidasini_qollang(elementlar)
    element_integrallari = zeros(1, length(elementlar));
    % Har bir to'rtburchak elementni aylantiring
    for i = 1:length(elementlar)
        % To'rtburchakning uchlarini oling
        x1 = elementlar(i).x1; y1 = elementlar(i).y1;
        x2 = elementlar(i).x2; y2 = elementlar(i).y2;
        x3 = elementlar(i).x3; y3 = elementlar(i).y3;
        x4 = elementlar(i).x4; y4 = elementlar(i).y4;
        % Kvadratlar qoidasidan foydalanib integral hisoblash
19         % Bu misolda, oddiy maydonni hisoblaymiz
        area = abs((x1 * y2 + x2 * y3 + x3 * y4 + x4 * y1) - (y1 * x2 + y2 * x3
+ y3 * x4 + y4 * x1)) / 2;
        % Integralni saqlash
               element_integrallari(i) = area; % Bu maydon, haqiqiy integral uchun
boshqa metodlar kerak
    end
end
      Yuqorida   keltirilgan   kod   tuzilmasida   C++   dasturlash   tili   har   bir
to'rtburchak   element   ustidagi   integralni   taxminan   hisoblash   uchun   kvadratlar
qoidasini   qo'llash   uchun   ishlatiladi.   To'rtburchak_element   strukturasi   har   bir
to'rtburchak   elementni   ifodalaydi   va   Kvadratlar_qoidasini_qo'llang   funksiyasi
kvadratlar   qoidasi   yordamida   har   bir   element   uchun   integral   yaqinlashishni
hisoblaydi.   Asosiy   funktsiya   to'rtburchaklar   elementlari   bilan
Kvadratlar_qoidasini_qo'lla   funksiyasini   qanday   chaqirishni   va   har   bir   element
uchun taxminiy integrallarni qayta ishlashni ko'rsatadi.
  Global integratsiya
  Kod tuzilishi:
% To'rtburchak elementni ifodalash uchun struktura
function Tortburchak_integrallari = main()
    % To'rtburchak elementlarni yaratish
    elementlar(1) = struct('id', 1, 'x', [0, 0; 4, 0; 4, 3; 0, 3]);
    elementlar(2) = struct('id', 2, 'x', [1, 1; 5, 1; 5, 4; 1, 4]);
     % Har bir element ustida integralni taxmin qilish
     Tortburchak_integrallari = Kvadratlar_qoidasini_qollang(elementlar);
    % Har bir element uchun taxminiy integrallarni chiqarish
    for i = 1:length(Tortburchak_integrallari)
20                 fprintf('Element   ID:   %d,   Integral:   %.2f\n',   elementlar(i).id,
Tortburchak_integrallari(i));
    end
end
% Har bir element ustida kvadratchalar va taqribiy integral qoidasini qo'llash
funksiyasi
function element_integrallari = Kvadratlar_qoidasini_qollang(elementlar)
    element_integrallari = zeros(1, length(elementlar));
    % Har bir to'rtburchak elementni aylantiring
    for i = 1:length(elementlar)
        % To'rtburchakning uchlarini oling
        x1 = elementlar(i).x1; y1 = elementlar(i).y1;
        x2 = elementlar(i).x2; y2 = elementlar(i).y2;
        x3 = elementlar(i).x3; y3 = elementlar(i).y3;
        x4 = elementlar(i).x4; y4 = elementlar(i).y4;
        % To'rtburchakning maydoni
        area = abs((x1 * y2 + x2 * y3 + x3 * y4 + x4 * y1) - ...
                    (y1 * x2 + y2 * x3 + y3 * x4 + y4 * x1)) / 2;
        % Integralni hisoblash
        integral = area; % Bu maydon, haqiqiy integral uchun boshqa metodlar
kerak
        element_integrallari(i) = integral;
    end
end
Yuqorida keltirilgan kod tuzilmasida C++ dasturlash tili  global  integratsiya
bosqichini amalga oshirish uchun ishlatiladi, bunda umumiy integralni olish uchun
21 barcha   to'rtburchak   elementlarning   hissalari   yig'iladi.   QuadrilateralElement
strukturasi   har   bir   to'rtburchak   elementni,   shu   jumladan   uning   noyob
identifikatorini,   uchlarini   va   integral   yaqinlashuvini   ifodalaydi.
performGlobalIntegration   funktsiyasi   har   bir   element   bo'ylab   takrorlanadi   va
umumiy   integralni   hisoblash   uchun   ularning   integral   hissalarini   yig'adi.   Asosiy
funksiya   hosil   qilingan   to'rtburchak   elementlar   bilan   performGlobalIntegration
funksiyasini qanday chaqirish va umumiy integralni chiqarishni ko'rsatadi.
Raqamli   integratsiya   uchun   to'rtburchak   usul   dasturining   aniqligi   va
ishonchliligini   ta'minlash   uchun   turli   test   holatlarini   ishlab   chiqish   kerak.   Ushbu
test   holatlari   oddiy   geometrik   shakllar,   murakkab   tartibsiz   domenlar   va   har   xil
xususiyatlarga   ega   funktsiyalarni   o'z   ichiga   olgan   bir   qator   stsenariylarni   qamrab
olishi   kerak.   Quyida   kutilgan   natijalar   bilan   birga   bir   nechta   test   holatlarining
batafsil tavsiflari keltirilgan.
Test ishi 1:  Birlik kvadrat ustidagi integral
Tavsif:
Funktsiyani birlashtirish 
f ( x ,va)=1tomonidan belgilangan birlik kvadrat ustida
0≤x≤1va 0≤va≤1
Kutilayotgan natija ning integrali
f ( x ,va )=1birlik kvadrat ustida bo'lishi kerak1
               Amalga oshirish:
function main()
    % Birlik kvadrat uchlarini aniqlash
    % Masalan, [0, 0; 1, 0; 1, 1; 0, 1] koordinatalari
    vertices = [0, 0; 1, 0; 1, 1; 0, 1];
    % Birlik kvadrat elementlarini diskretlashtirish
    birlikKvadratElementlari = hududniDiskretlashtirish(vertices);
    % Har bir element uchun integral hisoblash
22     for i = 1:length(birlikKvadratElementlari)
                birlikKvadratElementlari(i).integral   =
birlikKvadratUchunKvadratQoidalariniQo'llash(birlikKvadratElementlari(i));
    end
    % Global integratsiyani bajarish
    natija = globalIntegratsiyaniBajarish(birlikKvadratElementlari);
    fprintf('Sinov Holati 1 - Kutilgan: 1, Hisoblangan: %.2f\n', natija);
    % Qo'shimcha test holati
    % Ikkinchi birlik kvadrat hududini aniqlash
    % Masalan, [1, 1; 2, 1; 2, 2; 1, 2] koordinatalari
    vertices2 = [1, 1; 2, 1; 2, 2; 1, 2];
    birlikKvadratElementlari2 = hududniDiskretlashtirish(vertices2);
    % Har bir element uchun integral hisoblash
    for i = 1:length(birlikKvadratElementlari2)
                birlikKvadratElementlari2(i).integral   =
birlikKvadratUchunKvadratQoidalariniQo'llash(birlikKvadratElementlari2(i));
    end
    % Global integratsiyani bajarish
    natija2 = globalIntegratsiyaniBajarish(birlikKvadratElementlari2);
    fprintf('Test Holati 1 - Kutilgan: 1, Hisoblangan: %.2f\n', natija2);
end
function elementlar = hududniDiskretlashtirish(vertices)
    % Birlik kvadrat elementlarni yaratish
     elementlar = struct('id', {}, 'x1', {}, 'y1', {}, 'x2', {}, 'y2', {}, 'x3', {}, 'y3',
{}, 'x4', {}, 'y4', {}, 'integral', {});
23     
    % Elementni qo'shish
    id = 1;
        elementlar(end   +   1)   =   struct('id',   id,   'x1',   vertices(1,   1),   'y1',   vertices(1,
2), ...
                                  'x2', vertices(2, 1), 'y2', vertices(2, 2), ...
                                  'x3', vertices(3, 1), 'y3', vertices(3, 2), ...
                                  'x4', vertices(4, 1), 'y4', vertices(4, 2));
end
function integral = birlikKvadratUchunKvadratQoidalariniQo'llash(element)
    % To'rtburchak maydonni hisoblash
    area = abs((element.x1 * element.y2 + element.x2 * element.y2 + ...
                element.x3 * element.y3 + element.x4 * element.y1) - ...
                (element.y1 * element.x2 + element.y2 * element.x3 + ...
                element.y3 * element.x4 + element.y4 * element.x1)) / 2;
    % Integral maydon sifatida
    integral = area; % Haqiqiy integral uchun boshqa metodlar kerak
end
function natija = globalIntegratsiyaniBajarish(elementlar)
    % Har bir elementning integralini yig'ish
    natija = sum([elementlar.integral]);
end
    Test ishi 2: To‘g‘ri burchakli uchburchak ustidagi integral
Tavsif: 
     Funktsiyani birlashtirish
f ( x ,va )=x+va  uchlari bo'lgan to'g'ri burchakli uchburchak ustida ( 0 ,0 ),
( 1 ,0 ), va ( 0 ,1 ).
24 Kutilayotgan natija: 
ning integrali f ( x va )=x+vauchburchak ustida bo'lishi kerak 1/3.
Amalga oshirish:
function main()
    % To'g'ri burchakli uchburchak uchlarini aniqlash
    vertices = [0, 0; 1, 0; 0, 1]; % [x1, y1; x2, y2; x3, y3]
    % To'g'ri burchakli uchburchak elementlarini diskretlashtirish
    TogriBurchakliElementlar = domennidiskretlash(vertices);
    % Har bir element uchun integral hisoblash
    for i = 1:length(TogriBurchakliElementlar)
                TogriBurchakliElementlar(i).integral   =
applyRuleOfSquaresForTriangle(TogriBurchakliElementlar(i));
    end
    % Global integratsiyani amalga oshirish
    result = GlobalIntegratsiyaniamalgaoshirish(TogriBurchakliElementlar);
    fprintf('Test ishi 2 - Kutilayotgan: %.2f, Hisoblangan: %.2f\n', 1/3, result);
end
function elementlar = domennidiskretlash(vertices)
    % To'g'ri burchakli uchburchak elementlarni yaratish
     elementlar = struct('id', {}, 'x1', {}, 'y1', {}, 'x2', {}, 'y2', {}, 'x3', {}, 'y3',
{}, 'integral', {});
    
    % Elementni qo'shish
    id = 1;
        elementlar(end   +   1)   =   struct('id',   id,   'x1',   vertices(1,   1),   'y1',   vertices(1,
2), ...
25                                   'x2', vertices(2, 1), 'y2', vertices(2, 2), ...
                                  'x3', vertices(3, 1), 'y3', vertices(3, 2));
end
function integral = applyRuleOfSquaresForTriangle(element)
    % Uchburchak maydonini hisoblash (to'g'ri burchakli uchburchak uchun)
     base = element.x2 - element.x1; % Asos
     height = element.y3; % Balandlik
    area = 0.5 * base * height; % Uchburchak maydoni
    % Integralni hisoblash
        integral   = area;   %  Bu  maydon, haqiqiy  integral  uchun  boshqa  metodlar
kerak
end
function natija = GlobalIntegratsiyaniamalgaoshirish(elementlar)
    % Har bir elementning integralini yig'ish
    natija = sum([elementlar.integral]);
end
Test ishi 3: Aylana domenidagi integral
Tavsif: 
  Funktsiyani birlashtirish  f ( x ,va )=x 2
 +va 2
  radiusi   1   bo'lgan   doiraviy   domen   bo'ylab   markazning   koordinatasida
joylashgan.
Kutilayotgan natija:  ning integrali f ( x ,va )=x 2
 +va 2
  birlik doira ustida bo'lishi kerak  P
i /2 .
       Amalga oshirish:
function main()
    % Doira uchlarini aniqlash
26      radius = 1; % Doira radiusi
    n = 100; % Doira bo'ylab nuqtalar soni
    % Doira elementlarini diskretlashtirish
    doiraElementlari = doiraHududlariniDiskretlashtirish(radius, n);
     % Har bir element uchun integral hisoblash
    for i = 1:length(doiraElementlari)
                doiraElementlari(i).integral   =
doiraUchunKvadratQoidalariniQo'llash(doiraElementlari(i));
    end
    % Global integratsiyani bajarish
    natija = globalIntegratsiyaniBajarish(doiraElementlari);
        fprintf('Sinov   Holati   3   -   Kutilgan:   %.2f,   Hisoblangan:   %.2f\n',   pi/2,
natija);
end
function elementlar = doiraHududlariniDiskretlashtirish(radius, n)
    % Doira elementlarini yaratish
    elementlar = struct('id', {}, 'x', {}, 'y', {}, 'integral', {});
    
    for i = 1:n
        theta1 = (i-1) * (2*pi/n); % Birinchi burchak
        theta2 = i * (2*pi/n);     % Ikkinchi burchak
        % Doira segmentining uchlarini hisoblash
        x1 = radius * cos(theta1);
        y1 = radius * sin(theta1);
        x2 = radius * cos(theta2);
27         y2 = radius * sin(theta2);
        % Elementni qo'shish
        id = i;
        elementlar(end + 1) = struct('id', id, 'x', [x1, x2], 'y', [y1, y2]);
    end
end
function integral = doiraUchunKvadratQoidalariniQo'llash(element)
    % Doira segmentining maydonini hisoblash
    x1 = element.x(1);
    y1 = element.y(1);
    x2 = element.x(2);
    y2 = element.y(2);
    % Segment maydoni (to'liq doira maydoni uchun)
    segmentArea = 0.5 * (x1 * y2 - x2 * y1);
    % Integralni hisoblash
       integral = abs(segmentArea); % Maydon, haqiqiy integral uchun boshqa
metodlar kerak
end
function natija = globalIntegratsiyaniBajarish(elementlar)
    % Har bir elementning integralini yig'ish
    natija = sum([elementlar.integral]);
end
28 Test ishi 4: tartibsiz ko‘pburchak ustidagi integral
Tavsif: 
  Funktsiyani birlashtirish
f ( x ,va )=Bu(x + y)   ixtiyoriy cho'qqilar to'plami bilan aniqlangan tartibsiz
ko'pburchak ustida.
Kutilayotgan natija: 
kutilayotgan   natija   ko‘pburchakning   o‘ziga   xos   cho‘qqilariga   bog‘liq
bo‘ladi.   Ushbu   test   ishi   birinchi   navbatda   dasturning   tartibsiz   domenlarni
boshqarish qobiliyatini tekshiradi.
Amalga oshirish:
function main()
    % Noaniq to'rtburchak uchlarini aniqlash
    vertices = [0, 0; 3, 1; 2, 4; 0, 3]; % Noaniq to'rtburchakning uchlari
    % Noaniq to'rtburchak elementlarini diskretlashtirish
        noaniqliTortburchakElementlar   =
noaniqliTortburchakniDiskretlashtirish(vertices);
    % Har bir element uchun integral hisoblash
    for i = 1:length(noaniqliTortburchakElementlar)
                noaniqliTortburchakElementlar(i).integral   =
noaniqliTortburchakUchunKvadratQoidalariniQo'llash(noaniqliTortburchakEleme
ntlar(i));
    end
    % Global integratsiyani bajarish
    natija = globalIntegratsiyaniBajarish(noaniqliTortburchakElementlar);
    fprintf('Sinov Holati 4 - Hisoblangan: %.2f\n', natija);
end
29 function elementlar = noaniqliTortburchakniDiskretlashtirish(vertices)
    % Noaniq to'rtburchak elementlarini yaratish
     elementlar = struct('id', {}, 'x1', {}, 'y1', {}, 'x2', {}, 'y2', {}, 'x3', {}, 'y3',
{}, 'x4', {}, 'y4', {}, 'integral', {});
    % To'rtburchakni qo'shish
    id = 1;
    elementlar(end + 1) = struct('id', id, ...
                                  'x1', vertices(1, 1), 'y1', vertices(1, 2), ...
                                  'x2', vertices(2, 1), 'y2', vertices(2, 2), ...
                                  'x3', vertices(3, 1), 'y3', vertices(3, 2), ...
                                  'x4', vertices(4, 1), 'y4', vertices(4, 2));
end
function   integral   =
noaniqliTortburchakUchunKvadratQoidalariniQo'llash(element)
    % Noaniq to'rtburchak maydonini hisoblash
    x1 = element.x1; y1 = element.y1;
    x2 = element.x2; y2 = element.y2;
    x3 = element.x3; y3 = element.y3;
    x4 = element.x4; y4 = element.y4;
    % To'rtburchakning maydoni (sho'rlik formula)
    area = abs((x1 * y2 + x2 * y3 + x3 * y4 + x4 * y1) - ...
                (y1 * x2 + y2 * x3 + y3 * x4 + y4 * x1)) / 2;
    % Integralni hisoblash
        integral   = area;   %  Bu  maydon, haqiqiy  integral  uchun  boshqa  metodlar
kerak
end
30 function natija = globalIntegratsiyaniBajarish(elementlar)
    % Har bir elementning integralini yig'ish
    natija = sum([elementlar.integral]);
end
Test ishi 5: Teshigi bo'lgan domen ustidagi integral
Tavsif: 
Funktsiyani   birlashtirish   f   (   x   ,va   )=sin(x) ⋅ chunki   (   va   )dumaloq   teshikli
kvadrat domen ustida. Kutilgan natija: 
kutilgan   natija   kvadratning   o'lchamlari   va   teshik   radiusiga   bog'liq   bo'ladi.
Ushbu   test   ishi   dasturning   ichki   chegaralar   bilan   murakkab   geometriyalarni
boshqarish qobiliyatini tekshiradi.
Amalga oshirish:
function main()
    % Teshikdagi hududni diskretlashtirish
    teshikdagiHududElementlar = teshikdagiHududniDiskretlashtirish();
    % Har bir element uchun integral hisoblash
    for i = 1:length(teshikdagiHududElementlar)
        teshikdagiHududElementlar(i).integral = 
teshikdagiHududUchunKvadratQoidalariniQo'llash(teshikdagiHududElementlar(i))
;
    end
    % Global integratsiyani bajarish
    natija = globalIntegratsiyaniBajarish(teshikdagiHududElementlar);
    fprintf('Sinov Holati 5 - Hisoblangan: %.2f\n', natija);
end
31 function elementlar = teshikdagiHududniDiskretlashtirish()
    % Teshikdagi hududni diskretlashtirish
    elementlar = struct('x1', {}, 'y1', {}, 'x2', {}, 'y2', {}, 'x3', {}, 'y3', {}, 'x4', 
{}, 'y4', {}, 'integral', {});
    
    % Kvadrat elementini qo'shish (masalan, [0, 0] va [1, 1])
    elementlar(end + 1) = struct('x1', 0, 'y1', 0, 'x2', 1, 'y2', 0, 'x3', 1, 'y3', 1, 
'x4', 0, 'y4', 1);
    % Qo'shimcha elementlar qo'shish mumkin
end
function integral = 
teshikdagiHududUchunKvadratQoidalariniQo'llash(element)
    % Kvadrat qoidalaridan foydalanib integralni hisoblash
    area = abs((element.x1 * element.y2 + element.x2 * element.y2 + ...
                element.x3 * element.y3 + element.x4 * element.y1) - ...
                (element.y1 * element.x2 + element.y2 * element.x3 + ...
                element.y3 * element.x4 + element.y4 * element.x1)) / 2;
    
    % Integralni hisoblash
    integral = area; % Maydon sifatida
end
function natija = globalIntegratsiyaniBajarish(elementlar)
    % Har bir elementning integralini yig'ish
    natija = sum([elementlar.integral]);
end
32 Yuqoridagi testlarni 5 chigacha qisman korib o’tdik.  5 chi testda esa dasturni
to’liq qismini kordik.
Yuqorida   keltirilgan   test   holatlari   oddiydan   murakkabgacha   bo'lgan
stsenariylarni   qamrab   oladi,   bu   to'rtburchak   usul   dasturining   aniqligi   va
mustahkamligi uchun sinchkovlik bilan sinovdan o'tkazilishini ta'minlaydi. Ushbu
test   holatlarida   dasturning   ishlashini   tekshirish   orqali   biz   uning   turli   tartibsiz
domenlarda   integrallarni   yaqinlashtirish   uchun   ishonchliligini   tasdiqlashimiz
mumkin.   Keyingi   bo'limda   ushbu   test   holatlarini   bajarish   natijasida   olingan
natijalar   va   dastur   samaradorligini   oshirish   uchun   zaruriy   tuzatishlar   muhokama
qilinadi.
   Aniqlik va konvergentsiya.
Raqamli   integratsiya   uchun   to'rtburchak   usul   dasturi   ham   to'g'ri,   ham
konvergent bo'lishini ta'minlash uchun uning turli test holatlari bo'yicha ishlashini
tahlil   qilish   juda   muhimdir.   Ushbu   bo'limda   ushbu   baholash   natijalari   bilan   bir
qatorda   aniqlik   va   konvergentsiyani   baholash   metodologiyalari   muhokama
qilinadi.
                                      Aniqlikni baholash
Aniqlikni   baholash   to'rtburchak   usul   dasturidan   olingan   raqamli   natijalarni
ma'lum   bo'lgan   analitik   echimlar   yoki   yuqori   aniqlikdagi   sonli   taxminlar   bilan
solishtirishni   o'z   ichiga   oladi.   Xato   odatda   mutlaq   xato   va   nisbiy   xato   kabi
ko'rsatkichlar yordamida aniqlanadi.
Xato ko'rsatkichlari:
Mutlaqo xato:  Mutla xato= I∣
aniq  – I
taxminan ∣
Nisbiy xato:  Nisbiy xato=  I
∣
aniq  – I
taxminan   I	∣
aniq
Qayerda   Ianiq   integralnin   aniq   qiymamti   va   Itaxminan   dasturdan   olingan
taxmininy  qiymatdir.
1-test uchun hiosblash misoli:
Sinov   ishi   1:   Integratsiya   f(x,va)=1birlik   kvadrat   ustida   0≤x≤1   va
0≤va≤1.Aniq integral: aniq=1
Taxminiy integral: Itaxminiy(dastur tomonidan hiosblangan)
33 function main()
    % Aniqlangan integral qiymati
    aniqliIntegral = 1.0;
    % Birlik kvadrat elementlarini diskretlashtirish
    unitSquareElements = birlikKvadratElementlariniDiskretlashtirish();
    % Global integratsiyani bajarish
    hisoblanganIntegral = globalIntegratsiyaniBajarish(unitSquareElements);
     % Absolut va nisbiy xatoni hisoblash
    absolutXato = abs(aniqliIntegral - hisoblanganIntegral);
    nisbiyXato = absolutXato / abs(aniqliIntegral);
    % Natijalarni chiqarish
        fprintf('Sinov   Holati   1   -   Absolut   Xato:   %.10f,   Nisbiy   Xato:   %.10f\n',
absolutXato, nisbiyXato);
end
function elementlar = birlikKvadratElementlariniDiskretlashtirish()
    % Birlik kvadrat elementlarini yaratish
    elementlar = struct('x1', {}, 'y1', {}, 'x2', {}, 'y2', {}, 'x3', {}, 'y3', {}, 'x4',
{}, 'y4', {}, 'integral', {});
    
    % Kvadrat elementini qo'shish (masalan, [0, 0] va [1, 1])
       elementlar(end + 1) = struct('x1', 0, 'y1', 0, 'x2', 1, 'y2', 0, 'x3', 1, 'y3', 1,
'x4', 0, 'y4', 1);
    % Qo'shimcha elementlar qo'shish mumkin
end
34 function natija = globalIntegratsiyaniBajarish(elementlar)
    % Har bir elementning integralini yig'ish
    natija = sum([elementlar.integral]);
end
                                    Konvergentsiya tahlili
          Konvergentsiya   tahlili   domenning   diskretizatsiyasi   qanchalik   nozik
bo'lsa,   sonli   yaqinlashishning   aniqligi   qanday   yaxshilanishini   tekshiradi.
To'rtburchak   elementlarning   o'lchami   kamayishi   (ya'ni,   to'rning   tozalanganligi
sababli) xatolik kamaysa, usul konvergent hisoblanadi.
Konvergentsiyani tahlil qilish bosqichlari:
1.Turli xil aniqlikdagi meshlarni yarating: 
Domenning   turli   darajadagi   nozikliklari   bilan   bir   nechta   diskretizatsiyasini
yarating (masalan, nozik va qo'polroq to'rlar).
2.Har bir to'r uchun integrallarni hisoblash: 
har   bir  tarmoq  o'lchamlari   uchun  integralni  hisoblash  uchun   to'rtburchaklar
usulini qo'llang.
3.Plot Error vs. Mesh Size: 
    Xatoni   (mutlaq   yoki   nisbiy)   to‘rtburchak   elementlarning   xarakterli
o‘lchamiga   (masalan,   maksimal   yon   uzunligi   yoki   o‘rtacha   maydon)   nisbatan
chizing.
Konvergentsiya tahlilini amalga oshirishga misol:
function main()
    % Aniqlangan integral qiymati
    aniqIntegral = 1.0;
    % Turkumlar o'lchami uchun vektor
    meshSizes = [0.1, 0.05, 0.01];
    
    % Xatoliklar uchun vektor
35     xatolar = zeros(size(meshSizes));
    
    for i = 1:length(meshSizes)
        meshSize = meshSizes(i);
        
                %   Berilgan   turkumlar   o'lchami   uchun   to'rtburchak   elementlarini
yaratish
        elementlar = MeshSizebilandomennidiskretlash(meshSize);
        
        % Integrallarni hisoblash
        hisoblanganIntegral = performGlobalIntegration(elementlar);
        
        % Xatolikni hisoblash
        mutlaqXato = abs(aniqIntegral - hisoblanganIntegral);
        xatolar(i) = mutlaqXato;
    end
    
    % Natijalarni chiqarish
     disp('Xatoliklar:');
    disp(xatolar);
    
    % Xatoliklar va turkumlar o'lchamlarini plot qilish
     figure;
    plot(meshSizes, xatolar, '-o');
    xlabel('Mesh O''lchami');
    ylabel('Mutlaq Xato');
    title('Mesh O''lchami va Xatoliklar');
    grid on;
end
36 function elementlar = MeshSizebilandomennidiskretlash(meshSize)
    % Teshikdagi hududni diskretlashtirish (masalan, birlik kvadrat)
    elementlar = struct('x1', {}, 'y1', {}, 'x2', {}, 'y2', {}, 'x3', {}, 'y3', {}, 'x4',
{}, 'y4', {}, 'integral', {});
    % Mesh o'lchamiga qarab to'rtburchaklarni yaratish
    for x = 0:meshSize:1-meshSize
        for y = 0:meshSize:1-meshSize
            % To'rtburchak elementini qo'shish
            elementlar(end + 1) = struct('x1', x, 'y1', y, ...
                                          'x2', x + meshSize, 'y2', y, ...
                                          'x3', x + meshSize, 'y3', y + meshSize, ...
                                          'x4', x, 'y4', y + meshSize);
        end
    end
end
function natija = performGlobalIntegration(elementlar)
    % Har bir elementning integralini yig'ish
    natija = 0.0;
    for i = 1:length(elementlar)
        % Har bir to'rtburchak elementining maydonini hisoblash
                area   =   (elementlar(i).x2   -   elementlar(i).x1)   *   (elementlar(i).y3   -
elementlar(i).y1);
               natija = natija + area; % Bu maydon, haqiqiy integral  uchun boshqa
metodlar kerak
    end
end
          To'rtburchak   usul   dasturining   to'g'riligi   va   yaqinligini   baholash   xato
ko'rsatkichlarini   baholash   va   yaqinlashuv   tahlilini   o'tkazishni   o'z   ichiga   oladi.
37 Ushbu   baholashlarni   o'tkazish   orqali   biz   dastur   tartibsiz   domenlar   bo'yicha
integrallarning ishonchli va to'g'ri sonli taxminlarini taqdim etishini tasdiqlashimiz
mumkin.   Ushbu   tahlillar   natijalari,   shuningdek,   dastur   samaradorligini   yanada
oshirish   uchun   takomillashtirish   va   optimallashtirish   uchun   har   qanday   potentsial
sohalarni aniqlashga yordam beradi.
   Faoliyatni baholash..
          To'rtburchak   usul   dasturining   hisoblash   samaradorligi   turli   xil
o'lchamdagi   muammolar   uchun   ish   vaqtini   o'lchash   yo'li   bilan   baholanadi.
To'rtburchak usulning afzalliklari va cheklovlarini ta'kidlash uchun ishlash boshqa
raqamli integratsiya usullari bilan taqqoslanadi.
                            Ish faoliyatini baholash metodologiyalari
1. Hisoblash vaqti: 
Turli   domenlar   va   funktsiyalarda   integratsiyani   amalga   oshirish   uchun
sarflangan   vaqtni   o'lchang.   Bunga   vaqt   domenini   diskretlashtirish,   kvadratura
qoidalarini qo'llash va global integratsiya kiradi.
2. Masshtablilik: 
to'rtburchak   elementlarning   soni   va   integralning   murakkabligi   kabi
muammoning o'lchami bilan dasturning ishlashi qanday o'lchanishini baholang.
3. Xotiradan foydalanish: 
Dasturning   xotira   sarfini,   ayniqsa   nozik   diskretizatsiya   bilan   bog'liq   keng
ko'lamli muammolar uchun hisoblang.
                                     Hisoblash vaqti
Muayyan   sohada   funktsiyani   birlashtirish   uchun   hisoblash   vaqti   dastur
ishlashining muhim ko'rsatkichidir. Biz har bir asosiy bosqichga sarflangan vaqtni
o'lchashimiz   mumkin:   diskretizatsiya,   kvadratura   qoidalarini   qo'llash   va   global
integratsiya.
Amalga oshirish misoli
function main()
    % Integratsiya domeni va funksiyasini aniqlash
    elementlar = []; % Domen aniqlanishi bilan to'ldiriladi
38     % Domenni diskretlashtirish uchun vaqtni o'lchash
tic; % Vaqtni o'lchashni boshlash   elementlar = diskretlashtirish
Domeni(); % Kiritish parametrlari berilishi mumkin  diskretlashtirish
Vaqti = toc; % Vaqtni o'lchash
fprintf('Diskretlashtirish vaqti: %.6f soniya\n', diskretlashtirishVaqti);
    % Kvadrat qoidani qo'llash uchun vaqtni o'lchash
    tic; % Vaqtni o'lchashni boshlash
    for i = 1:length(elementlar)
        elementlar(i).integral = kvadratQoidaniQollash(elementlar(i));
    end
    kvadratVaqti = toc; % Vaqtni o'lchash
    fprintf('Kvadrat qoida qo\'llash vaqti: %.6f soniya\n', kvadratVaqti);
    % Global integratsiya uchun vaqtni o'lchash
    tic; % Vaqtni o'lchashni boshlash
    umumiyIntegral = globalIntegratsiyaniBajaring(elementlar);
    globalIntegratsiyaVaqti = toc; % Vaqtni o'lchash
    fprintf('Global integratsiya vaqti: %.6f soniya\n', globalIntegratsiyaVaqti);
end
function elementlar = diskretlashtirishDomeni()
    % Domenni diskretlashtirish funksiyasi
    elementlar = struct('x1', {}, 'y1', {}, 'x2', {}, 'y2', {}, 'x3', {}, 'y3', {}, 'x4',
{}, 'y4', {}, 'integral', {});
        % To'rtburchak elementlarini qo'shish (masalan, birlik kvadrat)
       elementlar(end + 1) = struct('x1', 0, 'y1', 0, 'x2', 1, 'y2', 0, 'x3', 1, 'y3', 1,
'x4', 0, 'y4', 1);
    % Qo'shimcha elementlar qo'shish mumkin
39 end
function integral = kvadratQoidaniQollash(element)
    % To'rtburchak elementining integralini hisoblash
    area = abs((element.x1 * element.y2 + element.x2 * element.y2 + ...
                element.x3 * element.y3 + element.x4 * element.y1) - ...
                (element.y1 * element.x2 + element.y2 * element.x3 + ...
                element.y3 * element.x4 + element.y4 * element.x1)) / 2;
    
    integral = area; % Maydon sifatida
end
function natija = globalIntegratsiyaniBajaring(elementlar)
    % Har bir elementning integralini yig'ish
    natija = sum([elementlar.integral]);
end
Masshtablilik
          Masshtablilikni   baholash   uchun   dasturning   ishlashi   muammo
o'lchamlarini   oshirish   bilan   sinovdan   o'tkazilishi   kerak.   Bu   to'rni   tozalash   va
hisoblash   vaqti   va   aniqligiga   ta'sirini   baholash   orqali   to'rtburchak   elementlarning
sonini ko'paytirishni o'z ichiga oladi.
Masshtablilik testini amalga oshirishga misol:
function main()
    % Birlik kvadrat elementlarini diskretlashtirish
    birlikKvadratElementlari = hududniDiskretlashtirish();
    
    % Har bir element uchun integralni hisoblash
    for i = 1:length(birlikKvadratElementlari)
                birlikKvadratElementlari(i).integral   =
birlikKvadratUchunKvadratQoidalariniQo'llash(birlikKvadratElementlari(i));
40     end
    
    % Global integratsiyani bajarish
    natija = globalIntegratsiyaniBajarish(birlikKvadratElementlari);
    
    % Natijani chiqarish
    fprintf('Sinov Holati 1 - Kutilgan: 1, Hisoblangan: %.6f\n', natija);
end
function elementlar = hududniDiskretlashtirish()
    % Birlik kvadratni diskretlashtirish
    elementlar = struct('x1', {}, 'y1', {}, 'x2', {}, 'y2', {}, 'x3', {}, 'y3', {}, 'x4',
{}, 'y4', {}, 'integral', {});
    
    % Birlik kvadrat uchun bitta to'rtburchak elementini qo'shish
    elementlar(end + 1) = struct('x1', 0, 'y1', 0, 'x2', 1, 'y2', 0, ...
                                  'x3', 1, 'y3', 1, 'x4', 0, 'y4', 1);
end
function integral = birlikKvadratUchunKvadratQoidalariniQo'llash(element)
    % Birlik kvadrat elementining integralini hisoblash
    integral = 1; % Birlik kvadrat uchun aniqlangan integral
end
function natija = globalIntegratsiyaniBajarish(elementlar)
    % Har bir elementning integralini yig'ish
    natija = sum([elementlar.integral]);
end
                                   Xotiradan foydalanish
41 Xotiradan   foydalanish,   ayniqsa   katta   hajmdagi   muammolar   uchun   muhim
omil   hisoblanadi.   Xotira   iste'molini   monitoring   qilish   dasturning   murakkab
integratsiyalarni   ortiqcha  resurslardan   foydalanmasdan  boshqarishini   ta'minlashga
yordam beradi.
     Xotiradan foydalanishni monitoring qilish uchun misol: 
Batafsil   xotira   profili   odatda   maxsus   vositalarni   talab   qilsa-da,   asosiy
monitoring   tizim   qo'ng'iroqlari   yoki   tashqi   kutubxonalar   yordamida   amalga
oshirilishi mumkin. Bu erda tizim ma'lumotlaridan foydalanishning oddiy usuli.
% TortburchakElement tuzilmasi uchun struktura
TortburchakElement = struct('x', 0, 'y', 0, 'integral', 0);
% Hududni diskretlashtirish funktsiyasi
function elements = hududniDiskretlashtirish(a, b, n)
    % Step o'lchamini hisoblash
    step = (b - a) / n;
    elements = repmat(TortburchakElement, n, 1);
    
    for i = 1:n
        elements(i).x = a + (i - 1) * step;
        elements(i).y = elements(i).x^2;  % Misol sifatida x^2 funktsiyasi
    end
end
% Kvadrat qoidalarini qo'llash funktsiyasi
function integral = kvadratQoidalariniQollash(element)
     integral = element.y;  % Bu erda xuddi shu y qiymatini qaytaramiz
end
% Umumiy integralni hisoblash funktsiyasi
function totalIntegral = globalIntegratsiyaniBajarish(elements)
    totalIntegral = 0;
    for i = 1:length(elements)
42         totalIntegral = totalIntegral + elements(i).integral;
    end
end
%   Xotira   foydalanishni   kuzatish   funktsiyasi   (MATLABda   to'g'ridan-to'g'ri
kuzatish mumkin)
function xotiraFoydalanishniKuzatish()
    % MATLABda tizim xotira ma'lumotlarini olish
    info = memory;
    fprintf('Xotira ishlatilishi: %.2f MB\n', info.MemUsedMATLAB / 1e6);
end
% Xotira foydalanish testini bajarish
function xotiraFoydalanishTesti()
     % Hudud parametrlarini belgilash
    a = 0.0;  % Pastki chegarasi
    b = 1.0;  % Yuqori chegarasi
    n = 10000; % Diskretlashtirish nuqtalari soni
    
    % Xotira monitoringini boshlash
    xotiraFoydalanishniKuzatish();
    
    % Hududni diskretlashtirish
     elementlar = hududniDiskretlashtirish(a, b, n);
    
    % Integratsiyani bajarish
    for i = 1:n
        elementlar(i).integral = kvadratQoidalariniQollash(elementlar(i));
    end
    
43     % Umumiy integralni hisoblash
    umumiyIntegral = globalIntegratsiyaniBajarish(elementlar);
    fprintf('Umumiy integral: %.4f\n', umumiyIntegral);
    
    % Integratsiyadan keyin xotirani kuzatish
    xotiraFoydalanishniKuzatish();
end
% Asosiy funksiya
xotiraFoydalanishTesti();
To'rtburchak   usul   dasturining   ishlashini   baholash   hisoblash   vaqtini,
miqyoslilikni   va   xotiradan   foydalanishni   baholashni   o'z   ichiga   oladi.   Ushbu
jihatlarni sinchiklab baholab, biz dasturning nafaqat to g ri va ishonchli, balki turliʻ ʻ
integratsiya   vazifalari   uchun   samarali   va   kengaytirilishiga   ishonch   hosil   qilamiz.
Ushbu   keng   qamrovli   ish   faoliyatini   baholash   optimallashtirish   sohalarini
aniqlashga   yordam   beradi   va   dastur   katta   va   murakkab   domenlarni   samarali
boshqarishini ta'minlaydi.
44 XULOSA
Xulosa qilib aytadigan bo'lsak, ushbu kurs ishida aniq integrallarni taqribiy
hisoblash uchun to'g'ri to'rtburchaklar usuli asosida dastur ishlab chiqildi. Bu usul
oddiy va samarali bo'lib, matematik integrallarni hisoblashda keng qo'llaniladi.
Kurs ishining asosiy natijalari quyidagilardan iborat:
To'g'ri   to'rtburchaklar   usulining   matematik   asoslari   o'rganildi.   Bu   usulda
integral   hisoblash   uchun   funksiya   oraliq   intervallar   bo'yicha   teng   qismlarga
bo'linadi   va   har   bir   qismda   funksiya   qiymati   bo'yicha   to'rtburchaklar   yuzasi
hisoblanadi.
To'g'ri   to'rtburchaklar   usulining   algoritmi   batafsil   tasvirlandi.   Algoritmning
har bir bosqichi, ya'ni oraliq intervallarni aniqlash, funksiya qiymatlarini hisoblash
va umumiy natijani yig'ish jarayonlari tushuntirildi.
Mazkur   usulni   amalga oshirish  uchun  dastur   ishlab  chiqildi.  Dastur   Python
dasturlash tilida yozildi va foydalanuvchi kiritgan funksiya, boshlang'ich va oxirgi
chegara hamda oraliq soni bo'yicha integralni taqribiy hisoblaydi.
Dastur   bir   qator   test   funksiyalar   bilan   sinovdan   o'tkazildi.   Sinov   natijalari
dasturning   yuqori   aniqlikda   ishlashini   ko'rsatdi,   ayniqsa   kichik   oraliqlarda
hisoblashda yuqori aniqlikka erishildi.
To'g'ri   to'rtburchaklar   usuli   matematik   integrallarni   taqribiy   hisoblashda
oddiy   va   samarali   usul   ekanligi   isbotlandi.   Kelgusida   dasturga   boshqa   taqribiy
hisoblash   usullarini   (masalan,   trapetsiya   yoki   Simpson   usullari)   qo'shish,   hamda
dastur interfeysini takomillashtirish taklif etildi.
Kurs   ishi   davomida   amalga   oshirilgan   tadqiqot   va   dasturiy   ta'minot
matematik integrallarni taqribiy hisoblashda foydalanish mumkin bo'lgan ishonchli
vositani taqdim etdi. Bu dastur nafaqat ta'lim jarayonida, balki ilmiy tadqiqotlarda
ham qo'llanishi mumkin.Ushbu loyihada ishlab chiqilgan to'rtburchak usul dasturi
tartibsiz   domenlar   bo'yicha   integrallarni   yaqinlashtirish   uchun   moslashuvchan,
aniq   va   samarali   vositani   taklif   qiluvchi   raqamli   integratsiya   texnikasi   haqida
yetarlicha   ma’lumot   berdim.   Keng   qamrovli   sinov   va   samaradorlikni   baholash
dasturning   ishonchliligini   va   turli   ilmiy   va   muhandislik   sohalarida   amaliy
45 qo'llanilishiga   tayyorligini   ta'minlaydi.   Qo'shimcha   berilgan   ma’lumotlar   va
optimallashtirishlar   ushbu   asosga   asoslanib,   raqamli   integratsiya   bilan   erishish
mumkin bo'lgan masalalarni yechishga yordam beradi.
                
46                             ADABIYOTLAR RO’YXATI :
1.  Numerical Methods for Engineers by Steven C. Chapra, Raymond P. Canale
2.  Numerical   Recipes   by   William   H.   Press,   Saul   A.   Teukolsky,   William   T.
Vetterling, Brian P. Flannery.
3. C The Complete Reference Schildt, McGraw Hill Education (Gna)UZ
4. C++ and Object Oriented Programming - Jana, PHI Learning
5. Object Oriented Programming with C++ - Rajiv Sahay, Oxford
6 .  Ismatullaev   G'.P.,   Jo'raev   G'.U.  
7. Isroilov   M.I.   Hisoblash   metodlari,   1.   Toshkent,   O'qituvchi,   2000.  
8. Isroilov M.I. Hisoblash metodlari. 2-qism. - T.: « O‘qituvchi», 2008.
9.   Abdulhamidov   A.   U.,   Xudoynazarov   S.A   15   Hisoblash   usullaridan
mashqlar   va   laboratoriya   ishlari:   Oliy   o‘quv   yurtlari   talabalari   uchun   o‘quv
qo‘llanma/T . Azlarov tahririda.— T.: Uzbekiston, 1995.—223 b.
10. http://www.intuit.ru
11. http://www.ziyonet.uz.
47

Integrallarni taqribiy hisoblashda to'g'ri to'rtburchak formulasining matlab dasturi tadbig’i

Купить
  • Похожие документы

  • Boshlangʻich sinflarda vaqt tushunchasi va uning oʻlchov birliklari
  • Streometryada vektorlar metodi
  • Arifmetikani intuitiv tushuntirish uchun amaliy mashgʻulotlar
  • 100 ichida nomanfiy butun sonlar ustida arifmetik amallarni o'rgatish metodikasi
  • Tenglama va tengsizliklarni geometrik usulda yechish

Подтвердить покупку

Да Нет

© Copyright 2019-2025. Created by Foreach.Soft

  • Инструкция по снятию с баланса
  • Контакты
  • Инструкция использования сайта
  • Инструкция загрузки документов
  • O'zbekcha