AUGSTKOLA
IT nodaļa
Informācijas tehnoloģijas fakultāte
1. kurss
Programmas izstrāde Java II vidē
Inversās matricas aprēķināšana
Izstrādāja:
Pārbaudīja:
Pieņēma:
ANOTĀCIJA
Studiju darba pārskatu veido 10 nodaļas ar bibliogrāfisko sarakstu, programmas pirmtekstu, diviem attēliem un vienu tabulu.
Pārskatā dota Inversās matricas definīcija, aplūkots uzdevuma risinājums – ievadīto skaitļu pārbaude inversās matricas aprēķināšanā. Ir sniegts uzdevuma risināšanas algoritma apraksts, blokshēma, programmas apraksts un lietotāja ceļvedis.
Programma sastādīta algoritmiskajā valodā Java un izpildīta ar Pentium – II 450 un Pentium III datoru operētājsistēmas Windows vidē.
SATURS
1. UZDEVUMA NOSTĀDNE 4
1.1. Uzdevumu matemātiskais formulējums 4
1.2. Matemātiskais pamatojums 4
2. VISPĀRĒJAIS KLAŠU APRAKSTS 6
2.1. Basic class (klase) 6
2.2. Getdata class (klase) 6
2.3. Laiks class (klase) 6
2.4. Mate class (klase) 6
2.5. Masivs class (klase) 7
3. ALGORITMA APRAKSTS UN KOPĒJĀ SHĒMA 8
4. PROGRAMMAS APRAKSTS 10
4.1. Lietojumsfēra 10
4.2. Ievaddati 10
4.3. Izvaddati 10
4.4. Moduļu apraksts 10
4.5. Moduļi un faili 10
5. PROGRAMMAS ATKĻŪDOŠANAS KĻŪDU ANALĪZE 12
6. PROGRAMMAS FUNKCIONĒŠANAS KONTROLES PIEMĒRS 13
7. LIETOTĀJA CEĻVEDIS 14
8. SECINĀJUMI 15
9. BIBLIOGRĀFISKAIS SARAKSTS 16
10. PROGRAMMAS PIRMTEKSTS 17
10.1. Getdata.class 17
10.2. Laiks.class 17
10.3. Basic.class 18
10.4. Mate.class 18
10.5. Masivs.class 20
1. UZDEVUMA NOSTĀDNE
1.1. Uzdevumu matemātiskais formulējums
Sastādīt programmu, kas dotajai matricai aprēķina inverso matricu.
1.2. Matemātiskais pamatojums
Inversā matrica eksistē tikai kvadrātiskām matricām.
Apzīmējumi:
A – matrica A-1 – inversā matrica
det – determinants P – piesaistītā matrica
A* – adjunkta matrica
Inversās matricas aprēķināšanas kārtība:
1. Aprēķina det(A). A ≠ 0, ja det(A) = 0, tad A-1 neeksistē.
2. Aprēķina adjunkta matricu A*.
3. Aprēķina piesaistīto matricu P (=A*T)
4. Aprēķina inverso matricu
Piemērs inversās matricas aprēķināšanai
Dota matrica:
1. Matricas determinantes aprēķināšana:
Secinājums: det(A) ≠ 0, tādā gadījumā drīkst turpināt aprēķināšanu.
2. Adjunkta matricas aprēķināšana:
Formula:
3. Piesaistītās matricas aprēķināšana:
4. Inversās matricas aprēķināšana:
2. VISPĀRĒJAIS KLAŠU APRAKSTS
Programmas struktūra ietver piecas klases: Getdata, Laiks, Basic, Mate, Masivs.
2.1. Basic class (klase)
Šī ir galvenā klase, jo tā satur metodi main. Klase Basic ar Getdata klases palīdzību iegūst datus un izveido masīvu mas, un ar konstruktora palīdzību piešķir objekta masīva mainīgajam divdimensijas masīvu. Basic klase ir saistīta ar klasi laiks, kas ir kā starpnieks, jo klase laiks „iedod” datus, bet klase basic tos apstrādā. Viena no svarīgākajām iespējām ir tā, ka šajā klasē tiek izmantots komandas, ar kuru palīdzību programma ķer problēmas, un kļūdas gadījumā uz ekrāna izvada, piem., „Kļūda”.
2.2. Getdata class (klase)
Klases Getdata galvenais uzdevums ir aprakstīt datus, lai pēc tam šos datus varētu ērti izmantot.
Metodes:
o public getdata – konstruktors;
o public double[][] back_mas – iegūst datus no masīva mas[][].
2.3. Laiks class (klase)
Klases Laiks pamatuzdevumi ir aprēķināt, cik ilgi programma ir rēķinājusi konkrēto piemēru un izvadīt uz ekrāna datumu un laiku. Ja programma uzdevumu ir izpildījusi sekundēs (sekundes laikā) jeb milisekundēs, tad programmas izvada atbilstošu paziņojumu, ka “programmas izpildes laiks ir mērāms milisekundēs”, bet, ja programma izpildījusies ilgāk, tad programma izvada programmas izpildes laiku.
Metodes:
o laiks(boolean yes) – konstruktors;
o private int calc();
o public int get_calc();
o public int get(int sk);
o public void set(int min, int sec, int min2, int sec2);
2.4. Mate class (klase)
Klases Mate galvenais uzdevums ir atrisināt šo uzdevumu. Šajā klasē glabājas matemātiskās funkcijas un procedūras, kas aprēķina determinanti, adjunktu, transponēto matricu un inverso matricu. Klase strādā ar diviem no klases masīva izveidotajiem objektiem.
Metodes:
o mate() – konstruktors;
o mate(masivs ma) – konstruktors;
o mate(math obj) – konstruktors;
o mate(int size) – konstruktors;
o mate(int size, int a) – konstruktors;
o private void setval(int rinda,int kolona, double vertiba);
o private void drukat(String text);
o private void setval_m(int rinda,int kolona, double vertiba);
o private double determ();
o public double adjunkts(int ARow, int ACol);
o private int reizinatajs(int rinda, int kolonna);
o private void adj_matr(int izm);
o public void rez(int izm);
2.5. Masivs class (klase)
Klases Masivs uzdevums ir saglabāt un apstrādāt datus.
Metodes:
o masivs(double mas[][], int izm) – konstruktors;
o masivs(int izm) – konstruktors;
o public void print_array(String teksts);
o private void prepare_array();
o private void prepare_array(double mas[][]);
o void set_size(int size);
o int get_size();
o void setval(int rinda,int kolona, double vertiba);
o double getval(int rinda,int kolona);
3. ALGORITMA APRAKSTS UN KOPĒJĀ SHĒMA
Programmas struktūra ietver funkcijas, procedūras un konstruktorus. Detalizēti tiek apskatīta klases Mate funkcija adj_matrica.
Programmas izpildes algoritms
1. att. Programmas izpildes algoritma shēma
Procedūras adj_matrica algoritms
Funkcija ir paredzēta inversās matricas aprēķināšanai.
o Izsauc klases Masivs procedūru print_array, lai izdrukātu uz ekrāna doto matricu.
o Izvada uz ekrānu tukšu rindu.
o Tiek izveidotas jauni objekti adj_mas un new_mas.
o Tiek izveidoti double tipa mainīgie c un det.
o Mainīgajam det tiek piešķirta funkcijas determ rezultāta vērtība.
o Iedarbina ciklu for, cikls darbojas tik ilgi, kamēr tiek izpildīts apakšcikla nosacījums (b < ASize) un paša cikla nosacījums, kad a < ASize).
a – rinda, b – kolonna, ASize – matricas izmērs;
o Apakšciklam katru reizi darbojoties tiek aprēķināts minors. Aprēķinātās vērtības tiek piešķirtas objektam adj_mas ar procedūras setval_m starpniecību.
Procedūras adj_matrica algoritma shēma parādīta 1. attēlā.
2. att. Procedūras adj_matr algoritma shēma
4. PROGRAMMAS APRAKSTS
4.1. Lietojumsfēra
Programma paredzēta inversās matricas aprēķināšanai.
Programmēšanas valoda – JAVA. Programma izpildīta ar Pentium II 450 datoru operētājsistēmas Windows vidē.
4.2. Ievaddati
Reāli pozitīvi un negatīvi skaitļi, piemēram 1, 0, -2.4. Skaitļi tiek ievadīti programmas kodā pirms kompilēšanas.
4.3. Izvaddati
4.3.1. Ziņojums: „Programmas izpildes laiks un datums…” – programmas startēšanas laiks un datums.
4.3.2. Ziņas par doto matricu.
4.3.3. Ziņas par aprēķināto matricu.
4.3.4. Ziņojums: „Programmas izpildes laiks ir mērāms milisekundēs (ms)”, ja programma uzdevumu ir izpildījusi mazāk kā 1 sekundi, pretējā gadījumā tiek parādīts cik sekundēs ir tikts veikts aprēķins.
4.3.5. Ziņojums: „Kļūda programmas uzsākšanā”, ja netiek ievēroti programmas ievada un izvada nosacījumi.
4.4. Moduļu apraksts
Programma sastāv no vairākiem moduļiem. Sīkāk tiek apskatīts modulis adj_matr no klases Mate.
Modulis private void adj_matr(int izm)
Funkcija: izdrukā uz ekrānu doto funkciju sadarbojoties ar klasi Masivs, tiek sagatavotas un piešķirtas vērtības ar citu moduļu (adjunkts, setval_m) palīdzību.
Parametri: modulim ir viens parametrs izm – vesela tipa mainīgais (int izm).Tas ir ieejas parametrs.
4.5. Moduļi un faili
1. tabula
Metodes (funkcija) Pirmteksta fails Objektfails
– basic.java basic.class
getdata,
back_mas getdata.java getdata.class
laiks,
calc,
get_calc,
get,
set. basic.java laiks.class
mate,
setval,
drukat,
setval_m,
determ,
adjunkts,
reizinatajs,
adj_matr,
rez mate.java mate.class
masivs,
print_array,
prepare_array,
set_size,
get_size,
setval,
getval masivs.java masivs.class
Programmas atkļūdošanai un izpildei tiks izveidots fails basic.class.
5. PROGRAMMAS ATKĻŪDOŠANAS KĻŪDU ANALĪZE
Programmas izveides laikā tika pielaistas dažas sintaktiskas kļūdas:
– izlaists semikols un pēdiņas;
– salīdzinājumam izmantota zīme „=” zīmes „= =” vietā utt. Šāda tipa kļūdas tika novērstas viena seansa gaitā.
6. PROGRAMMAS FUNKCIONĒŠANAS KONTROLES PIEMĒRS
Programmas darbības pārbaudei tika ievadīts studiju darba pārskata 1. daļā aplūkotais divdimensiju masīvs.
Ievadot masīvu , tika izvadīts rezultāts .
Tā kā iegūtais rezultāts sakrīt ar iepriekš aprēķināto matricu, varam apgalvot, ka izpildot programmu rezultāts, tika izvadīts pareizs. Var gaidīt, ka programma dos korektus rezultātus.
7. LIETOTĀJA CEĻVEDIS
Programmas izpilde sākas ar faila basic.class palaišanu.
Pēc programmas palaišanas tiek izvadīta dotā matrica, aprēķinātā inversā matrica, programmas izpildes laiks un tās sākšanas laiks.
Programmu startēšana notiek no command rindas: Java basic
Pirms tam visas klases jānokompilē: javac.exe masivs.java, javac.exe mate.java, javac.exe laiks.java, javac.exe getdata.java, javac.exe basic.java.
Programmas izpildes laiks un datums: 2002.08.04 07:25:08
Izdrukā programmas uzsākšanas datumu un laiku.
DOTĀ MATRICA
************************************************************
1.0 1.0 1.0
2.0 -1.0 6.0
3.0 -2.0 0.0
************************************************************
Izdrukā doto matricu.
APRĒĶINĀTĀ INVERSĀ MATRICA
*************************************************************************************
-0.41379310344827586 0.06896551724137931 -0.2413793103448276
-0.6206896551724138 0.10344827586206896 0.13793103448275862
0.034482758620689655 -0.1724137931034483 0.10344827586206896
*************************************************************************************
Izdrukā aprēķināto matricu.
Programmas izpildes laiks ir mērāms milisekundēs (ms)
Izdrukā programmas izpildes un laiku.
Piemērs, logam, ko izvada uz ekrāna:
Programmas izpildes laiks un datums: 2002.08.04 07:25:08
DOTĀ MATRICA
******************************************************************************************************
1.0 1.0 1.0
2.0 -1.0 6.0
3.0 -2.0 0.0
******************************************************************************************************
APRĒĶINĀTĀ INVERSĀ MATRICA
******************************************************************************************************
-0.41379310344827586 0.06896551724137931 -0.2413793103448276
-0.6206896551724138 0.10344827586206896 0.13793103448275862
0.034482758620689655 -0.1724137931034483 0.10344827586206896
******************************************************************************************************
Programmas izpildes laiks ir mērams milisekundēs (ms)
Programmu izveidoja: (c) Gunārs Grundštoks. IT 0111. 08.04.2002.
Papildus nosacījumi:
o ievades masīvs nedrīkst būt mazāks par 2×2 masīva robežām;
o ja, masīvā nebūs ievadīts cipars, programma to uzskatīs par „nulli”.
8. SECINĀJUMI
Kursa darba izpildes gaitā ir veikta uzdevumu analīze, formulētas prasības programmai, izstrādāts algoritms un izveidota programma valodā JAVA inversās matricas aprēķināšanai. Programma atkļūdota un izpildīta ar Pentium II un Pentium III datoru, iegūtie rezultāti pilnīgi atbilst definētajam uzdevumu matemātiskajam formulējumam.
Darbs bija sarežģīts. Tā izpildei prasīja vairākas dienas, no kurām dažas dienas prasīja uzdevumu analīzei un programmas izveidei. Pārējās dienas – pārskata noformēšana.
Sastādītājā programmā var uzlabot: pārbaudi vienā programmas palaišanas laikā. Iespējams arī uzlabot (optimizēt) metodes, procedūras un klases.
Darba izpilde deva iespēju praktiski apgūt programmēšanas valodu JAVA un tās programmēšanas vidi, kā arī iemācīties to, kā pareizi veidot programmas projektu un strādāt ar to.
9. BIBLIOGRĀFISKAIS SARAKSTS
1. Art Gittelman. Objects To Components With the Javatm Platform. – California, 2000. – 589. lpp.
2. П. Ноутон, Г. Шилдт. Java 2. – Петервург, 2000ю – 1050 с.
10. PROGRAMMAS PIRMTEKSTS
10.1. Getdata.class
public class getdata {
private double mas[][] = {
{1, 1, 1,},
{2, -1, 6},
{3, -2, 1}};
public getdata(){}
public double[][] back_mas(){
return mas;
}
}
10.2. Laiks.class
import java.lang.System;
import java.util.Date;
class laiks {
private int h,m,s,l;
private int m1, m2, s1, s2;
long test;
Date today = new Date();
// ———————————————————————–
laiks(boolean yes){
h = today.getHours();
m = today.getMinutes();
s = today.getSeconds();
if (yes) {
System.out.println(“Programmas izpildes laiks un datums: ” + today.toLocaleString());
System.out.println();}}
// ———————————————————————–
private int calc() {
int rez;
rez = s2 – s1;
return rez;}
// ———————————————————————–
public int get_calc() {
return calc();}
// ———————————————————————–
public int get(int sk) {
int rez = 0;
if (sk == 1) {rez = h;}
if (sk == 2) {rez = m;}
if (sk == 3) {rez = s;}
return rez;}
// ———————————————————————–
public void set(int min, int sec, int min2, int sec2){
m1 = min; m2 = min2; s1 = sec; s2 = sec2;
}}
10.3. Basic.class
class basic {
public static void main(String args[]) {
laiks moment = new laiks(true);
getdata mas_imp = new getdata();
double mas[][] = mas_imp.back_mas();
try {
if (mas.length <= 2) {
System.out.println(“Kļūda! Matricas izmēriem jābūt lielākiem par 2×2”);}
else {
int izm = mas.length;
masivs set = new masivs(mas,izm);
mate met = new mate(set);
met.rez(izm);
laiks moment2 = new laiks(false);
moment.set(moment.get(2),moment.get(3),moment2.get(2),moment.get(3));
if (moment.get_calc() == 0) {System.out.println(“Programmas izpildes laiks ir mērams milisekundēs (ms)”);}
else {
System.out.println(“Programmas izpildes laiks: ” + moment.get_calc() + ” sekundes”);}
System.out.println(“Programmu izveidoja: (c) Gunārs Grundštoks. IT 0111. 08.04.2002.”);
System.out.println();
}}
catch (Exception e) {
System.out.println(“Kļūda programmas uzsākšanā!”);
//e.printStackTrace();}
}}
10.4. Mate.class
class mate {
private int Asize=2;
private masivs mas, adj_mas, new_mas;
private double rez;
// ———————————————————————–
mate() {}
// ———————————————————————–
mate(masivs ma) {
Asize = ma.get_size();
mas = ma;}
// ———————————————————————–
mate(math obj){
Asize = obj.get_Asize();
mas.set_size(Asize);}
// ———————————————————————–
mate(int size) {
Asize = size;
mas = new masivs(Asize);
}
// ———————————————————————–
mate(int size, int a) {
if (a == 1) {adj_mas = new masivs(size);}
if (a == 2) {new_mas = new masivs(size);}
}
// ———————————————————————–
private void setval(int rinda,int kolona, double vertiba){
if ((rinda > -1) & (kolona > -1) & (rinda < Asize) & (kolona < Asize)) {
mas.setval(rinda,kolona,vertiba);
}
}
// ———————————————————————–
private void drukat(String text) {
adj_mas.print_array(text);
}
// ———————————————————————–
private void setval_m(int rinda,int kolona, double vertiba){
if ((rinda > -1) & (kolona > -1)) {
adj_mas.setval(rinda,kolona,vertiba);
}
}
// ———————————————————————–
private double determ() {
double temp = 0;
if (mas.get_size() > 2) {
double val;
for (int row = 0; row < mas.get_size();row++) {
val = mas.getval(row,1);
temp = temp + (val * adjunkts(row,1));
}
}
else {
temp = ((mas.getval(0,0) * mas.getval(1,1)) – (mas.getval(0,1) * mas.getval(1,0)));
}
return temp;
}
// ———————————————————————–
public double adjunkts(int ARow, int ACol) {
int newsize = mas.get_size() – 1;
mate mas_obj = new mate(newsize);
int small_row = -1; int small_col = -1;
for (int large_row = 0; large_row < mas.get_size(); large_row++) {
if (large_row != ARow) {
small_row++;
small_col = -1;
for (int large_col = 0; large_col < mas.get_size(); large_col++) {
if (large_col != ACol) {
small_col++;
mas_obj.setval(small_row, small_col,
mas.getval(large_row, large_col));
}
}
}
}
double adj_rez;
adj_rez = mas_obj.determ() * reizinatajs(ARow, ACol);
return adj_rez;
}
// ———————————————————————–
private int reizinatajs(int rinda, int kolonna) {
int reiz = 1;
if (((rinda+kolonna)%2) != 0) reiz = -1;
return reiz;
}
// ———————————————————————–
private void adj_matr(int izm) {
mas.print_array(“DOTĀ MATRICA”);
System.out.println();
mate adj_mas = new mate(izm, 1);
mate new_mas = new mate(izm, 2);
double c, det;
det = determ();
for (int a = 0; a < Asize; a++) {
for (int b = 0; b < Asize; b++) {
c = adjunkts(a,b)/(det*-1);
adj_mas.setval_m(b,a,c);
}
}
adj_mas.drukat(“APRĒĶINĀTĀ INVERSĀ MATRICA”);
}
// ———————————————————————–
public void rez(int izm) {
adj_matr(izm);
}
}
10.5. Masivs.class
class masivs {
private double array[][];
private int Asize = 2;
// ———————————————————————–
masivs(double mas[][], int izm) {
Asize = izm;
prepare_array(mas);
}
// ———————————————————————–
masivs(int izm) {
Asize = izm;
prepare_array();
}
// ———————————————————————–
public void print_array(String teksts) {
System.out.println(teksts);
System.out.print(“****************************************************”);
System.out.println(“**************************************************”);
for (int a = 0; a < Asize; a++) {
for (int b = 0; b < Asize; b++) {
System.out.print(array[a][b]+” “); }
System.out.println();
}
System.out.print(“****************************************************”);
System.out.println(“**************************************************”);
}
// ———————————————————————–
private void prepare_array() {
array = new double[Asize][Asize];
for (int tmp1 = 0; tmp1 < Asize; tmp1++) {
for (int tmp2 = 0; tmp2 < Asize; tmp2++) {
setval(tmp1,tmp2,0);
}
}
}
// ———————————————————————–
private void prepare_array(double mas[][]) {
array = new double[Asize][Asize];
for (int tmp1 = 0; tmp1 < Asize; tmp1++) {
for (int tmp2 = 0; tmp2 < Asize; tmp2++) {
try {
setval(tmp1,tmp2,mas[tmp1][tmp2]);
}
catch (Exception e) {
System.out.println(“Nav pareizi nodefinēts masīvs! Tukšās vietas tiks aizvietotas ar 0!”);
}
}
}
}
// ———————————————————————–
void set_size(int size) {
Asize = size;
}
// ———————————————————————–
int get_size() {
return Asize;
}
// ———————————————————————–
void setval(int rinda,int kolona, double vertiba) {
if ((rinda > -1) & (kolona > -1) & (rinda < Asize) & (kolona < Asize)) {
array[rinda][kolona] = vertiba;
}
}
// ———————————————————————–
double getval(int rinda,int kolona) {
return array[rinda][kolona];
}
// ———————————————————————–
}