Java forráskód - címke - it-tanfolyam.hu

Egy matematika érettségi feladat megoldása programozással 2023

2023. május 12.2023. május 9. Szerző: Kaczur Sándor

A 2023-as középszintű matematika érettségi feladatsorból az 5. feladat alkalmasnak bizonyult arra, hogy a programozás eszköztárával oldjuk meg. Rögtön többféleképpen is, hogy összehasonlíthatóak legyenek egymással. Érdekes belegondolni, hogy mennyire más lehetne a problémamegoldás, ha programozhatnánk a matematika érettségi vizsgán. A teljes feladatsor letölthető az oktatas.hu-ról.

5. feladat

Adja meg a 420 és az 504 legnagyobb közös osztóját! Megoldását részletezze!

Íme kulcsszavakban, mit érdemes átgondolni a megoldás előtt: számelmélet alaptétele, prímfelbontás (prímtényezős felbontás, faktorizáció), osztópár, prímek szorzata, prímtényezők szorzata, kanonikus alak, euklideszi algoritmus.

1. megoldás

private void lnko1(int aa, int bb) {

if(aa>0 && bb>0) {

int a=Math.max(aa, bb), b=Math.min(aa, bb), m=a%b;

while(m!=0) {

//System.out.println(a+" = "+a/b+" * "+b+" + "+m);

a=b;

b=m;

m=a%b;

}

//System.out.println(a+" = "+a/b+" * "+b+" + "+m);

int lnko=b;

System.out.println("lnko ("+aa+"; "+bb+") = "+lnko);

}

else

System.out.println("Mindkét számnak pozitívnak kell lennie!");

}

Az első megoldás az euklideszi algoritmus alkalmazása. A metódus paraméterezhető. Pozitív paramétereket vár és képes kiírni a konzolra a két szám legnagyobb közös osztóját. A módszer alapötlete: a legnagyobb közös osztó nem változik, ha a nagyobb számot a két szám különbségével helyettesítjük. Ezzel csökken a nagyobb szám, így a cserék ismétlésével egyre kisebb számokat kapunk, amíg a két szám egyenlővé nem válik. Ez az eddigi számpároknak, így az eredeti számpárnak is a legnagyobb közös osztója. Az eredményt az utolsó nem nulla maradék while(m!=0) adja meg int lnko=b;. Az algoritmus lépésszáma csökkenthető, ha a>b, de ennek ellenőrzése nélkül is működik. Mivel a feladat kéri a megoldás részletezését, így aktiválva a megjegyzésbe tett forráskódokat, a kiírásból könnyen érthető, mi és hogyan történik:

504 = 1 * 420 + 84

420 = 5 * 84 + 0

lnko (420; 504) = 84

A konkrét esetben a metódus eredménye: lnko (420; 504) = 84. Nagyobb számok esetében „beszédesebb” a program kiírása, több lépésben írja ki a megoldáshoz vezető utat, ezért érdemes többféle paraméterrel is tesztelni a metódust.

2. megoldás

private List<Integer> primtenyezok(int n) {

List<Integer> primtenyezokLista=new ArrayList<>();

if(n>0)

for(int i=2; i<=n; i++)

while(n%i==0) {

//System.out.printf("%5d | %d\n", n, i);

primtenyezokLista.add(i);

n/=i;

}

//System.out.printf("%5d | \n", n);

return primtenyezokLista;

}

private String primtenyezokSzorzatkent(

List<Integer> primtenyezok) {

return primtenyezok.stream().map(i->i.toString()).

collect(Collectors.joining(" * "));

}

private void lnko2(int a, int b) {

if(a>0 && b>0) {

List<Integer> aPrimtenyezok=primtenyezok(a);

//System.out.println(a+" = "+

// primtenyezokSzorzatkent(aPrimtenyezok));

List<Integer> bPrimtenyezok=primTenyezok(b);

//System.out.println(b+" = "+

// primtenyezokSzorzatkent(bPrimtenyezok));

List<Integer> kozosPrimtenyezok=new ArrayList<>();

aPrimtenyezok.stream().distinct().forEach((prim)->{

long aPrimDb=aPrimtenyezok.stream().filter(p->p==prim).count();

long bPrimDb=bPrimtenyezok.stream().filter(p->p==prim).count();

long minEgyediPrimDb=Math.min(aPrimDb, bPrimDb);

if(minEgyediPrimDb>0)

for(int i=1; i<=minEgyediPrimDb; i++)

kozosPrimtenyezok.add(prim);

});

int lnko=kozosPrimtenyezok.stream().reduce(1, (p1, p2)->p1*p2);

System.out.println("lnko ("+a+"; "+b+") = "+

/*primtenyezokSzorzatkent(kozosPrimtenyezok)+" = "+*/lnko);

}

else

System.out.println("Mindkét számnak pozitívnak kell lennie!");

}

A második megoldás a prímtényezős felbontásokon alapul. Mindkét szám esetén gyűjtsük össze listában ezeket, majd vegyük a két lista közös részét. (Ha lista helyett halmazok lennének, akkor metszet programozási tétel lenne.) A generikus listákba prímszámok kerülnek és bármelyik többször is előfordulhat. (Ezért most a leghosszabb közös részsorozat(ok) előállítása szükséges.) Addig osztjuk a számot 2-vel, amíg lehet, utána következik a többi prímosztó, amíg vannak. Érdemes több metódusra szétosztani a megoldást, mert jóval áttekinthetőbb és karbantarthatóbb Java forráskódot eredményez. A beszédes változó, objektum és metódusnevek is segítenek a megértésben. A második megoldás természetesen ugyanazt az eredményt adja, mint az első megoldás. Aktiválva a megjegyzésbe tett forráskódokat, a kiírásból most is könnyen érthetővé válik (középiskolás matematikaóra-szerűen), mi és hogyan történik:

420 | 2

210 | 2

105 | 3

35 | 5

7 | 7

1 |

420 = 2 * 2 * 3 * 5 * 7

504 | 2

252 | 2

126 | 2

63 | 3

21 | 3

7 | 7

1 |

504 = 2 * 2 * 2 * 3 * 3 * 7

lnko (420; 504) = 2 * 2 * 3 * 7 = 84

Kanonikus alakban: 420 = 2² * 3 * 5 * 7, 504 = 2³ * 3² * 7, így lnko (420; 504) = 2² * 3 * 7. Azaz összeszorozzuk a közös prímtényezőket az előforduló legkisebb hatványon.
A megoldás erősen épít a generikus kollekciók esetén jól használható Stream API lambda kifejezéseire. Ezeket most nem részletezem, helyette ajánlom a szakmai blogból a lambda kifejezés címkét.

Érdemes átgondolni

Nagy prímszámok esetén az euklideszi algoritmus nem hatékony. Az algoritmus végrehajtása kifejezetten lassú például a Fibonacci-számok esetén. A prímtényezőkre bontás feltételezett bonyolultságát számos kriptográfiai algoritmus használja ki. Vannak különleges esetek is, például: egyforma számok, az egyik szám 1, a két szám egymás többszöröse.
A feladat nem kérte a legkisebb közös többszörös meghatározását, de ha tudjuk a lnko(a, b)-t, akkor abból könnyen adódik a lkkt(a, b)=a*b/lnko(a, b).
A legnagyobb közös osztó tulajdonságait megismerve az euklideszi algoritmus könnyen optimalizálható. Számos esetben ellenőrzést végezhetünk, illetve triviális alapesetek is vannak. Létezik kiterjesztett euklideszi algoritmus is.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Ajánljuk matematika érettségi feladat címkénket, mert a témában évről-évre blogolunk.

A feladat a Java SE szoftverfejlesztő tanfolyam szakmai moduljának 5-8. óra: Vezérlési szerkezetek, 9-12. óra: Metódusok, rekurzió, valamint 17-28. óra: Objektumorientált programozás alkalmaihoz kötődik.

Sankey-diagram készítése

2023. április 17. Szerző: Kaczur Sándor

A Sankey-diagram alkalmas kétféle adatsor közötti N:M fokszámú kapcsolat, összefüggés és a köztes átmenet ábrázolására. Hangsúlyozza a fő átvitelt vagy áramlatokat egy rendszeren belül. Az áramlás irányát nyíllal szemlélteti és az áramlatok szélessége arányos az áramlási mennyiségekkel.

Feladat

Jelenítsük meg HTML formátumú weboldalként a magyarországi régiókban a foglalkoztatottak számát nemzetgazdasági szektorok szerint a KSH 2018-as adatsora alapján! Automatizáljuk egy Java programmal úgy a feladatot, hogy az év paraméterként megadható legyen!

Tervezés

A KSH témastruktúrában a táblázat elérési útja:

5. Területi adatok,
5.1. A munkaerő-piaci tendenciák Magyarország régióiban,
5.1.3. A foglalkoztatottak száma nemzetgazdasági szektorok szerint, nemenként (2008–)

Online böngészhető táblázat:
https://www.ksh.hu/docs/hun/xstadat/xstadat_hosszu/h_qlf017.html

Letölthető táblázat (XLS formátumban):
https://www.ksh.hu/docs/hun/xstadat/xstadat_hosszu/xls/h5_1_3.xls

A táblázatban lévő adatforrás szükséges része látható az ábrán:

A táblázatban a régiók az A105:A112 cellatartományban találhatók. A hozzájuk tartozó 3 nemzetgazdasági szektor a B-C-D oszlopok azonos soraiból olvashatók ki. POJO-k létrehozása mindenképpen hasznos a megvalósításhoz, például new SankeyData("Közép-Dunántúl", "Szolgáltatás", 253.89). Ezekből generikus listát is célszerű építeni: List<SankeyData> sankeyDataList.

Többféleképpen is hozzájuthatunk az adatokhoz attól függően, hogy milyen előismeretekkel rendelkezünk a különböző tanfolyamainkon:

A Java SE szoftverfejlesztő tanfolyamon „kézzel” letölthetjük a projekt files mappájába az XLS fájlt. Ezután akár manuálisan is összeállítható a POJO lista, vagy a JExcel API-val is hatékonyan feldolgozható a XLS fájl aktuális munkalapja. Fájlkezelés előtt az összeállított HTML fájlt kiírathatjuk a konzolra, ahonnan „kézzel” vágólapozva létrehozhatjuk belőle a szükséges HTML fájlt. Fájlkezeléssel persze adott mappába, adott fájlnévvel, kivételkezeléssel a java.io vagy java.nio csomagot használva a HTML fájl generálása is automatizálható.
A Java EE szoftverfejlesztő tanfolyamon megvalósítható, hogy a program kivételkezeléssel hálózati kapcsolatot épít, majd letölti az XLS fájlt és ezzel a feladat visszavezethető az előző esetekre. Azt is megtehetjük, hogy az XLS fájlt nem töltjük le, hanem olvasunk belőle közvetlenül a webről. Ekkor is rendelkezésünkre áll a POJO lista. Itt már tudunk HTML fájlt is automatikusan generálni.

Tanulmányoznunk kell a Google Charts galériában a Sankey diagram dokumentációját! Meg kell ismernünk a paraméterezési lehetőségeit és JavaScript forráskódját!

Megvalósítás

private String createSankeyDiagram(List<SankeyData> sankeyDataList) {

String sankeyData=

sankeyDataList.stream().map(SankeyData::toString).

collect(Collectors.joining(",\n ", " ", "\n"));

String html=

"<html>\n" +

" <head>\n" +

" <script type=\"text/javascript\" " +

" src=\"https://www.gstatic.com/charts/loader.js\"></script>\n" +

" <script type=\"text/javascript\">\n" +

" google.charts.load('current', {'packages':['sankey']});\n" +

" google.charts.setOnLoadCallback(drawChart);\n" +

"\n" +

" function drawChart() {\n" +

" var data = new google.visualization.DataTable();\n" +

" data.addColumn('string', 'Régió');\n" +

" data.addColumn('string', 'Nemzetgazdasági szektor');\n" +

" data.addColumn('number', 'Foglalkoztatottak száma (ezer fő)');\n" +

" data.addRows([\n" +

"#SankeyData#" +

" ]);\n" +

"\n" +

" var options = {\n" +

" width: 500,\n" +

" };\n" +

"\n" +

" var chart=new google.visualization.Sankey("+

" document.getElementById('sankey_basic'));\n" +

" chart.draw(data, options);\n" +

" }\n" +

" </script>\n" +

" </head>\n" +

" <body>\n" +

" <div id=\"sankey_basic\" style=\"width: 500px; height: 300px;\"></div>\n" +

" </body>\n" +

"</html>";

return html.replace("#SankeyData#", sankeyData);

}

A createSankeyDiagram() függvény létrehozza a HTML fájl szöveges tartalmát. Átveszi adatforrásként a sankeyDataList generikus POJO listát. A String típusú sankeyData objektum tartalmazza a Stream API-val hatékonyan összefűzött – POJO-któl elkért – toString() szövegeket. Ezek a diagramhoz szükséges adatok ( addRows …). Például: "['Közép-Dunántúl', 'Szolgáltatás', 253.89]". A String típusú html objektum kezdetben tartalmazza a diagramhoz nem szükséges fix részeket, a diagram alapbeállításait, valamint a diagram fejlécéhez szükséges metaadatokat ( addColumn… Régió, Nemzetgazdasági szektor, Foglalkoztatottak száma (ezer fő)). A függvény végül a html objektum #SankeyData# részét cseréli a sankeyData-val és az adatfüggő résszel frissített HTML tartalommal tér vissza.

Eredmény

Az egyik eredmény a generált HTML fájl (benne a grafikonhoz tartozó JavaScript) forráskódját tartalmazza:

<html>

<head>

src="https://www.gstatic.com/charts/loader.js"></script>

google.charts.load('current', {'packages':['sankey']});

google.charts.setOnLoadCallback(drawChart);

function drawChart() {

var data=new google.visualization.DataTable();

data.addColumn('string', 'Régió');

data.addColumn('string', 'Nemzetgazdasági szektor');

data.addColumn('number', 'Foglalkoztatottak száma (ezer fő)');

data.addRows([

['Budapest', 'Mezőgazdaság', 1.251],

['Budapest', 'Ipar', 148.004],

['Budapest', 'Szolgáltatás', 684.56],

['Pest', 'Mezőgazdaság', 11.845],

['Pest', 'Ipar', 182.934],

['Pest', 'Szolgáltatás', 400.425],

['Közép-Dunántúl', 'Mezőgazdaság', 22.684],

['Közép-Dunántúl', 'Ipar', 222.544],

['Közép-Dunántúl', 'Szolgáltatás', 253.89],

['Nyugat-Dunántúl', 'Mezőgazdaság', 25.64],

['Nyugat-Dunántúl', 'Ipar', 202.794],

['Nyugat-Dunántúl', 'Szolgáltatás', 253.44],

['Dél-Dunántúl', 'Mezőgazdaság', 26.865],

['Dél-Dunántúl', 'Ipar', 122.281],

['Dél-Dunántúl', 'Szolgáltatás', 224.863],

['Észak-Magyarország', 'Mezőgazdaság', 21.866],

['Észak-Magyarország', 'Ipar', 186.662],

['Észak-Magyarország', 'Szolgáltatás', 276.754],

['Észak-Alföld', 'Mezőgazdaság', 48.301],

['Észak-Alföld', 'Ipar', 206.593],

['Észak-Alföld', 'Szolgáltatás', 384.82],

['Dél-Alföld', 'Mezőgazdaság', 56.402],

['Dél-Alföld', 'Ipar', 174.068],

['Dél-Alföld', 'Szolgáltatás', 329.982]

]);

var options={

width: 500,

};

var chart=new google.visualization.Sankey(

document.getElementById('sankey_basic'));

chart.draw(data, options);

}

</script>

</head>

<body>

</body>

</html>

A másik eredmény a Sankey-diagram képernyőképe, amelyről kiválóan leolvashatók az értékek:

A böngészőben megjelenő HTML oldalon a Sankey-diagram dinamikusan – az egérkurzor pozíciójától függően – képes az aktuális adatok megjelenítésére, mintegy lebegő jelmagyarázatként.

A bejegyzéshez tartozó teljes forráskódot ILIAS e-learning tananyagban tesszük elérhetővé tanfolyamaink résztvevői számára.

Naprendszer szimuláció – megvalósítás Java nyelven

2023. április 16.2023. március 10. Szerző: Friedel Attila

Naprendszer szimulációt terveztünk és valósítottunk meg Java nyelven, amit három részből álló blog bejegyzés sorozatban mutatunk be (ez a 3. rész):

Naprendszer szimuláció 1. rész – elméleti háttér
Naprendszer szimuláció 2. rész – objektumorientált tervezés
Naprendszer szimuláció 3. rész – megvalósítás Java nyelven

A Naprendszer szimuláció megvalósítása Java nyelven

Fejlesztőeszközként a Java Swinges projekthez a JDK+JRE aktuális verziót támogató NetBeans IDE-t használtuk. Hibakeresés során, a modell adatainak ellenőrzését és a működés helyességének egyszerű tesztelését, debuggolást konzolra történő szöveges kiírással oldottuk meg. A megvalósítás során az előre megtervezett osztálydiagramok alapján készült el Java nyelven a forráskód. Az MVC modell szerint elkülönített programrészek külön csomagokba kerültek, ezzel is kiemelve a funkciók szerinti szétválasztást – eleget téve a terv követelményeinek.

Részlet a Java forráskódból

Megmutatjuk a Java forráskódnak azt a részét, ami megvalósítja az elméleti háttérnél ismertetett transzformációs mátrix alkalmazását X tengely körüli elforgatásra, a nézőponttól való távolság függvényében az égitest látható méretének kiszámítását, valamint a 3D→2D leképezést.

Point3D forog = new Point3D(

b.getPozicio().getX(),

b.getPozicio().getY() * Math.cos(forogZ) +

b.getPozicio().getZ() * Math.sin(forogZ),

-1 * b.getPozicio().getY() * Math.sin(forogZ) +

b.getPozicio().getZ() * Math.cos(forogZ));

int egitestMeret = (int)(

(AdatInterfesz.MELYSEG * b.getSize()) /

(AdatInterfesz.MELYSEG - forog.getZ()));

Point2D kepXY = new Point2D(

(forog.getX() * AdatInterfesz.MELYSEG /

(AdatInterfesz.MELYSEG - forog.getZ()) /

size) + origo.getX() - egitestMeret / 2,

(forog.getY() * AdatInterfesz.MELYSEG /

(AdatInterfesz.MELYSEG - forog.getZ()) /

size) + origo.getY() - egitestMeret / 2);

A teljes és megjegyzésekkel ellátott forráskód ILIAS e-learning tananyagban hozzáférhető, letölthető, tesztelhető tanfolyamaink résztvevői számára.

Az elkészült Java Swinges alkalmazás felhasználói felülete

Tapasztalatok

A Java nyelv erősen típusos, így a kötelező és sok lebegőpontos/egész átalakítás miatt észrevehető, hogy a legkisebb égitest (Hold) kissé ugrál.
Az OO szempontból szép Java megvalósítás könnyen módosítható és bővíthető, a funkciók jól csoportosítottak, a felelősségi kör egyértelműen meghatározott.
A projekt megtervezéséhez és elkészítéséhez magasabb szintű absztrakciós készség szükséges.
A példaprogram alkalmas a különböző szakterületek, témakörök (matematika – lineáris algebra, fizika, számítógépes grafika, virtuális valóság modellezése) közötti kapcsolatok felismertetésére, megerősítésére, a (legalább részben) egymásra épülések felderítésére.
A terv átgondolásával, implementálásával gyors, látványos eredmény érhető el, a sikerélmény hamar jelentkezik.

Továbbfejlesztési lehetőségek

Célszerű ötlet a hardveres gyorsítás és 3D megjelenítés megvalósítása.
Felkínálható lenne a felhasználó számára több paraméter módosítása.
Az égitestek lehetnének textúrázhatók is.
Az égitestek pozíciója kiinduló helyzetben lehetne valós.
A szimuláció szükség esetén lehetne elindítható, leállítható, újraindítható, gyorsítható, lassítható.
A terv könnyen implementálható lehet Java3D technológia alkalmazásával, illetve DirectX és/vagy OpenGL támogatással is.
Az égitestek pozíciója és mozgása demonstrálhatna/modellezhetne nevezetes együttállást is, külön esettanulmányként.
A program paraméterezhető lehetne konfigurációs fájlból (amelynek formátuma tetszőleges: INI, XML).
Fejlettebb matematikai modell is alkalmazható lenne.

Forrás

Friedel, A.; Kaczur, S. (előadó: Friedel, A.): Naprendszer szimuláció a Virtuális valóság modellezése tantárgyban, Informatika Korszerű Technikái Konferencia, Dunaújváros, Dunaújvárosi Főiskola, 2012. november 16-17. (előadás hazai konferencián)
Friedel, A.; Kaczur, S.: Naprendszer szimuláció a Virtuális valóság modellezése tantárgyban, Cserny, L.; Hadaricsné Dudás, N.; Nagy, B. (szerk): Dunakavics Könyvek 2. – Az Informatika Korszerű Technikái, Dunaújvárosi Főiskola, Új Mandátum Könyvkiadó, 2014, ISBN 978 963 287 069 4, ISSN 2064-3837, p. 72-84 (magyar nyelvű szakcikk)

Naprendszer szimuláció – objektumorientált tervezés

2023. március 10.2023. február 7. Szerző: Friedel Attila

Naprendszer szimulációt terveztünk és valósítottunk meg Java nyelven, amit három részből álló blog bejegyzés sorozatban mutatunk be (ez a 2. rész):

Naprendszer szimuláció 1. rész – elméleti háttér
Naprendszer szimuláció 2. rész – objektumorientált tervezés
Naprendszer szimuláció 3. rész – megvalósítás Java nyelven

A Naprendszer szimuláció objektumorientált tervezése

A Naprendszer égitestjeinek ábrázolása a valódi világban előforduló méretük és távolságuk szerint történik azért, hogy a szimuláció stabil legyen. A példában a Nap és a három belső bolygó szerepel, valamint a Hold. Utóbbi igazolja, hogy nem csak Nap középpontú égitestekre működőképes a modell. A szimuláció diszkrét lépések véges sorozataként valósul meg, az egyes lépések között az égitestek a virtuális térben egyenes vonalú egyenletes mozgást végeznek. Olyan lépésközt kell választani, amely rövid idő alatt kellően nagy változást képes bemutatni, ilyen például az 1 számítási ciklus / 1 nap érték. 10 képkocka / másodperces megjelenítést feltételezve – melyet egy időzítő biztosít – egy virtuális év kb. 37 másodperc alatt telik el, vagyis a Föld ennyi idő alatt tesz meg egy teljes fordulatot a Nap körül. Az égitestek kezdő pozíciója fiktív, nem függ konkrét dátumtól, együttállástól, méretük a jobb láthatóság érdekében torzított.

A program indításakor a szimuláció automatikusan indul, és nincs lehetőség a leállításra. Az alkalmazás felületének tetején foglalnak helyet a kezelő nyomógombok, a többi részt a megjelenítés/transzformált modelltér tölti ki. Futás közben – egyszerű eseménykezelést megvalósítva – lehet változtatni a méretarányt és a nézőpontot, így az ekliptika síkját felülről és elbillentve is ábrázolhatjuk.

Kivételkezelés nem szükséges a programhoz, mert ez egy önálló demonstrációs eszköz, nem épül rá több elem, nem érhetőek el a szolgáltatásai külső programok számára.

Meghatározott cél és a szempontok: a Java projektben a csomagokat az MVC szerint hozzuk létre, a funkciókat logikusan osszuk szét, csoportosítsuk, tartsuk be az objektumorientált szemléletmód elveit, használjunk interfészt, biztosítsuk az egységbezárást, legyen öröklődés, alkalmazzuk a polimorfizmust, legyen szép és elegáns megoldás, legyen a jelölésrendszer UML osztálydiagram. Mindez grafikus asztali Java alkalmazásként valósuljon meg.

A modell csomag (M – Model)

A modellhez 1 interfész és 5 osztály tartozik:

Az AdatInterfesz tárolja a modell számításhoz és megjelenítéshez tartozó konstansait (ezek a szimuláció paraméterei), és metódusfejet nem tartalmaz. A Pont2D osztály egy kétdimenziós pont sémája, valós x és y koordinátapárral, eltol() és túlterhelt tavolsag() metódusokkal. Ennek leszármazottja a Pont3D osztály, amely mindezt három dimenzióban biztosítja, valamint pozícióként és sebességvektorként is használható. Az Egitest osztályból létrehozott objektumnak van mérete, pozíciója, sebessége, színe és tömege. Az interfészt implementálja az Adattar osztály, amelynek egitestLista nevű generikus listája elérhetővé és egységesen kezelhetővé teszi a tervben felsorolt 5 égitestet. A ZIndex osztályú objektumok az égitestek kirajzolásakor szükséges mélységpufferbeli adatot képesek kezelni.

A nézet csomag (V – View)

A nézet 2 osztályból áll:

Az Ablak osztály egy javax.swing.JFrame leszármazott, az alkalmazás teljes grafikus felületét biztosítja, valamint előkészíti az eseménykezelést. Tartalompanelje négy vezérlő nyomógombot tartalmaz és rajta található a rajzpanel objektum, a vaszon. A RajzPanel osztály egy javax.swing.JPanel leszármazott, amely kapcsolatban áll az adattárral, és kezeli a mélységpuffert. Ez felel a szimulált 3D térben lévő objektumok 2D-beli leképezéséért, figyelembe véve a nézőpont elmozdulását is. A rajzolást a felüldefiniált (öröklődés) paintComponent() metódus végzi el.

Az Ablak osztályú objektum elsődleges szerepet tölt be a megjelenítésben, keretbe foglalva a látható komponenseket, vagyis a kezelő nyomógombokat és a modellteret. Az objektum megvalósít egy ActionListener eseménykezelőt, így a program reagálni tud a felhasználó által kiváltott eseményekre. Az ablakobjektum nagyítás és forgatás üzenetek küldésével saját vásznát – és csak azt – frissíti.

A vezérlő csomag (C – Controller)

A vezérlőt 2 osztály valósítja meg:

A Main osztály összefogja a projektet, ez a végrehajtás belépési pontja. Szükség szerint átadja az MVC szerinti objektumok referenciáit egymásnak, ezzel biztosítva a kommunikációt közöttük, valamint el is indítja a szimulációt. A Logika osztály képes az égitestek gyorsulásának és vonzásának kiszámítására, az égitestek mozgatására, továbbá a megjelenítésért felelős komponenst megfelelő időközönként értesíti a képernyő frissítésének szükségességéről, ami az alapbeállítás szerint 30 frissítés másodpercenként.

Naprendszer szimuláció – elméleti háttér

2023. március 10.2023. január 8. Szerző: Friedel Attila

Naprendszer szimulációt terveztünk és valósítottunk meg Java nyelven, amit három részből álló blog bejegyzés sorozatban mutatunk be (ez az 1. rész):

Naprendszer szimuláció 1. rész – elméleti háttér
Naprendszer szimuláció 2. rész – objektumorientált tervezés
Naprendszer szimuláció 3. rész – megvalósítás Java nyelven

A Naprendszer szimuláció elméleti háttere

A Naprendszer szimulációhoz elengedhetetlen, hogy ismerjük a homogén koordinátákat, az elemi műveletek egységes megvalósításához szükséges transzformációs mátrixokat, a tömegvonzás elvét és az implementációhoz szükséges MVC modellt.

Homogén koordináták

Számítógépes algoritmusokkal egyszerű a térbeli transzformáció megvalósítása, ha homogén koordinátákat használunk. Segítségükkel az affin transzformációk egységesen kezelhetők. A cél egy egységes matematikai formalizmus alkalmazása. A pontok az égitestek középpontjait fogják jelölni. Legyen a P pont 3D-beli koordinátái: P=(x, y, z). Szükséges egy konstans érték. Ha w≠0, akkor a P pont koordinátái: P=(w·x, w·y, w·z, w). Ha w=1, akkor a P pont normalizált homogén koordinátái: P=(x, y, z, 1). A pontnégyes kijelölése kölcsönösen egyértelmű.

Transzformációk

Koordináta transzformáció során az ábrázolandó grafikus objektum pontjaihoz (tárgypontokhoz) új koordináta-rendszert rendelünk hozzá. Az objektum nem változik (nem torzul, nem változtatja meg az alakját), csupán a nézőpont változik meg. Például: a koordináta-rendszer eltolása, elforgatása, a koordinátatengelyek felcserélése, tükrözése, és a léptékváltás (nagyítás, kicsinyítés, összenyomás, széthúzás), elforgatjuk az ekliptika síkját a szimulált Naprendszerben.

Pont transzformáció esetén a tárgypontokhoz hozzárendeljük azok egy adott szempont szerinti hasonmását. Például: 3D-s tárgyak leképezése 2D-s képre, objektumok eltolása, forgatása, mozgatása, égitestek mozgatása tömegvonzás alapján. Affin transzformációk (egybevágósági és hasonlósági transzformációk) alkalmazása esetén pont képe pont, szakasz képe szakasz, felület képe felület, valamint metsző térelemek eredeti metszésvonala megegyezik azok leképezett metszésvonalával.

A számítógépes grafika területén az affin transzformációk általános alakja (mátrixosan):

A pont a B=(b_x, b_y, b_z) vektorral eltolható. A pont – a T=(t₁₁, t₁₂, …, t₃₃) mátrixot használva – adott szöggel elforgatható, skálázható, tükrözhető. A számítógépes grafikában ezt a transzformációs mátrixot a homogén koordinátákkal alkalmazva, az összes geometriai transzformáció hatékonyan megvalósítható, visszavezethető mátrixok szorzására. Mindezt saját magunk is implementálhatjuk, de része a DirectX és OpenGL rendering pipeline-jának is.

Más módon is lehetne: egyenes és ehhez tartozó szög párossal is dolgozhatnánk.

A tömegvonzás elve

A tömegvonzás bármely két égitest között meghatározott, függ a gravitációs állandótól és az égitestek tömegétől egyenes arányban, az égitestek (tömeg)középpontjainak távolságától fordított arányban. Ez a Newton szerinti értelmezés, amelynek képlete:

A hatás-ellenhatás törvénye miatt a vonzás – egymás felé való gyorsulás – kölcsönös, a gyorsulás az égitestek tömegével fordítottan arányos, sosem nulla. A Naprendszerben a bolygók a Nap körül keringenek, és a bolygóknak lehetnek holdjaik. Egységesen kezelve: égitestek.

A tömegvonzásnak más elméleti megközelítései is vannak: Einstein gödör-modellje, Kepler törvényei, illetve differenciál-egyenletrendszer, integrálszámítás is használható a közelítő képlet helyett (csak ideális modell esetén pontszerű az égitest és gömbszimmetrikus azok tömegeloszlása), illetve ismeretes többféle értelmezés a rendszer/modell stabilitására: Lagrange pontok, Lyapunov stabilitás.

Az MVC modell

A klasszikus megközelítés szerint a szoftveres alkalmazások három, egymástól jól elkülöníthető szereppel rendelkező egységből állnak: modell (model), nézet (view), vezérlő (controller). A Java nyelv Swing komponensei az MVC architektúra szerint működnek.

A vezérlő reagál az érkező eseményre, hozzáfér a modell adatszerkezeteihez, azaz igénybe veszi a modell szolgáltatásait, valamint frissítheti a nézetet. A nézet a vezérlő frissítési kérésére a közvetlenül megkapott adatok alapján, vagy a modelltől elkért adatok alapján frissíti saját magát. A vezérlő határozza meg az alkalmazás, komponens, program működését. Egy modellt több nézet is használhat. A modell közvetlenül is üzenheti a nézetnek, hogy megváltozott. A nézet adja a látványt, amelyet angolul skin vagy „look and feel”-nek neveznek.