przemkovv's world

Rozwijam właśnie aplikację w której niezbędne jest przeprowadzanie obliczeń na niekoniecznie z góry znanych typach. W celu zapewnienia elastyczności poszczególnych klas zdecydowałem się na implementacje klas generycznych. Załóżmy, że mamy taką oto klasę:

1
2
3
4

public class Klasa< T > {
    public T Field1;
    public T Field2;
}

Następnie utwórzmy metodę, która ma za zadanie zsumować oba pola i zwrócić wynik. Intuicyjnie powstanie taki kod:

1
2
3

    public T SumFields() {
        return Field1 + Field2;
    }

Jednakże podczas kompilacji zostaniemy uraczeni następującym błędem:
Error 1 Operator '+' cannot be applied to operands of type 'T' and 'T'

Po chwili zastanowienia nie można się kompilatorowi dziwić, nie każdy typ musi mieć zaimplementowany operator dodawania (a także odejmowania, mnożenia, itd.). Znająć z kolei chęci programistów Microsoft do projektowania interfejsów do „wszystkiego” zaczałem szukać takiego, który deklarowałby powyższe operatory. Niestety czegoś takiego jeszcze nie ma (może kiedyś będzie?). I należy się posiłkować innymi metodami.

W tym celu można wykorzystać wprowadzony w C# 4.0 nowy typ dynamic. Deklarując zmienną typu dynamic zmieniamy moment, w którym rozwiązywany jest jej typ. Normalnie proces ten jest realizowany w czasie kompilacji, natomiast w przypadku dynamic w czasie działania programu (podobnie jak w językach skryptowych bez ścisłego typowania).

Po drobnej modyfikacji metoda będzie wyglądała następująco:

1
2
3
4

    public T SumFields() {
        dynamic dField1 = Field1, dField2 = Field2;
        return dField1 + dField2;
    }

Wiele razy już w przeciągu ostatnich 2-3 lat szukałem jakiejś porządnej biblioteki implementującej podstawowe algorytmy z algebry liniowej i ogólnie z matematyki. Wbrew pozorom znalezienie tychże dla platformy .NET nie jest takie trywialne..

Po odpytaniu google o jakikolwiek silnik matematyczny natrafiamy na cenioną open sourcową bibliotekę GSL. Z mojego punktu widzenia ma ona jedną wadę: jest mocno nastawianona na środowisko Linuksowe. O ile istnieją wersje przeportowane na system Win32 (nie mówię tutaj o Cygwinie) to nie były już aktualizowane kilka lat. A o automagicznym podpięciu się z poziomu C# można praktyczznie pomarzyć..

Następna kolekcja matematyczna jak wpadła mi w ręce to dnAnalytics. Muszę przyznać, że jest ona bardzo dobrze przygotowana zapewniając bardzo wygodny i intyuicyjny intefejs programistyczny. Z podstawowych możliwości udostępnianych mogę wymienić własną implementację struktury do obsługi macierzy i wektorów, możliwość wczytywania i zapisywania danych z/do plików CSV, chyba wszystkie najważniejsze operacje na macierzach oraz szereg algorytmów do rozwiązywania równań, dekompozycji macierzy (SVD, LU, QR) i co najważniejsze ma zaimplementowane wsparcie dla natywnej biblioteki Intel Math Kernel Library, dzięki czemu znacząco zyskujemy na wydajności. Niestety dnAnalytics miał jedną wadę: nie w pełni wykorzystywał możliwości MKL.

W ten sposób dotarłem (całkiem przypadkowo) od ILNumerics.Net. Porównując z dnAnalytics to ma raczej trochę inny interfejs (ani nie lepszy, ani nie gorszy, po prostu inny) przypominający bardziej język skryptowy  z Scilaba czy Matlaba (między innymi odwoływanie się do pól macierzy). A skoro jestem przy macierzach to warto wspomnieć, że w tym przypadku nie jesteśmy ograniczeni tylko do dwóch wymiarów i typu double, ale dzięki typom generycznym możemy wykorzystać niemal dowolny typ numeryczny w wielomiarowej przestrzeni. Malutkim minusem jest brak obsługi plików CSV do których przyzwyczaiła mnie dnAnalytics, ale coś za coś. Na zakończenie jeszcze jeden ogromny plus: w pełni wykorzystuje zestaw funkcji LINPACK z natywnej biblioteki MKL, a także dodatkowo z konkurencyjnej biblioteki firmy AMD. Dla zachowania kompatybilności z platformą mono powstała również specjalna wersja natywnego silnika matematycznego.

Podsumowując dnAnalytics jest bardzo przejrzystą biblioteką nadającą się do projektów w których nie wymaga się dużej wydajności i ograniczamy się do dwóch wymiarów. ILNumerics.Net jest natomiast prawdziwą perełką wśród otwartych bibliotek matematycznych, a dzięki porządnemu połączeniu z MKL i pochodnymi jest naprawdę wydajnym tworem.

Parę dni temu coś mnie podkusiło do instalacji wersji beta nowego service packa do VS2008 i .NET3.5. Instalacja przeszła względnie bezboleśnie (musiałem tylko zwolnić trochę miejsca na dysku;) ).

I wszystko byłoby OK, gdyby nie fakt, że RubiksCube v2 przestał działać..
A dokładniej po wykonaniu dowolnego ruchu wywalał się bliżej nieokreślony błąd w PresentationCore.dll (bliżej nieokreślony, bo opisu błędu wogóle nie było). Co lepsze przed SP1 Beta aplikacja działała prawidłowo…

Błędu szukałem komentując po kolei poszczególne fragmenty kodu i dotarłem do takiej konstrukcji

if (model == null)
{
    model = new Model3DGroup();
}
else
{
    model.Children.Clear();
}

Gdzie model jest typu Model3DGroup. Doszedłem do tego, że aplikacja wywalała się przez linijkę 7. Nie wiem dlaczego tak się zachowywał, ale błąd naprawiłem w następujący sposób:

if (model == null)
{
    model = new Model3DGroup();
}
else
{
    model.Children = new Model3DCollection();
}

I jak na razie aplikacja śmiga

Jak wiadomo debugger dla programisty to jest bardzo ważne narzędzie, które potrafi znacząco ułatwić pracę. Moim zdaniem w Visual Studio znajduje się chyba jeden z najlepszych pod względem intuicyjnego używania (aczkolwiek dawno nie korzystałem z produktów Borlanda, tam może też się co nieco zmieniło;) ). Nie będę tutaj opisywał jak z poziomu środowiska IDE obsługiwać to narzędzie, gdyż to raczej każdy już sie z tym zapoznał, ale jak z niego korzystać z poziomu kodu.

W ogólności służy do tego klasaSystem.Diagnostics.Debugger. Co prawda posiada ona tylko trzy metody przydatne dla programisty, ale liczba ich nie jest istotna;).

• Debugger.Break() – powoduje zatrzymanie działania programu i włączenie debuggera (coś a la standardowy breakpoint)
• Debugger.Launch() – uruchamia debugger i podłącza go do aktualnego procesu, ale jeszcze go nie zatrzymuje
• Debugger.Log(int level, string category, string message – wykorzystuje w przypadku, gdy chcemy wysłać na konsolę debuggera informację zwrotną. Nie potrzebujemy w tym wypadku tworzyć aplikacji konsolowej – w ogóle nie musi ona posiadać jakiegokolwiek okna

Ciekawostką jest to, że wywołania tych metod zostają usuwane w wersji Release projektu. Są one dostępne jedynie w wersji Debug.
Przydatności metody Log() chyba nie trzeba tłumaczyć. Zawsze przecież przydają się dodatkowe informacje w przypadku, gdy badamy rozbudowaną i przebiegającą przez wiele iteracji funkcję.

Break() możemy oczywiście zastąpić standardowym Breakpointem z IDE, ale ma taką zaletę, że zadziała nawet wtedy gdy nie będziemy uruchamiali aplikacji z VisualStudio. Przydatne przy badaniu WebService’ów zainstalowanych na IIS;)

Sąsiednią klasą towarzyszącą System.Diagnostics.Debugger jest System.Diagnostics.Debug udostęniająca asercje (Assert(bool condition) – przy czym warunek musi być spełniony, aby program działał poprawnie) oraz bardziej rozbudowane metody do obsługi wyjścia w konsoli debuggera takie jak Write, WriteIf, WriteLine, WriteLineIf, Indent, Unindent, Print. W każdym bądź razie polecam się z nimi zapoznać

Wyrażenia lambda jest to nowa konstrukcja wprowadzona do C# 3.0 pozwalająca w łatwy i przejrzysty sposób na „szybko” zdefiniować jakąś funkcję. W tej notce napiszę jak można je użyć do definiowan

Nadrzędnym typem każdego wyrażenia lambda jest typ Func<T1, T2, T3, T4, TResult> gdzie T1-T4 są typami argumentów, a TResult typem wyniku. Nie jesteśmy oczywiście przywiązani do czterech parametrów wejściowych, gdyż zostały zdefiniowane typy od 0 do 4 argumentowe (zmienia się liczba wystąpień TX). TResult jest natomiast parametrem obowiązkowym.

W poniższym przykładzie zdefiniuję metodę w klasie Matrix, która jako argument będzie otrzymywała wyrażenie lambda (funkcję) i wykona ją dla każdego z elementów macierzy. Przechodząc do praktyki będzie to wyglądało tak:

        public void DoForAllElements(Func< T , T> function)
        {

            for (int i = 0; i < N; i++)
            {
                for (int j = 0; j < M; j++)
                {
                    this[i, j] = function(this[i, j]);
                }
            }
        }

Wykorzystać ją możemy w sposób następujący:

var A = new Matrix< Double , DoubleCalculator>();
A.DoForAllElements( x => Math.Sqrt(x) );

Prawda, że proste?

Zacznę może od tego, że potrzebuję w pewnym projekcie pisanym w C# obsługę macierzy (dodawanie, mnożenie, ślad, itp). Konkretniej chodzi o macierz skonstruowaną z elementów typu prostego Double, ale dobrą cechą byłaby jej uniwersalność (czyli obsługa dowolnych typów) – w skrócie macierz generyczna. Ponieważ jestem troszku leniwy więc rozpocząłem poszukiwania odpowiednich bibliotek w Internecie. Niestety jedynym rozwiązaniem godnym przejrzenia, aczkolwiek niespełniącym moich wymagań była biblioteka CSML. Wadą jej polega na tym, że natywnie operuje na liczbach zespolonych (co można oczywiście zarzutować w przestrzeń liczb rzeczywistch) i nie ma domyślnie zrobionej konwersji Double na Complex.

Zdziwiło mnie, że taka ważna struktura w obliczeniach numerycznych nie dorobiła się pożądnej implementacji (dodam jeszcze: darmowej).. No cóż, w takim razie należy samemu napisać odpowiedni kod.

Zacząłem od stworzenia szkieletu klasy:

public class Matrix< T >
{
	T[,] matrix;
        public int N { get; private set; }
        public int M { get; private set; }
        public Matrix(int n, int m)
        {
        }

        public T this[int i, int j]
        {
        }
	public static Matrix< T > operator +(Matrix< T > A, Matrix< T > B)
	{
	}
	public static Matrix< T > operator -(Matrix< T > A, Matrix< T > B)
	{
	}
	public static Matrix< T > operator *(Matrix< T > A, Matrix< T > B)
	{
	}
}

Dokonałem następnie implementacji pierwszego z operatorów:

        public static Matrix< T > operator +(Matrix< T > A, Matrix< T > B)
        {
            if (A.N == B.N && A.M == B.M)
            {
                Matrix< T > result = new Matrix< T >(A.N, A.M);
                for (int i = 0; i < A.N; i++)
                {
                    for (int j = 0; j < A.M; j++)
                    {
                        result[i, j] = A[i, j] + B[i, j];
                    }
                }
                return result;
            }
            else
            {
                throw new Exception("Matrices have different dimensions");
            }
        }

Próba kompilacji i… błąd: „Operator ‘+’ cannot be applied to operands of type ‘T’ and ‘T’”. W sumie prawda, skąd kompilator ma wiedzieć, czy typ T ma zaimplementowany operator dodawania. Właśnie po to wprowadzono system reguł mogący wymusić na danym typie kilka cech. Zaglądam więc do dokumentacji MSDN i niestety nic ciekawego nie znalazłem. Odpalam wyszukiwarkę dotarłem do kilku wątków o tym samym problemie i jedyną odpowiedzią jest to, że: nie można czegoś takiego zrobić ponieważ Double jest typem prostym.

Ostatecznie jest jeszcze jedno rozwiązanie („Using generics for calculations”), ale moim zdaniem nie do końca jest ono wzorowe z tego względu, że należałoby stosować dodatkową warstwę pomiędzy typami Int32, Double a naszą klasą generyczną. Ale dużego wyboru nie ma..

Wróciłem po dłuższym czasie do mojego hobbistycznego projektu RubiksCube v2. Zrobiłem ponieważ pojawiła się iskierka nadzieji, że zaliczę na uczelni nim laboratoria z baz danych. Tak więc brakującą częścią do tej pory była cała inteligencja układania kostki. Algorytmy (sekwencje ruchów) już kiedyś postanowiłem przechowywać w pliku XML. Wczoraj dokończyłem projektowanie pliku XML Scheme i.. zacząłem się zastanawiać jak to wykorzystać w projekcie. Rozwiązań było kilka:

1. Ręcznie parsować plik XML – to już przeszłość…
2. Skorzystać z zintegrowanego z platformą parsera XML oraz XPath – niestety jest to nadal bardzo wiele roboty i można się zagubić w którymś momencie
3. Skorzystać z LINQ to XML – to już wygląda dużo lepiej, ale nadal trzeba się odwoływać do elementów poprzez obiekt Xelement, no i brak jest ścisłego typowania obiektów na typy z XSD.
4. Dzisiaj znalazłem jeszcze taki projekt jak LINQ to XSD. Robi to wszystko co LINQ to XML z jednym małym dodatkiem. Pozwala na ścisłe typowanie obiektów, a to dzięki temu, że sam automatycznie generuje odpowiednie klasy w C#. Niestety wadą uniemożliwiającą skorzystanie z tego cudownego narzędzia jest to, że chwilowo nie jest rozwijany a ostatnia wersja pamięta czasy Visual Studio Orcas beta 1. I z powodu niekompatybilności wersji System.Xml.Linq nie da się tego w prosty sposób uruchomić na wersji RTM. Należy cierpliwie czekać na dalszy bieg wydarzeń…
5. Szukając dalej znalazłem coś takiego jak CodeXS. Potrafi przekonwertować plik XSD na zestaw klas C# (także VB), a następnie jednym poleceniem wypełnić wszystkie struktury danymi z pliku XML opartego na danym XSD z zachowaniem wszystkich typów (także wyliczeniowych) oraz bardziej skomplikowanych struktur. Na stronie producenta jest dostępna wersja online (wysyłamy plik XSD na serwer i ściągamy archiwum z klasami) oraz postać źródłowa tej aplikacji. W prosty sposób można ją podpiąć pod zdarzenia pre-build w projekcie VS i mamy ładny generator kodu na podstawie XSD. Wadą jest niestety to, że chyba nie będzie można wykorzystać tutaj LINQ, gdyż na pierwszy rzut oka nie ma odpowiedniego wsparcia ze strony IDE. Ale poszukam może jeszcze czegoś na ten temat.

Ostatecznie waham się pomiędy rozwiązaniem trzecim a piątym (czwarte naprawdę niestety odpada). Trzecie na obecną chwilę mimo trochę bardziej skomplikowanej składni pozwala na wygodne przeszukiwanie, piąte natomiast posiada bardzo dobre typowanie danych, a z przeszukiwaniem gorzej.

Jednym z przyczyn dla której platforma .NET jest tak elastyczna jest mechanizm refleksji. Prościej mówiąc modyfikacja programu w czasie jego działania. Przykładem użycia może być wywoływanie metod nieznając ich nazw w czasie pisania programu albo tworzenie obiektów z klas znajdujących się w zewnętrznych bibliotekach (inaczej: system wtyczek).
Żeby nie było nie występuje on tylko w produktach firmy Microsoft, ale także w innych językach: PHP, Java, Perl, Ruby. W których został zaimplementowany już dosyć dawno.
Continue reading »

No to udało mi się w końcu opanować wszystkie animacje Dodatkowo zastosowałem tani chwyt i zmodyfikowałem trochę kod, aby była możliwość zmiany rozmiarów kostki. Od teraz będzie można układać kostki 2x2x2, 3x3x3, 4x4x4, 10x10x10 i wszystkie pośrednie (włącznie z wszystkimi prostopadłościanami).
Niestety czy rozmiarach większych niż 6x6x6 wydajność już dosyć znacznie spadła. Będę musiał zoptymalizować jakoś ten kod. A swoją drogą w Visual Studio w wersji proffesional brakuje mi profiler’a. Znacznie by ułatwił pracę, niestety jest dostępny jedynie w edycji Team Suite

Poniżej mała demonstracja:

Oto screencast z prezentacji pierwszej prototypowej wersji RubiksCube. Jak narazie wielu efektów nie widać, ale to jest prawie, że dopiero początek.
W tej chwili jest zrobiony silnik do obsługi kostki Rubika oraz wizualizacja z wykorzystaniem technologi WPF.