Cyfroteka.pl

klikaj i czytaj online

Cyfro
Czytomierz
00335 008370 10461719 na godz. na dobę w sumie
Java. Programowanie, biblioteki open-source i pomysły na nowe projekty - książka
Java. Programowanie, biblioteki open-source i pomysły na nowe projekty - książka
Autor: Liczba stron: 248
Wydawca: Helion Język publikacji: polski
ISBN: 83-246-0624-6 Data wydania:
Lektor:
Kategoria: ebooki >> komputery i informatyka >> programowanie >> java - programowanie
Porównaj ceny (książka, ebook, audiobook).

Odkryj nieznane możliwości Javy

Java, mimo stosunkowo krótkiej obecności na rynku, stała się jednym z najpopularniejszych języków programowania. Codziennie korzystają z niej setki tysięcy programistów z całego świata. Największe korporacje świata za jej pomocą budują systemy informatyczne przetwarzające potężne porcje danych. Aplikacje bazodanowe, serwlety i aplety to najbardziej znane zastosowania Javy, jednak nie jedyne. W sieci dostępna jest ogromna ilość bibliotek tworzonych przez pasjonatów, którzy wykorzystują Javę do odmiennych celów, takich jak przetwarzanie grafiki, modelowanie sieci neuronowych, przeprowadzanie złożonych obliczeń i wielu innych zadań.

Dzięki książce 'Java. Programowanie, biblioteki open-source i pomysły na nowe projekty' poznasz mniej znane zastosowania Javy. Dowiesz się, jak za pomocą bibliotek dostępnych na licencji open-source tworzyć ciekawe projekty i pisać nietypowe aplikacje. Nauczysz się przetwarzać pliki XML i HTML, obrabiać i generować grafikę a także wyświetlać pliki multimedialne. Przeczytasz o sieciach semantycznych i neuronowych, odczytywaniu kanałów RSS i sterowaniu urządzeniami podłączonymi do komputera.

Jeśli lubisz eksperymentować z językami programowania,
ta książka będzie dla Ciebie doskonałym źródłem inspiracji.

Znajdź podobne książki Ostatnio czytane w tej kategorii

Darmowy fragment publikacji:

IDZ DO IDZ DO PRZYK£ADOWY ROZDZIA£ PRZYK£ADOWY ROZDZIA£ SPIS TREœCI SPIS TREœCI KATALOG KSI¥¯EK KATALOG KSI¥¯EK KATALOG ONLINE KATALOG ONLINE ZAMÓW DRUKOWANY KATALOG ZAMÓW DRUKOWANY KATALOG TWÓJ KOSZYK TWÓJ KOSZYK DODAJ DO KOSZYKA DODAJ DO KOSZYKA CENNIK I INFORMACJE CENNIK I INFORMACJE ZAMÓW INFORMACJE ZAMÓW INFORMACJE O NOWOœCIACH O NOWOœCIACH ZAMÓW CENNIK ZAMÓW CENNIK CZYTELNIA CZYTELNIA FRAGMENTY KSI¥¯EK ONLINE FRAGMENTY KSI¥¯EK ONLINE Wydawnictwo Helion ul. Koœciuszki 1c 44-100 Gliwice tel. 032 230 98 63 e-mail: helion@helion.pl Java. Programowanie, biblioteki open-source i pomys³y na nowe projekty Autor: Brian Eubanks T³umaczenie: Grzegorz Borkowski ISBN: 83-246-0624-6 Tytu³ orygina³u: Wicked Cool Java: Code Bits, Open-Source Libraries, and Project Ideas Format: B5, stron: 248 Odkryj nieznane mo¿liwoœci Javy (cid:129) Sieci semantyczne i neuronowe (cid:129) Przetwarzanie grafiki i multimediów (cid:129) Obliczenia naukowe Java, mimo stosunkowo krótkiej obecnoœci na rynku, sta³a siê jednym z najpopularniejszych jêzyków programowania. Codziennie korzystaj¹ z niej setki tysiêcy programistów z ca³ego œwiata. Najwiêksze korporacje œwiata za jej pomoc¹ buduj¹ systemy informatyczne przetwarzaj¹ce potê¿ne porcje danych. Aplikacje bazodanowe, serwlety i aplety to najbardziej znane zastosowania Javy, jednak nie jedyne. W sieci dostêpna jest ogromna iloœæ bibliotek tworzonych przez pasjonatów, którzy wykorzystuj¹ Javê do odmiennych celów, takich jak przetwarzanie grafiki, modelowanie sieci neuronowych, przeprowadzanie z³o¿onych obliczeñ i wielu innych zadañ. Dziêki ksi¹¿ce „Java. Programowanie, biblioteki open-source i pomys³y na nowe projekty” poznasz mniej znane zastosowania Javy. Dowiesz siê, jak za pomoc¹ bibliotek dostêpnych na licencji open-source tworzyæ ciekawe projekty i pisaæ nietypowe aplikacje. Nauczysz siê przetwarzaæ pliki XML i HTML, obrabiaæ i generowaæ grafikê a tak¿e wyœwietlaæ pliki multimedialne. Przeczytasz o sieciach semantycznych i neuronowych, odczytywaniu kana³ów RSS i sterowaniu urz¹dzeniami pod³¹czonymi do komputera. (cid:129) Nieznane funkcje standardowego API Javy (cid:129) Przetwarzanie ³añcuchów tekstowych (cid:129) Analiza plików XML i HTML (cid:129) Stosowanie RDF w projektach (cid:129) Czytanie kana³ów RSS (cid:129) Obliczenia o dowolnej precyzji (cid:129) Realizacja algorytmów genetycznych (cid:129) Symulowanie sieci neuronowych (cid:129) Generowanie plików SVG (cid:129) Wspó³praca z interfejsem MIDI Jeœli lubisz eksperymentowaæ z jêzykami programowania, ta ksi¹¿ka bêdzie dla Ciebie doskona³ym Ÿród³em inspiracji PODZIĘKOWANIA ...................................................................................... 9 WSTĘP ....................................................................................................... 11 1 STANDARDOWE API JAVY ....................................................................... 15 Użycie nowej wersji pętli for .................................................................................................16 Wykorzystanie konstrukcji enum ...........................................................................................18 Mapy bez rzutowania w dół ...................................................................................................21 Pisanie metod z parametrami generycznymi .........................................................................22 Metody ze zmienną liczbą parametrów .................................................................................25 Asercje w Javie .......................................................................................................................27 Użycie System.nanoTime .......................................................................................................29 Uśpienie wątku na czas krótszy od milisekundy ....................................................................30 Klasy anonimowe ...................................................................................................................31 Porównania == != .equals ...................................................................................................33 Podsumowanie .......................................................................................................................35 2 NARZĘDZIA DO PRACY Z ŁAŃCUCHAMI TEKSTOWYMI ....................... 37 Użycie wyrażeń regularnych do wyszukiwania tekstów ........................................................38 Użycie metody String.split .....................................................................................................40 Wyszukiwanie fragmentów w łańcuchach tekstowych ..........................................................41 Użycie grup w wyrażeniach regularnych ................................................................................42 Wykonywanie zamiany tekstów za pomocą wyrażeń regularnych ........................................44 Przetwarzanie z użyciem klasy Scanner .................................................................................47 Analiza skomplikowanej składni przy użyciu klasy Scanner ....................................................49 Generowanie przypadkowego tekstu ....................................................................................51 Drukowanie zawartości tablic w Javie 1.5 ..............................................................................52 Kodowanie i dekodowanie danych binarnych ........................................................................54 Formatowanie tekstów za pomocą MessageFormat ............................................................. 57 Powrót funkcji printf — formatowanie tekstów z klasą Formatter ...................................... 58 Podsumowanie ...................................................................................................................... 59 3 PRZETWARZANIE XML I HTML ................................................................61 Szybkie wprowadzenie do XML ............................................................................................ 62 Użycie WebRowSet do utworzenia dokumentu XML .......................................................... 63 Zapamiętywanie zależności między elementami w SAX ....................................................... 64 Bezpośrednie wywoływanie zdarzeń obiektu ContentHandler ............................................ 69 Filtrowanie zdarzeń interfejsu ContentHandler .................................................................... 71 Czytanie dokumentów XML z wykorzystaniem DOM4J ...................................................... 74 Użycie XPath do łatwego pobierania danych ........................................................................ 76 Niewidoczne tagi, czyli filtrowanie dokumentu przed załadowaniem do DOM4J ................ 80 Generowanie kodu analizatorów za pomocą JavaCC ........................................................... 83 Konwersja innych gramatyk na XML ..................................................................................... 87 Wykorzystanie techniki screen scraping do stron HTML ...................................................... 93 Wyszukiwanie z Lucene ........................................................................................................ 95 Podsumowanie ...................................................................................................................... 97 4 SIEĆ SEMANTYCZNA ................................................................................99 Krótkie wprowadzenie do N3 i Jena ................................................................................... 101 Tworzenie słowników RDF na własne potrzeby ................................................................. 103 Użycie hierarchii RDF w Jena .............................................................................................. 106 Dołączanie Dublin Core do dokumentów HTML ............................................................... 108 Zapytania w Jena RDQL ...................................................................................................... 109 Lojban, RDF i projekt Jorne ................................................................................................. 111 RSS i Informa ....................................................................................................................... 113 Czytanie źródeł RSS ............................................................................................................ 115 Odpytywanie i aktualizacja kanałów RSS ............................................................................. 116 Filtrowanie danych RSS ........................................................................................................ 117 Podsumowanie .................................................................................................................... 119 5 ZASTOSOWANIA W NAUKACH ŚCISŁYCH I MATEMATYCZNO-PRZYRODNICZYCH ................................................121 Tworzenie i zastosowanie funktorów ................................................................................. 122 Użycie funktorów złożonych ............................................................................................... 125 Bity dużego kalibru — BitVector z biblioteki Colt .............................................................. 126 Tworzenie tablic prawdy za pomocą BitMatrix ................................................................... 128 Dwa terafurlongi w dwa tygodnie — wielkości fizyczne z JScience .................................... 130 Krnąbrne ułamki — arytmetyka dowolnej precyzji ............................................................. 133 Funkcje algebraiczne w JScience .......................................................................................... 135 Łączenie tablic prawdy za pomocą portów ......................................................................... 136 Łączenie za pomocą JGraphT .............................................................................................. 139 6 S p i s t r e ś c i Łączenie ogólnych jednostek obliczeniowych ......................................................................141 Budowanie sieci neuronowych z Joone ................................................................................144 Użycie JGAP do algorytmów genetycznych .........................................................................146 Tworzenie inteligentnych agentów przy użyciu Jade ...........................................................149 Język angielski z JWorkNet ..................................................................................................153 Podsumowanie .....................................................................................................................155 6 PRZETWARZANIE GRAFIKI I WIZUALIZACJA DANYCH ....................... 157 Definiowanie graficznego interfejsu aplikacji Javy w XML ...................................................158 Wizualizacja danych w SVG ..................................................................................................160 Wyświetlanie obrazów SVG .................................................................................................163 Konwersja JGraphT do JGraphView .....................................................................................164 Użycie map atrybutów w JGraph .........................................................................................166 Tworzenie wykresów z JFreeChart .....................................................................................167 Tworzenie raportów w Javie ...............................................................................................169 Prosta dwuwymiarowa wizualizacja danych ........................................................................171 Użycie transformacji afinicznych w Java 2D .........................................................................174 Budowanie aplikacji graficznych z funkcją „zoom” na pomocą Piccolo ...............................176 Podsumowanie .....................................................................................................................177 7 MULTIMEDIA I SYNCHRONIZACJA WĄTKÓW ....................................... 179 Tworzenie muzyki z JFugue .................................................................................................180 Użycie JFugue razem z Java Sound MIDI ..............................................................................181 Wysyłanie zdarzeń do urządzeń wyjściowych MIDI ............................................................183 Tworzenie dźwięków w JMusic ...........................................................................................184 Użycie szumu i skomplikowanej syntezy w JMusic ..............................................................186 Niskopoziomowy dostęp do Java Sound ..............................................................................189 Czytanie dźwięku z linii wejściowej .....................................................................................191 Użycie Java Speech do tworzenia mówiących programów ..................................................192 Odśmiecacz i Javolution .......................................................................................................193 Synchronizacja wątków za pomocą CyclicBarrier ................................................................196 Podsumowanie .....................................................................................................................197 8 ROZRYWKA, INTEGRACJA I POMYSŁY NA NOWE PROJEKTY .............. 199 Użycie Javy do sterowania robotem LEGO .........................................................................200 Kontrolowanie myszy z użyciem klasy AWT Robot .............................................................201 Wybór dat z pomocą JCalendar ...........................................................................................202 Użycie klasy HttpClient do obsługi metody POST ..............................................................203 Symulacja systemu Cell Matrix w Javie .................................................................................204 Cell Matrix i algorytmy genetyczne ......................................................................................206 Uruchamianie aplikacji z Ant ................................................................................................207 Skrypty BeanShell .................................................................................................................208 Tworzenie testów JUnit .......................................................................................................210 S p i s t r e ś c i 7 Użycie JXTA w aplikacjach Peer-to-Peer ............................................................................ 211 Pakiet narzędziowy Globus oraz sieci rozproszone ............................................................ 212 Użycie Jabbera w aplikacjach ............................................................................................... 212 Pisanie w języku asemblera JVM .......................................................................................... 213 Połączenie programowania genetycznego z BCEL ............................................................. 214 Kompilowanie innych języków do kodu Javy ....................................................................... 215 Wizualizacja gramatyki języka Lojban .................................................................................. 215 Edytor instrumentów muzycznych ...................................................................................... 216 WordNet Explorer .............................................................................................................. 216 Automatyczny generator RSS .............................................................................................. 217 Sieci neuronowe w robotach ............................................................................................... 217 Narzędzie zarządzania metadanymi (adnotacjami) Javy 5 ................................................... 218 CVS i kontrola kodu źródłowego ........................................................................................ 218 Wykorzystaj SourceForge do swoich projektów ................................................................ 219 Posumowanie ...................................................................................................................... 219 SŁOWNICZEK ...........................................................................................221 SKOROWIDZ ............................................................................................235 8 S p i s t r e ś c i . ZADZIWIAJĄCY JEST FAKT, ŻE W WIELU KRĘGACH NAUKOWYCH FORTRAN WCIĄŻ SPRAWUJE NIEPODZIELNĄ WŁADZĘ (WIEM, WIEM, TEŻ MNIE TO PRZERAŻA). PRZYCZYNĄ TEGO STANU RZECZY NIEKONIECZNIE jest to, że Fortran jest wspaniałym językiem programowania, lecz raczej fakt, że jego standardowe biblioteki dostarczają ogromny zbiór operacji matema- tycznych, z których korzysta wielka rzesza istniejących programów. Java istnieje od ponad dekady, działa na większej liczbie dostępnych platform, ma standardowe API o bogatszych możliwościach i pozwala robić rzeczy niemożliwe w Fortra- nie. Dlaczego więc Java nie jest tak popularna w aplikacjach dla nauk ści- słych? Wynika to być może z faktu, że Java nie posiada dobrych bibliotek matematycznych. Klasa java.lang.Math ma bardzo ograniczone możliwości, ale ponieważ jest to klasa ze standardowej dystrybucji Javy, niektórzy programiści aplikacji naukowych nie trudzą się zbytnio poszukiwaniem dodatkowych bi- bliotek. Może po prostu uważają, że „masz to, co widzisz” (ang. „what you see is what you get”). Ten obraz jednak się zmienia, gdyż powoli na scenę wkraczają nowe biblioteki — istnieje obecnie wiele projektów typu open-source, w których powstają naprawdę wspaniałe rozwiązania. W niniejszym rozdziale przyjrzymy się niektórym matematycznym i naukowym bibliotekom dostępnym dla Javy. Wśród zagadnień, w które się zagłębimy, znajdą się funktory, tablice prawdy, teoria grafów, jednostki fizyczne, sieci neuronowe, algorytmy genetyczne i sztuczna inteligencja. JGA JAVA 5+ Według słownika internetowego Merriam-Webster (dostępnego pod adresem www.m-w.com) funktor jest to „coś, co wykonuje funkcję lub operację”. Z punktu widzenia programisty funktor to funkcja, która może być przekazana jako para- metr i użyta jak każda inna zmienna. Wiele języków, jak na przykład C, posiada wskaźniki na funkcje. Wskaźniki te przechowują adres pamięci, pod którym ulo- kowana jest dana funkcja. W takich językach możesz przekazać funkcję do innej funkcji i zastosować ją dla różnych argumentów — na przykład dla każdego elementu kolekcji. Języki takie jak Scheme, Lisp czy Haskell używają czysto funkcyjnego stylu programowania, bardzo wydajnego w pewnych zastosowaniach (w szczególności w dziedzinie sztucznej inteligencji). Java nie posiada funkcji w stylu Lispa czy C, ale możemy zaimplementować taki sposób działania za po- mocą interfejsów i klas bazowych. Generic Algorithms for Java to jedna z implementacji typu open-source obiek- tów funkcyjnych. Mamy w niej do czynienia z klasami odpowiadającymi funktorom przyjmującym zero, jeden lub dwa argumenty: Generator Funktor bezargumentowy UnaryFunctor Funktor jednoargumentowy BinaryFunctor Funktor dwuargumentowy Funktory te są zaprojektowane dla ścisłej współpracy z Javą 5, gdyż korzy- stają z typów generycznych (ang. generics) (które zostały omówione w rozdziale 1.). Klasa Generator jest w rzeczywistości zdefiniowana jako Generator R . Posiada ona bezargumentową metodę gen, która zwraca obiekt typu R określony w kon- struktorze klasy. Aby utworzyć funktor bezargumentowy, możemy użyć następu- jącego kodu: 122 R o z d z i a ł 5 import net.sf.jga.fn.Generator; public class CubeGenerator extends Generator Double { double current = 0; public Double gen() { current = current + 1; return current * current * current; } } Widać tu wyraźnie sens nazwy Generator: napisana przez nas przykładowa klasa generuje sześciany kolejnych liczb naturalnych. Oprócz możliwości two- rzenia własnych generatorów biblioteka JGA posiada zbiór gotowych generato- rów dla tworzenia wartości różnego typu: losowych, stałych lub wyliczanych. Wartości zwracane przez generatory nie muszą być liczbami. Klasą reprezentującą funktor jednoargumentowy jest klasa UnaryFunctor T, R . Definiuje ona metodę fn, która przyjmuje parametr typu T i zwraca wartość typu R. Możemy na przykład utworzyć predykat, pisząc funktor zwracający war- tość typu Boolean. Stwórzmy klasę typu UnaryFunctor Number, Boolean , która zwraca wartość true dla liczb parzystych: public class EvenNumber extends UnaryFunctor Number, Boolean { public Boolean fn(Number x) { return (x.longValue() 2) == 0; } } Na razie wygląda to tak, jakbyśmy dokładali sobie pracy bez wyraźnych korzy- ści. Jednakże zaletą takiego rozwiązania jest możliwość tworzenia nowych metod, które jako parametr przyjmą dowolne funktory. Kolejny listing pokazuje, jak to wygląda w praktyce: public void removeMatches(List Number aList, UnaryFunctor Number,Boolean functor) { for (Number num : aList) { if (functor.fn(num)) aList.remove(num); } } Metoda ta usuwa wszystkie elementy z listy, dla których funktor typu Number - Boolean zwraca true (a dokładnie Boolean.TRUE; w Javie 5 typy te są rów- noważne). Prześledźmy teraz dwa sposoby napisania kodu usuwającego liczby parzyste z listy: Z a s t o s o w a n i a w n a u k a c h ś c i s ł y c h i m a t e m a t y c z n o - p r z y r o d n i c z y c h 123 List Number numbers = ... // wypełniamy listę jakimiś liczbami // pierwszy sposób for (Number aNumber : numbers) { if (aNumber.longValue() 2 == 0) numbers.remove(aNumber); } // drugi sposób removeMatches(numbers, new EvenNumber()); Metoda taka jak removeMatches może być bardzo użyteczną częścią biblio- teki. Pozwala nam ona zastosować kolejno kilka funktorów typu UnaryFunctor Number,Boolean na danej liście: removeMatches(numbers, lessThan30000); removeMatches(numbers, greaterThan10000000); Możemy osiągnąć ten sam efekt, używając klasy Iterables, która dobrze na- daje się do wykorzystania w pętlach „for each” wprowadzonych w Javie 5. Na stronach JGA znajdziesz bardziej szczegółowe przykłady filtrowanych iteracji. Oto krótki przykład pętli, która jest wykonywana wyłącznie na parzystych ele- mentach danej listy: UnaryFunctor Number,Boolean even = new EvenNumber(); List Number numbers = ...; // dowolne wypełnienie listy for (Number aNumber : Iterables.filter(numbers, even)) { System.out.println(aNumber); } Klasa Algorithms obejmuje implementacje niektórych popularnych algorytmów, które wykorzystują funktory. Następny przykład używa dwóch z tych algorytmów: forEach stosuje funktor unarny dla każdego elementu z listy, a removeAll usuwa wszystkie elementy pasujące do predykatu: import net.sf.jga.util.Algorithms; List String aList = ...; //wypełniamy listę // usuwamy wszystkie wartości równe null UnaryFunctor Object,Boolean isNull = new UnaryFunctor Object,Boolean () { public Boolean fn(Object o) {return o == null;} }; Algorithms.removeAll(aList, isNull); // przycinamy łańcuchy tekstowe UnaryFunctor String,String trimmer = new UnaryFunctor String,String () { public String fn(String s) {return s.trim();} }; Algorithms.forEach(aList, trimmer); 124 R o z d z i a ł 5 Jeżeli nie chcesz modyfikować oryginalnej listy, możesz utworzyć iterator przeglądający oryginalne wartości i zwracający zmodyfikowaną wartość każdego elementu lub ignorujący wartości null. Programowanie funkcjonalne jest bar- dzo użytecznym narzędziem programisty Javy. W następnej części użyjemy nieco bardziej zaawansowanych cech omawianego API. JGA JAVA 5+ W poprzedniej części użyliśmy funktorów do filtrowania danych wejściowych dla pętli for, eliminując tym samym potrzebę filtrowania danych w samej pętli. JGA posiada funkcje pomocnicze służące tworzeniu złożonych funktorów i są one wbudowane automatycznie w każdy unarny i binarny funktor. Klasa Unary- Functor posiada metodę compose, która zwraca nowy funktor będący złożeniem z wewnętrznym funktorem. Kiedy widzisz metodę compose, traktuj ją jak funkcję złożoną: f.compose(g) oznacza „funkcję f funkcji g”. Innymi słowy, możesz utwo- rzyć funktor h z dwóch funktorów f i g, tak że h=f(g(x)), za pomocą następują- cego kodu: UnaryFunctor f,g; UnaryFunctor h = f.compose(g); Kiedy wywołamy metodę fn funktora h, zostanie faktycznie użyte złożenie dwóch funktorów. Klasa BinaryFunctor ma podobną metodę compose dla składania jej z innymi funktorami unarnymi i binarnymi. Możemy utworzyć w ten sposób łańcuch elementów o dowolnej długości. Możemy również przesłać wyjście z generatora do funkcji złożonej, używając pomocniczej klasy Generate. Spróbuj- my użyć tej metody do stworzenia złożonego generatora wytwarzającego szereg logarytmów kwadratów każdej co trzydziestej liczby naturalnej, zaczynając od 99. Zacznijmy od napisania generatora zwracającego naturalne liczby ze skokiem równym 30, a potem będziemy dodawać dalszą część bazując już na nim: Generator Number every30thFrom99 = new Generator Number () { long count = 99; public Number gen() { long result = count; count += 30; return result; } }; UnaryFunctor Number,Number log = new UnaryFunctor Number,Number () { public Number fn(Number in) { double val = in.doubleValue(); return Math.log(val); } }; Z a s t o s o w a n i a w n a u k a c h ś c i s ł y c h i m a t e m a t y c z n o - p r z y r o d n i c z y c h 125 UnaryFunctor Number,Number square = new UnaryFunctor Number,Number () { public Number fn(Number in) { double val = in.doubleValue(); return val*val; } }; Generate Number,Number logOfSquareOfEvery30thFrom99 = new Generate(log.compose(square), every30thFrom99); Zagnieżdżanie funkcji nie jest ograniczone do liczb. Funkcje złożone mogą działać na obiektach dowolnego typu (na przykład String, Employee, Automobile, WebRowSet). Widzimy teraz, dlaczego tworzenie funktorów na możliwie niskim poziomie jest ważne — możemy potem je łączyć i wykorzystywać w innym kontekście. Zanim napiszesz nowy funktor, sprawdź, czy nie dasz rady osiągnąć tego samego efektu, łącząc kilka istniejących. W chwili pisania tej książki oma- wiane API było wciąż w fazie „beta”, więc pewne rzeczy mogą ulec jeszcze zmia- nie — dla pewności sprawdź więc dokumentację dostępną w internecie. COLT JGA Co mają wspólnego ze sobą matematyka, pistolety, konie i alkohol? Otóż okazuje się, że oprócz producenta broni, gatunku alkoholu i nazwy młodego konia „colt” jest również nazwą API matematyczno-fizycznego. API to zostało stworzone w tym samym miejscu, gdzie narodziła się Sieć — w CERN, laboratorium cząstek elementarnych w Szwajcarii. Strona CERN-u opisuje Colt jako „wydajne i użyteczne struktury danych oraz algorytmy dla przetwarzania danych, algebry liniowej, tablic wielowymiarowych, statystyk, histogramów, symulacji Monte Carlo, programowania równoległego i współbieżnego zarówno online, jak i offline”. W tej części rozdziału przyjrzymy się jednej z pomocniczych klas z biblioteki Colt, BitVector. Będziemy modelować funkcję logiki cyfrowej, tworząc funktor (jak to omawialiśmy wcześniej), który działa na wartościach typu BitVector. Jest to trochę inna sytuacja od tej, z którą mieliśmy do czynienia poprzednio, gdy używaliśmy predykatów logicznych. Obecnie będziemy starali się modelować funkcję mającą wiele bitów zarówno na wejściu, jak i na wyjściu. Nasza funkcja ma przyjmować uporządkowany zbiór bitów i wytwarzać inny uporządkowany zbiór bitów. Standardowa dystrybucja Javy dostarcza klasę BitSet w celu pracy ze zbiorem bitów. Choć ta klasa może być użyteczna w wielu aplikacjach, ma wiele wad, gdy zostanie użyta do modelowania funkcji logicznych. Po pierwsze, nie zapewnia ona stałego rozmiaru zbioru. Przykładowo, jeśli nasza funkcja mia- łaby przyjmować pięć bitów na wejściu i zwracać trzy na wyjściu, potrzeba by było przechowywać gdzieś w osobnych zmiennych rozmiary wektorów wejścia- 126 R o z d z i a ł 5 -wyjścia. Po drugie, BitSet nie posiada metody do przeliczania podzbioru bi- tów na reprezentację w postaci liczby całkowitej. Klasa BitVector z biblioteki Colt jest bardziej wydajna i lepiej przystosowana do modelowania funkcji tego typu. Zacznijmy od prostego przykładu demonstrującego niektóre z możliwo- ści tej klasy: BitVector vec1000 = new BitVector(1000); // rozmiar = 1000 bitów // początkowo wszystkie bity są ustawiane na false (0) vec1000.set(378); // ustaw bit 378 na true (1) System.out.println(vec1000.get(378)); // drukuje true na standardowym wyjściu vec1000.replaceFromToWith(1, 40, true); // ustawia bity od 1 do 40 na true // zwróć bity z pozycji od 38 do 50 (włącznie) BitVector portion = vec1000.partFromTo(38, 50); //zwróć wartość typu long ciągu bitów 3-10 long longValue = portion.getLongFromTo(3,10); Możemy użyć tych metod do symulacji bramek logicznych układów mikro- elektronicznych stanowiących podstawowe cegiełki tworzące komputer. Przy- kładem takich niskopoziomowych bramek są bramki AND, OR i NOT. Do ogólnej reprezentacji bramki logicznej możemy wykorzystać instancję klasy BitVector jako wejście i wyjście funktora. Chociaż Colt posiada własne funktory ogólnego zastosowania, użyjemy tutaj API omówionego wcześniej, aby uniknąć nieporo- zumień. Funktor dla bramki AND mógłby wyglądać tak: public class UnaryBitVectorAndFunction extends UnaryFunctor BitVector,BitVector { public BitVector fn(BitVector in) { int oneBits = in.cardinality(); // ile bitów jest ustawionych na 1 int size = in.size(); // rozmiar wektora BitVector outVec = new BitVector(1); // jednobitowe wyjście outVec.put(0, size == oneBits); // AND = same jedynki return outVec; } } W podobny sposób jesteśmy w stanie utworzyć funkcję logiczną dowolnego typu. Zobaczmy jeszcze jeden przykład, tym razem z większą liczbą bitów na wyjściu. Dekoder 1-do-4 (demultiplekser) jest blokiem logicznym z trzema wej- ściami i czterema wyjściami. Demultiplekser przesyła sygnał z wejścia (D) na jedno z czterech wyjść (Q0, Q1, Q2, Q3). O tym, które jest to wyjście, decydują dwa bity sterujące (S0, S1). Tabela 5.1 pokazuje stan każdego z wyjść dla każdej z możliwych kombinacji stanów wejść. Taką tabelę nazywa się tablicą prawdy. Z a s t o s o w a n i a w n a u k a c h ś c i s ł y c h i m a t e m a t y c z n o - p r z y r o d n i c z y c h 127 Tabela 5.1. Tablica prawdy dla demultipleksera dwuwejściowego D 0 0 0 0 1 1 1 1 S1 S0 Q0 Q1 Q2 Q3 0 0 1 1 0 0 1 1 0 1 0 1 0 1 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 Pierwsze trzy kolumny przedstawiają stany na wejściu, pozostałe — na wyj- ściu. Selektory S0 i S1 decydują, które wyjście przedstawia stan wejścia, a pozo- stałe wyjścia są wyzerowane. Stwórzmy teraz model tego układu. Każdemu sygnałowi trzeba przypisać indeks w obiekcie BitVector. W przypadku wejść przyjmijmy, że indeks 0 odpowiada wejściu D, 1 — S0 i 2 — S1. Poniższy obiekt UnaryFunctor tworzy czterobitowy wektor zawierający wartości sygnałów wyjściowych: public class QuadDemuxer extends UnaryFunctor BitVector,BitVector { public BitVector fn(BitVector in) { // czterobitowy wektor wyjścia, domyślnie wyzerowany BitVector outVec = new BitVector(4); // pobierz wartość wejścia D boolean data = in.get(0); if (data) { // bity sterujące zwrócone jako zmienna int int selector = (int) in.getLongFromTo(1,2); outVec.set(selector); } return outVec; } } W następnym podrozdziale rozszerzymy tę procedurę i utworzymy prostą implementację tablicy prawdy dla funkcji logicznej. COLT W poprzednim podrozdziale utworzyliśmy demultiplekser, specyficzny rodzaj funkcji logicznej posiadającej wiele bitów wejściowych i wyjściowych. Aby wy- jaśnić jej działanie, użyliśmy tablicy prawdy przedstawiającej wyjścia odpowia- dające wszystkim kombinacjom wejść. Tablica prawdy działa tak jak słownik typu 128 R o z d z i a ł 5 klucz-wartość dla kluczy binarnych. Pewnie zauważyłeś również, że nasza tablica prawdy wygląda jak macierz bitów. Możemy wykorzystać tę obserwację dla napi- sania uniwersalnego modelu tablicy prawdy. W podrozdziale utworzymy ta- blicę prawdy, używając klasy BitMatrix, dwuwymiarowego kuzyna znanej nam BitVector, również z biblioteki Colt. Wejściowe kombinacje bitów w tabeli są wymienione w kolejności rosnącej: 000, 001, 010, 011… Ponieważ kolejność bitów wejściowych w tablicach prawdy jest zawsze taka sama, ta część tablicy jest zbędna — możemy zająć się wyłącznie wyjściami. Liczba rzędów i kolumn bezpośrednio wynika z liczby wejść i wyjść. W ostatnim przykładzie, mając 3 wejścia i 4 wyjścia, otrzymaliśmy 4 kolumny i 8 rzędów. Liczba kolumn jest równa liczbie wyjść. Liczba rzędów jest równa 2n, gdzie n oznacza liczbę wejść, ponieważ musimy uwzględnić wszystkie możliwe kombinacje bitów na wejściu. Oczywiście pojedyncza tablica prawdy nie jest do- brym pomysłem dla bardzo dużej liczby wejść. Jednakże złożone systemy mogą być stworzone przez wzajemne powiązanie wielu prostszych komponentów, więc nie jest to poważny problem. Jeśli tylko pamiętasz kolejność bitów wejściowych, możesz przekonwertować je na liczby całkowite i użyć jako indeksów dla rzędów zawierających bity wyjścio- we. Zademonstrujmy to na przykładzie, tworząc macierz bitów typu BitMatrix dla tablicy prawdy z tabeli 5.1: int inputSize = 3; int rows = 1 inputSize; // 2**n rzędów, dla n bitów na wejściu int outputSize = 4; int columns = outputSize; // tablica prawdy z wszystkimi bitami ustawionymi na 0 BitMatrix matrix = new BitMatrix(columns, rows); // ustaw mapowanie wyjść dla przykładu z demultiplekserem matrix.put(0, 4, true); // kolumna 0, rząd 4 = true (1) matrix.put(1, 5, true); matrix.put(2, 6, true); matrix.put(3, 7, true); // podaj bity na wyjściu dla wartości wejściowej 101 (5) boolean Q0 = matrix.get(0, 5); // kolumna 0, rząd 5 boolean Q1 = matrix.get(1, 5); // kolumna 1, rząd 5 boolean Q2 = matrix.get(2, 5); // kolumna 2, rząd 5 boolean Q3 = matrix.get(3, 5); // kolumna 3, rząd 5 Aby z tablicy prawdy wydobyć parę wartości wejścia-wyjścia, trzeba dokonać konwersji bitów wejściowych na liczbę całkowitą i użyć jej jako indeks rzędu za- wierającego bity wyjściowe. Można czytać każdy bit z osobna jako wartość logiczną lub przekonwertować na typ int lub long, aby użyć wszystkich bitów naraz. Nasza tablica prawdy była łatwa do utworzenia, ponieważ zawiera niewiele jedynek, prawdopodobnie wolałbyś jednak użyć jakiejś ogólnej metody pomocniczej, która ustawia mapowanie wejść na wyjścia w pojedynczym wywołaniu. Następujące dwie metody implementują ogólny sposób modyfikacji i dostępu do tablicy prawdy: Z a s t o s o w a n i a w n a u k a c h ś c i s ł y c h i m a t e m a t y c z n o - p r z y r o d n i c z y c h 129 public void store(int inputVal, long out) { int start = inputVal * outSize; int end = start + outSize - 1; // włącznie matrix.toBitVector().putLongFromTo(out, start, end); } public long retrieve(int inputVal) { int start = inputVal * outSize; int end = start + outSize - 1; // włącznie long out = matrix.toBitVector().getLongFromTo(start, end); return out; } Moglibyśmy również napisać wersje tych metod dla BitVector, używając kodu z poprzedniej części. Powyższe funkcje wykorzystują dostęp do wewnętrznych danych (BitVector) klasy BitMatrix. (Napisałem to w ten sposób, ponieważ Bit- Matrix nie posiada wygodnej metody dostępu do całych rzędów). Pamiętaj, że liczba bitów wejściowych powinna być utrzymana na niskim poziomie, ponieważ rozmiar tablicy prawdy rośnie wykładniczo. Nie ma tu sprawdzania wartości wej- ściowych i niewłaściwe dane spowodują wygenerowanie wyjątku. Bity wyjściowe, które nie są używane, są ignorowane — wynika to ze sposobu, w jaki BitVector konwertuje bity na wartości long. Pamiętaj też, że wartości wyjściowe i wejściowe są przetwarzane przy założeniu, że najmniej znaczący bit jest bitem zerowym. Wrócimy jeszcze do tablic prawdy, gdy utworzymy połączoną sieć bloków logicz- nych posiadających swoje własne tablice prawdy. JScience JScience jest kolejnym API typu open-source przeznaczonym do zastosowań w naukach ścisłych i matematyczno-przyrodniczych. Jednym z celów JScience, bardzo wzniosłym, jest utworzenie wspólnego API Javy dla wszystkich tych nauk. Do najciekawszych jego cech należy model jednostek fizycznych (na przykład masy, prędkości, temperatury, odległości). Za pomocą JScience możesz korzy- stać ze stałych fizycznych takich jak prędkość światła czy stała Plancka, nie przej- mując się, jakie jednostki są użyte w nich wewnętrznie. Konwersja między róż- nymi systemami jest wyjątkowo łatwa, możesz również definiować swoje własne stałe. W tej części pokażemy, jak korzystać z wbudowanych stałych, tworzyć własne jednostki i używać klas opisujących wielkości. W Stanach Zjednoczonych, poza kręgami naukowymi, większość ludzi używa jednostek spoza układu metrycznego: stopni Fahrenheita, stóp, funtów. To często powoduje różne niejasności, a nawet stało się przyczyną katastrofy jednego bez- załogowego statku kosmicznego! Być może nie potrafimy rozwiązać definityw- nie tego problemu, ale na szczęście programując w Javie, możemy definiować 130 R o z d z i a ł 5 wielkości, nie przejmując się jednostkami, jakie za nimi stoją. W JScience pod- stawowe wielkości fizyczne mają własne klasy dziedziczące po wspólnej klasie bazowej Quantity (Ilość). Oto przykłady kilku z nich, razem z ich jednostkami w układzie SI: ■ długość (w metrach), ■ ■ ■ czas (w sekundach), masa (w kilogramach), temperatura (w kelwinach). Klasy typu Quantity znajdują się w pakiecie javax.quantities. Klasy te zawie- rają informacje o wielkościach, które mierzymy, i są dużo bardziej precyzyjne (czyli zapewniają mniejsze prawdopodobieństwo błędów) niż zwykłe wartości typu double do reprezentacji wartości numerycznych. W dowolnej aplikacji mie- rzącej zwykłe wielkości, takie jak długość, możesz użyć jednej ze standardowych klas JScience typu Quantity. Każda z tych klas przechowuje powiązaną z nią jednostkę wielkości i dzięki temu może dokonywać automatycznych konwersji. Jeśli piszesz aplikację zajmującą się komputerami, możesz napisać taką klasę do reprezentacji możliwych konfiguracji: public class ComputerConfig { double length, width, height; double mass; int ram, rom, network; } W tej klasie jednostki fizyczne nie są przyporządkowane do zmiennych, brak też wewnętrznej kontroli typów wielkości fizycznych. Na przykład nic nie stoi na przeszkodzie, aby napisać tak: length = mass; W fizyce włożono ogromny wysiłek w stworzenie teorii unifikacji, ale mimo to nie przypuszczam, żeby posunięto się aż tak daleko! Możemy zmienić klasę ComputerConfig tak, aby używała ona rzeczywistych wielkości fizycznych: import javax.quantities.*; public class ComputerConfig { Length length, width, height; Mass mass; DataAmount ram, rom; DataRate network; } Z a s t o s o w a n i a w n a u k a c h ś c i s ł y c h i m a t e m a t y c z n o - p r z y r o d n i c z y c h 131 Teraz nasz program wie, że mamy tu trzy wielkości określające długość, jedną opisującą masę, dwie określające pojemność pamięci i jedną — prędkość przesyłu danych. Ma to jeszcze inną zaletę: możemy podawać i otrzymywać wartości wy- rażone w dowolnych jednostkach, wciąż mając je przechowane w jednostkach układu SI. Zobaczmy, jak to wygląda w praktyce — przypiszmy zmiennej wagę w funtach i pobierzmy ją wyrażoną w kilogramach: Measure Mass mass = Measure.valueOf(20, NonSI.POUND); System.out.println(mass.to(SI.KILOGRAM)); Jak się pewnie domyślasz, próba użycia jednostki niezgodnej z typem zmien- nej spowoduje zgłoszenie wyjątku. Większość jednostek układu metrycznego znajdziesz w klasie SI, a pozostałe w klasie NonSI. Jeśli potrzebujesz jednostek, które nie zostały dodane jeszcze do JScience, możesz zawsze stworzyć własne, bazując na tych już istniejących. Jedna z bardziej tajemniczych jednostek angielskiego układu miar nazywa się furlong i równa jest jednej ósmej mili — lub inaczej 220 jardom1. Jednostki tej nie znajdziemy w JScience, ale możemy łatwo ją utworzyć. Poniższy kod tworzy taką jednostkę, jak również dodaje dla niej alias, aby mogła być użyta w dowol- nym miejscu w aplikacji: Unit Length furlong = NonSI.MILE.times(0.125); UnitFormat.getStandardInstance().alias(furlong, furlong ); UnitFormat.getStandardInstance().label(furlong, furlong ); Quantity fiveFurlong = Measure.valueOf( 5 furlong ); Tworzenie aliasów dla nowych jednostek pozwala używać ich później w opi- sach wielkości fizycznych. Etykieta (ang. label) jest zaś stosowana przy wyświetla- niu wartości. Wielkości i jednostki mogą być mnożone i dzielone w celu otrzyma- nia jednostek takich wielkości fizycznych jak przyspieszenie (m*s–2). W kolejnym przykładzie wyprowadzimy nową jednostkę i użyjemy jej do wyświetlenia pręd- kości światła (c): Measure Velocity c = Measure.valueOf(299792458, SI.METER_PER_SECOND);2 //słowo fortnight oznacza dwa tygodnie (14 dni) Unit Duration fortnight = NonSI.DAY.times(14); UnitFormat.getStandardInstance().alias(fortnight, fortnight ); UnitFormat.getStandardInstance().label(fortnight, fortnight ); Unit Velocity furlongperfortnight = (Unit Velocity ) furlong.divide(fortnight); System.out.println(c.to(furlongperfortnight)); 1 Około 200 metrów — przyp. tłum. 2 Co prawda w Science istnieje klasa org.jscience.physics.measures.Constants, w której zdefiniowano prędkość światła c, ale klasa ta w obecnej wersji (3.1.6) niestety nie działa poprawnie. 132 R o z d z i a ł 5 Nasza nowa jednostka jest jednostką prędkości, gdyż jest definiowana jako długość przez czas. Po uruchomieniu tego programu zobaczymy, że prędkość światła w próżni wynosi 1 802 617 499 785 253 furlongi na dwa tygodnie, czyli trochę mniej niż 2 terafurlongi na dwa tygodnie. JScience Dwa razy dwa równa się 3,9999999998, jeśli wierzyć wynikom obliczeń prze- prowadzonych na zmiennych typu double. Większość programistów Javy miała okazję używać typów double i float. Być może miałeś do czynienia również z nie- którymi metodami z klasy java.lang.Math. Klasa ta należy to najbardziej rdzen- nych bibliotek Javy i zawiera metody dla operacji na funkcjach, takich jak wy- kładnicze, logarytmiczne, trygonometryczne. Precyzja typu double wystarcza dla większości zastosowań, jednak dla naukowych aplikacji jej 11-bitowa cecha i 52-bitowa mantysa (oparte na typie zmiennoprzecinkowym podwójnej precyzji według IEEE 754) może czasem spowodować drobne błędy i szybko urosnąć do dużych problemów. Jest to szczególnie istotne w obliczeniach iteracyjnych, gdy rezultat poprzedniej iteracji jest daną wejściową kolejnej. Aby rozwiązać problem błędów zaokrąglenia w zastosowaniach matema- tycznych, Java posiada dwie klasy dla operacji o dowolnej precyzji: BigDecimal i BigInteger. BigInteger jest świetna do pracy z wyjątkowo dużymi liczbami. (Ależ tak, zdaję sobie sprawę, że nazwa dokładnie na to wskazuje!) Wielkość tych liczb jest ograniczona jedynie przez dostępną pamięć oraz prędkość procesora. Liczba taka jak 9700 jest zbyt duża, aby przechowywać ją w zmiennej double lub long, lecz nadaje się idealnie do zapamiętania w zmiennej typu BigInteger. Po- dobnie BigDecimal może precyzyjnie przechować liczby takie jak 0,0123456 78987654321234567890123456, z którą nie poradzi sobie liczba o mantysie 52-bitowej. Następujący krótki przykład używa klas BigInteger oraz BigDecimal do reprezentacji tych liczb: BigInteger nine = new BigInteger( 9 ); BigInteger nineToSevenHunredth = nine.pow(700); BigDecimal exactNumber = new BigDecimal( 0. 012345678987654321234567890123456 ); BigDecimal może reprezentować precyzyjnie dowolną liczbę, która ma skoń- czone rozwinięcie dziesiętne. Jest to spełnione dla ułamków, które w mianow- niku posiadają wielokrotności liczb 2 i 5, np. 1/2, 15/4, 127/20, lecz nie jest dla liczb takich jak 1/3 (0,333333…) lub 5/7. Może to powodować kumulację błędów zaokrąglenia w bardziej złożonych obliczeniach. W rzeczywistości wszystkie me- tody klasy BigDecimal związane z dzieleniem wymagają parametru skalującego Z a s t o s o w a n i a w n a u k a c h ś c i s ł y c h i m a t e m a t y c z n o - p r z y r o d n i c z y c h 133 określającego liczbę cyfr dziesiętnych, które powinny być zachowane w wyniku. Rozważmy następujący przykład, w którym wyliczany jest ułamek 1/3 z dokład- nością do 15 miejsc po przecinku (i zaokrąglany w razie potrzeby): BigDecimal one = new BigDecimal( 1 ); BigDecimal three = new BigDecimal( 3 ); BigDecimal third = one.divide(three, 15, BigDecimal.ROUND_HALF_UP); Przy wykonywaniu obliczeń arytmetycznych o dowolnie wysokiej precyzji naj- lepiej jest przechowywać licznik i mianownik w osobnych zmiennych. Ponieważ w podstawowych bibliotekach Javy nie ma obiektów dla ułamków zwykłych o do- wolnej precyzji, być może pomyślałeś o napisaniu własnej klasy. Wielu ludzi stworzyło klasy tego typu: public class HugeFraction { private BigInteger numerator, denominator; // metody dla operacji na ułamkach public HugeFraction divide(HugeFraction other) { // policz rezultat return result; } } W bibliotece JScience istnieje kilka klas służących do przeprowadzania ope- racji o dowolnie wysokiej precyzji. Pierwsza z nich to LargeInteger, podobna do BigInteger ze standardowej dystrybucji Javy. LargeInteger jest zoptymalizowana ze względu na prędkość i wydajność w czasie rzeczywistym i implementuje inter- fejs Ring (struktura algebraiczna) używany w teorii liczb i obliczeniach macierzo- wych. Posiada również związany ze sobą format XML. Klasa Rational3 bazuje na niej w celu umożliwienia reprezentacji ułamków a/b o nieskończonej precyzji, dla a i b będących liczbami całkowitymi różnymi od zera. Klasa Rational jest nie- zmienna — wszystkie jej metody zwracają wynik, zamiast zmieniać oryginalny obiekt. Działa to dokładnie tak, jakbyś mógł się spodziewać: Rational oneThird = Rational.valueOf( 1/3 ); Rational nine87654321 = Rational.valueOf( 987654321/1 ); Rational msixteen = Rational.valueOf( -16/1 ); Rational msixteenOver987654321 = msixteen.divide(nine87654321); Rational aNumber = oneThird.times (msixteenOver987654321); 3 Ang. rational number = liczba wymierna — przyp. tłum. 134 R o z d z i a ł 5 Tak długo, jak pozostaniesz w dziedzinie obiektów Rational, nie pojawią się żadne błędy zaokrąglania (przy dodawaniu, odejmowaniu, mnożeniu, dzieleniu, potęgach o wykładnikach całkowitych). Inną klasą, której na pewno nie chcesz przegapić, jest Real4. Reprezentuje ona liczbę rzeczywistą dowolnie wysokiej precyzji, o zagwarantowanej niepewności. JScience API posiada również klasę Complex5, lecz nie jest ona liczbą dowolnej precyzji, gdyż części rzeczywista i urojona są przechowywane w zmiennych typu double. W następnej części przyj- rzymy się funkcjom algebraicznym i wielomianowym. JScience We wcześniejszych częściach tego rozdziału pokazaliśmy korzyści płynące z moż- liwości manipulowania funkcjami, tak jakby były one obiektami, przez przeka- zywanie ich jako parametrów do metod. W podrozdziale spróbujemy spojrzeć na funkcje z matematycznego punktu widzenia. JScience, Colt, JGA (omawiane wcześniej) — wszystkie z nich zawierają swoje własne implementacje funktorów i każda z nich ma swoje zalety. Wersja z JGA jest bardzo dobra w zastosowaniach ogólnego typu z powodu swojej prostoty i ogólności. Colt zawiera więcej wbu- dowanych funktorów (patrz klasa Functions), lecz nie zapewnia obliczeń o dowol- nie wysokiej precyzji. W niniejszym podrozdziale omawiamy JScience, ponie- waż API to posiada ogólny zrąb dla operacji algebraicznych i wielomianowych możliwy do zastosowania z dowolnymi obiektami implementującymi interfejs Ring (takimi jak Real bądź Rational lub Twoimi własnymi klasami będącymi im- plementacją pierścieni). Obiekt typu Ring posiada metody mnożące i dodające oraz operację odwrot- ną dla każdej z tych metod. Klasa Polynomial (Wielomian) oznacza „wyrażenie matematyczne zawierające sumę potęg jednej lub wielu zmiennych przemnożo- nych przez współczynniki” (cytat z dokumentacji JScience). Możesz utworzyć wielomiany, które współpracują z dowolną klasą typu Ring. Na nasze potrzeby zdefiniujemy wielomian zmiennych rzeczywistych (Rational). Zacznijmy od stałego wielomianu. Klasa org.jscience.mathematics.functions.Constant jest podklasą Polynomial reprezentującą wielomian stopnia zerowego. Stwórzmy jeden egzem- plarz za pomocą metody valueOf: Constant Rational sixty = Constant.valueOf(Rational.valueOf( 60/1 )); Zastosujmy teraz tą metodę do utworzenia wielomianu (7/15) x5 + 9xy + 60. Musimy na początku utworzyć każdy z elementów i przemnożyć przez odpowied- ni współczynnik. Następnie możemy dodać elementy do siebie, aby utworzyć wielomian. Poniższy kod tworzy wielomian, przypisuje wartości x oraz y i na ko- niec wyświetla wynik: 4 Ang. real number = liczba rzeczywista — przyp. tłum. 5 Ang. complex number = liczba zespolona — przyp. tłum. Z a s t o s o w a n i a w n a u k a c h ś c i s ł y c h i m a t e m a t y c z n o - p r z y r o d n i c z y c h 135 Variable.Local Rational x = new Variable.Local Rational ( x ); Variable.Local Rational y = new Variable.Local Rational ( y ); Polynomial Rational xpoly = Polynomial.valueOf(Rational.ONE, x); Polynomial Rational ypoly = Polynomial.valueOf(Rational.ONE, y); Rational nine = Rational.valueOf( 9/1 ); Rational sixty = Rational.valueOf( 60/1 ); Rational seven15ths = Rational.valueOf( 7/15 ); Polynomial seven15X5 = Polynomial.valueOf(seven15ths, Term.valueOf(x, 5)); Polynomial nineXY = (Polynomial) Constant.valueOf(nine).times(xpoly).times(ypoly); Polynomial poly = (Polynomial) seven15X5.plus(nineXY).plus(Constant.valueOf(sixty)); x.set(Rational.valueOf( 5/7 )); y.set(Rational.ONE); System.out.println(poly); System.out.println(poly.evaluate()); Wynikiem działania tego kodu dla x = 5/7, y = 1 jest rezultat: [7/15]x^5 + [9/1]xy + [60/1] 479110/7203 Możesz również różniczkować i całkować wielomiany. JScience ma wiele innych pożytecznych cech. Opis szczegółów znajdziesz w dokumentacji do API. COLT JGA Na początku dwudziestego wieku filozof Ludwig Wittgenstein napisał „Traktat logiczno-filozoficzny”, w którym określił koncepcję funkcji prawdy będącej abstrakcją wyższego stopnia w logice zdaniowej. Jego funkcje prawdy działają tak jak znane nam tablice prawdy, lecz łączą one inne zdania zawierające inne funkcje i dają w wyniku jedynie pojedynczą wartość typu logicznego. W naszej tablicy prawdy z podrozdziału „Tworzenie tablic prawdy za pomocą BitMatrix” mieliśmy pewną liczbę wejść i wyjść, przy czym nie łączyliśmy ich z innymi funkcjami. Jeśli budowałbyś symulator logiczny, musiałbyś zapewne połączyć wiele jego części w jeden spójny system. Aby móc tworzyć i łączyć bloki logiczne ze sobą, musimy napisać kod do tego służący. Możemy połączyć dowolne komponenty na rysunku w jeden schemat, łącząc je liniami, tak jak łączy się elementy elektroniczne na schematach. Nie chodzi tu jednak tylko o połączenie elementów bezpośrednio ze sobą, lecz o dokładne przyporządkowanie wyjść z jednego komponentu do wejść innych komponentów. Innymi słowy, na rysunku 5.1 nie łączymy ze sobą elementów, lecz ich porty. 136 R o z d z i a ł 5 Rysunek 5.1. Standardowy element funkcyjny Możesz wyobrazić sobie porty jako nóżki chipów elektronicznych. Łączenie por- tów pozwala na dokładne określenie, które wyjście jest połączone z którym wej- ściem. Spróbujmy użyć tego podejścia do utworzenia klasy Component, której będzie można użyć w większym systemie. Nasza klasa Component jest uogólnieniem „funkcji z portami”, która to może być zaaplikowana do dowolnej funkcji posiadającej zbiór wejść i wyjść. Użyjemy tego podejścia do napisania rozszerzenia dla metod store i retrieve z tabeli prawdy utworzonej przez nas wcześniej. Dodamy porty wejścia-wyjścia i kilka metod dostępu do klasy. Ponieważ port wejściowy może być podłączony jedynie do portu wyjściowego, utwórzmy na początek osobny interfejs dla każdego typu (oraz klasę implementującą obydwa z nich): public interface Port { public Component getParent(); } public interface InputPort extends Port { public void setValue(Object value); } public interface OutputPort extends Port { public Object getValue(); } public class PortImpl implements InputPort, OutputPort { private Component parent; private Object value; public PortImpl(Component parent) { this.parent = parent; } public Component getParent() { return parent; } public Object getValue() { return value; } public void setValue(Object value) { this.value = value; } } Z a s t o s o w a n i a w n a u k a c h ś c i s ł y c h i m a t e m a t y c z n o - p r z y r o d n i c z y c h 137 InputPort oraz OutputPort to interfejsy używane zewnętrznie w stosunku do komponentu. Wysyłanie danych do portu wejściowego wymaga wywołania meto- dy ustawiającej zmienną value, a czytanie z portu wyjściowego oznacza wywo- łanie metody odczytującej wartość zmiennej value. Komponent określa rozmiar wejścia i wyjścia oraz definiuje metodę Object[]- Object[], która oblicza wartość wyjścia dla zadanych wartości na wejściu. Komponent jest zaimplementowany jako interfejs w celu zwiększenia zakresu możliwych zastosowań: public interface Component { // zwraca ilość portów wejściowych public int getInputSize(); // zwraca ilość portów wyjściowych public int getOutputSize(); // zwraca port wejściowy o danym numerze identyfikacyjnym public InputPort getInputPort(int index); // zwraca port wejściowy o danym numerze identyfikacyjnym public OutputPort getOutputPort(int index); // zasadnicza metoda komponentu wykonująca funkcję outputs = f(intputs) public void process(); } W tej chwili mamy już ogólny szkielet dla łączenia komponentów posiadają- cych porty wejścia-wyjścia. Założyłem tutaj, że komponent posiada jedną funkcję wykonującą całą pracę, pobierającą Object[] jako parametr i zwracającą rów- nież Object[]. Jeśli chcesz, możesz uczynić tę funkcję na tyle elastyczną, że bę- dzie ona potrafiła zwracać pojedynczy obiekt na pierwszy port wyjściowy i null na pozostałe. Na stronie internetowej książki znajdziesz implementację klasy Component wzbogaconą o możliwość użycia typów generycznych Javy 5 (ang. gene- rics). Zewnętrzny proces kontroluje komponenty i zarządza połączeniami między nimi — zaimplementujemy go później, korzystając z API grafów. Jednakże wcześniej musimy zmienić nasz obiekt w jednostkę przetwarzającą bity korzy- stającą z tablicy prawdy. Możemy napisać jednoargumentowy funktor (podtyp UnaryFunctor), który przetwarza tablicę obiektów na bity, stosując pewne proste reguły konwersji. Funkcja powinna być na tyle elastyczna, żeby interpretować każdy obiekt w tabli- cy jako bit w ten sam sposób (Boolean, niezero, nie-null). Załóżmy, że metoda arrayToBits konwertuje tablicę na bity. Przekonwertowane bity są interpreto- wane zgodnie z tablicą prawdy i dają bity wyjściowe. Te z kolei są zwracane jako tablica Boolean[], tak aby komponent mógł przesłać rezultat na swoje porty wyj- ściowe. Załóżmy, że metoda bitsToArray potrafi tego dokonać. Poniższy przykład jest uproszczoną wersją faktycznej funkcji, która mogłaby być użyta z naszą klasą Component: 138 R o z d z i a ł 5 public class UnaryTruthTableFunction extends UnaryFunctor Boolean[],Boolean[] { public Boolean[] fn(Boolean[] in) { // zmień obiekty na bity (w jakiś sposób) int convertedInput = arrayToBits(in); // znajdź wyjście w tabeli prawdy // (opis w podrozdziale Tworzenie tablic prawdy za pomocą BitMatrix ) long result = retrieve(convertedInput); //zmień wyjściowe bity na Boolean[] (w jakiś sposób) return bitsToArray(result); } } Dokładniejsze rozwiązanie jest dostępne na stronie internetowej książki. W bieżącej implementacji rezultaty muszą być obliczane w sposób „do przodu” (tzn. tylko w kierunku od wejść do wyjść). Jeśli komponenty są powiązane ze sobą cyklicznie, potrzebny będzie jakiś rodzaj synchronizacji. W kolejnym podrozdziale wprowadzimy API grafów i użyjemy go do połączenia portów między komponen- tami oraz uruchomienia symulacji. JGraphT JAVA 5+ W rozdziale 4. odkrywaliśmy „Sieć semantyczną”. Standard RDF, który omawiali- śmy, modeluje te sieci jako etykietowane grafy skierowane. Grafy oznaczają tu sieć węzłów lub wierzchołków. W teorii grafów etykietowany graf skierowany oznacza, że każda krawędź między dwoma wierzchołkami posiada opis i kierunek. Grafy Jena i RDF użyte przez nas wcześniej są implementacją grafów oznaczo- nych do specyficznych zastosowań, inne aplikacje mogą jednak potrzebować innych typów grafów do modelowania oraz wykonywania operacji na nich. W tym celu możesz wykorzystać JGraphT, łatwą w użyciu bibliotekę do pracy z grafami różnego rodzaju. Koncentruje się ona na samym modelu grafu, jego połączeń oraz wykonywaniu operacji na nim — a nie na wizualizacji i wyświetlaniu go. W rozdziale 6. omówimy inne API, którego głównym celem jest wizualizacja grafów. Póki co jednak będziemy budować po prostu modele grafów. Węzły w JGraphT mogą być dowolnymi obiektami Javy. Model grafu opisuje, w jaki sposób obiekty połączone są ze sobą. Używając tego modelu, możesz zaj- mować się połączeniami między obiektami, niezależnie od samych obiektów. Jest to bardzo podobne do założeń modelu Model-View-Controller (MVC, model- -widok-kontroler) użytego w Swingu oraz frameworkach sieciowych. Teoria gra- fów jest użyteczna w symulacji i analizie wielu skomplikowanych systemów, takich jak sieci komputerowe, obwody cyfrowe, ruch na autostradzie czy przesył danych. Tworzenie grafu w JGraphT jest proste. Na początku tworzysz instancję wy- maganego typu grafu. Następnie wywołujesz metodę addVertex, aby dodać nowy obiekt Javy jako wierzchołek. Kiedy obiekt jest już częścią grafu, możesz wywołać Z a s t o s o w a n i a w n a u k a c h ś c i s ł y c h i m a t e m a t y c z n o - p r z y r o d n i c z y c h 139 metody służące połączeniu go z innymi wierzchołkami. Poniżej mamy przykład modelu połączeń niektórych organów i systemów w ciele ludzkim. Rysunek 5.2 pokazuje zależności miedzy elementami grafu. Rysunek 5.2. Organy i systemy w ciele ludzkim Użyjemy konstrukcji enum z Javy 5 (zobacz rozdział 1.) do reprezentacji orga- nów i układów zawartych w grafie. Aby przechowywać zależności między tymi częściami, możemy stworzyć graf nieskierowany: import org.jgrapht.graph.DefaultEdge; import org.jgrapht.graph.SimpleGraph; enum Organs {HEART, LUNG, LIVER, STOMACH, BRAIN, SPINAL_CORD}; enum Systems {CIRCULATORY, DIGESTIVE, NERVOUS, RESPIRATORY}; SimpleGraph Enum, DefaultEdge graph = new SimpleGraph Enum, DefaultEdge (DefaultEdge.class); graph.addVertex(Organs.HEART); // serce graph.addVertex(Organs.LUNG); // płuco graph.addVertex(Organs.BRAIN); // mózg graph.addVertex(Organs.STOMACH); // żołądek graph.addVertex(Organs.LIVER); // wątroba graph.addVertex(Organs.SPINAL_CORD); // rdzeń kręgowy graph.addVertex(Systems.CIRCULATORY); // układ krążenia graph.addVertex(Systems.NERVOUS); // układ nerwowy graph.addVertex(Systems.DIGESTIVE); // układ pokarmowy graph.addVertex(Systems.RESPIRATORY); // układ oddechowy 140 R o z d z i a ł 5 graph.addEdge(Organs.HEART, Systems.CIRCULATORY); graph.addEdge(Organs.LUNG, Systems.RESPIRATORY); graph.addEdge(Organs.BRAIN, Systems.NERVOUS); graph.addEdge(Organs.SPINAL_CORD, Systems.NERVOUS); graph.addEdge(Organs.STOMACH, Systems.DIGESTIVE); graph.addEdge(Organs.LIVER, Systems.DIGESTIVE); Zwróć uwagę, że każdy z wierzchołków musi być dodany do grafu, zanim dołączysz go do krawędzi, w przeciwnym razie otrzymasz wyjątek. Ten kod nie wyświetla niczego, tworzy jedynie wewnętrzną sieć połączeń. Dokładniej tworzy on listę sąsiadów dla każdego obiektu. W tym szczególnym przypadku wszystkie krawędzie są traktowane jednakowo. Aby krawędzie stały się rozróżnialne, możesz użyć krawędzi etykietowanych. Wywołując odpowiednie metody na grafie, możesz znaleźć sąsiadów danych obiektów. Znajdźmy więc krawędzie dla jakiegoś wierzchołka z naszego przy- kładu i wyświetlmy, co jest po drugiej stronie danej krawędzi. Węzły połączone bezpośrednio z węzłem DIGESTIVE możemy znaleźć za pomocą metody: import org.jgrapht.Graphs; import org.jgrapht.graph.DefaultEdge; Set DefaultEdge digestiveLinks = graph.edgesOf(Systems.DIGESTIVE); for (DefaultEdge anEdge : digestiveLinks) { Enum opposite = Graphs.getOppositeVertex(graph, anEdge, Systems.DIGESTIVE); System.out.println(opposite); } Technika, której tutaj użyliśmy, polega na uzyskaniu listy krawędzi, następnie dla każdej z nich trzeba znaleźć wierzchołek, który nie jest węzłem DIGESTIVE (czyli znaleźć przeciwny wierzchołek). DefaultEdge (krawędź) to bazowa klasa, po której dziedziczą wszystkie krawędzie i która łączy wierzchołek źródłowy z docelowym. Możesz użyć jednej ze standardowych implementacji dostępnych wraz z biblioteką JGraphT lub napisać własną podklasę, aby spełniała specyficzne zadania. JGraphT posiada implementacje innych operacji, które można wykonywać na grafach. Więcej informacji znajdziesz w dokumentacji do API. Będziemy korzy-
Pobierz darmowy fragment (pdf)

Gdzie kupić całą publikację:

Java. Programowanie, biblioteki open-source i pomysły na nowe projekty
Autor:

Opinie na temat publikacji:


Inne popularne pozycje z tej kategorii:


Czytaj również:


Prowadzisz stronę lub blog? Wstaw link do fragmentu tej książki i współpracuj z Cyfroteką: