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:

    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:

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

W sumie zainteresowałem się tym już jakiś tydzień temu szukając jakichś fajnych gadżetów na mojego HTC Touch Diamonda (dorobiłem się w końcu jakiś czas temu, tak jak i nowego laptopa;) ). No i przypomniałem sobie o Windows Sideshow - usłudze, której nazwa co chwile wpadała w oczy podczas przeglądania panelu sterowania. Grzebiąc trochę w Internecie doszukałem się, że Microsoft wypuścił aplikacyjkę na Windows Mobile wykorzystującą właśnie Windows SideShow. Jaki jest efekt działania?

W tej chwili na komórce w momencie gdy jest połączona przez Bluetooth (po WiFi nie działa) mogę połączyć się z usługą Windows SideShow na laptopie i korzystać z zainstalowanych gadżetów. Gadżety można ściągnąć z MS Live Gallery, ale na chwilę obecną nie ma ich niestety zbyt wiele. W każdym bądź razie są dwa dosyć przydatne.

Office Powerpoint Remote oraz domyślnie zainstalowany gadget do Windows Media Playera. Ten drugi umożliwa zdalne sterowanie naszym WMP, a ten pierwszy czyni z naszego telefonu dosyć zaawansowany prezenter, który oprócz możliwości przełączania slajdów wyświetla również napisane notatki oraz wyświetla jaki będzie następny slajd. Co prawda ma jeszcze parę małych wad jak kiepskie przystosowanie do dotykowego ekranu, ale i tak cieżko znaleźć podobną aplikację i to za darmo

Linki:

• Office Powerpoint Remote
• Windows SideShow for Windows Mobile Developer Preview
• Windows SideShow Team Blog

Początkowo prace deweloperskie przeprowadzane były na maszynie z systemem 32bitowym z pamięcią 4GB. Występuje tutaj zjawisko ograniczenia pamięci dla procesu do 2GB (ewentualnie do 3GB z odpowiednim przełącznikiem). Przez jakiś czas wystarczał nam obecny limit... Ale po co się ograniczać skoro procesory są 64bitowe? Tak więc po przeinstalowaniu systemu na Windows Server 2008 x64 nastąpiła przedwczesna radość z praktycznie zerowymi limitami (nie mam do dyspozycji serwera z 2TB pamięci RAM ).

Pierwszym problem przy uruchamianiu aplikacji pojawił się z bibliotekami matematycznymi Intel Math Kernel Library, były jeszcze 32bitowe, ale nie sprawiło dużo kłopotów przerobienie jej na wersję 64bitową (aczkolwiek trzeba było trochę doczytać;P ).

W końcu z wielką radością w oczach aplikacja została odpalona i można było patrzeć jak rośnie słupek zajętości pamięci przez proces, urósł do około 4GB. No dobra, ale jakie tutaj są ograniczenia? Okazuje się, że najbliższym limitem jest ciągł obszar jaki można zaalokować. Próba zdefiniowania tablicy typu Byte o liczbie elementów większej niż 2^31 zakończyła się porażką (mniejszą bądź równą - należy wziąć jeszcze narzut platformy .NET - jak najbardziej udało się zaalokować). Dlaczego akurat tablica może mieć rozmiar tylko 2GB? No cóż, wina leży po stronie platformy .NET i środowiska CLR.

Następny krokiem była próba zaalokowania kilku tablic po 2GB każda. Niestety po 6 takich wyświetlił mi się wyjątek OutOfMemoryException (patrz rysunek)

Przyczyną braku pamięci zapewne była wielkość pliku wymiany, gdyż odpowiedni licznik pokazywał ładną liczbę 15999MB (rysunek). Zajętość co prawda wyniosła 14484MB, ale kolejne 2GB tutaj już się nie mieszczą

Ostatecznie muszę stwierdzić, że o ile limit 2GB na wielkość ciągłej pamięci do zaalokowania może boleć (należałoby się zagłębić bardziej w jaki sposób można to obejść), to obszar pamięci dla jednego procesu jest jak na razie nie do zapełnienia dla mnie pożytecznymi danymi, a zawsze można jeszcze zwiększyć rozmiar pliku wymiany.

Warto przeczytać:

1. BigArray<T>, getting around the 2GB array size limit
2. Memory Limits for Windows Releases
3. Zarządzanie pamięcią w 32 i 64-bitowych systemach Windows

Obecnie zostałem poniekąd "zmuszony" do zapoznania się z symulatorami sieci i ocenienia, które z nich spełnią odpowiednie wymagania. Kilka takowych się znalazło (m.in. opnet, omnet++),  ale ich wadami są jak zwykle albo trudnodostępność, albo fakt, że nie są już rozwijane od dłuższego czasu. W momencie, gdy dotarłem do ns2 (w sumie to od niego zacząłem tę przygodę:) ) muszę przyznać, że ktoś odwalił kawał dobrej roboty.

ns2 jest to projekt open-source stworzony przez badaczy dla badaczy. Rdzeń symulatora jest napisany w pełni obiektowo w C++, a skrypty eksperymentów (i nie tylko) można pisać w obiektowej wersji Tcl - OTcl. ns2 umożliwa symulowanie praktycznie każdej warstwy modelu OSI/ISO, począwszy od warstwy fizycznej, poprzez sieciową (wraz z włączeniem różnych protokołów routingu), aż po zachowanie się protokołów warstwy transportowej i aplikacji.

W celu przetestowania własnego protokołu (którejkolwiek z warstw) "wystarczy" go tylko zaimplementować w symulatorze. Ostatecznie nie jest to dosyć trudne, gdyż można wzorować się na już napisanych algorytmów.

Efektem działania symulatora jest plik tekstowy w którym zawarte są wszystkie niezbędne informacje na temat każdego z pakietów jaki w naszej wirtualnej sieci podróżował. Wystarczy teraz zaprząc jakiś parser (np. awk), coś do rysowania wykresów (np. gnuplot) i już możemy się cieszyć naszymi wynikami

Dodatkowo jeżeli chcielibyśmy wizualnie zobaczyć co się w naszej sieci dzieje można skorzystać z programu NAM (Network Animator) towarzyszącego ns2. Który na podstawie odpowiedniego pliku wynikowego z ns2 stworzy ładną animacje ruchu na poszczególnych połączeniach węzłów.

To tyle jeżeli chodzi o ns2. Chciałbym jeszcze wspomnieć o kolejnej wersji symulatora ns3, która jest w trakcie powstawiania. W przeciwieństwie do ns2, ns3 jest w całości napisana w C++ (ns2 korzysta również z OTcl) i jak na razie skrypty eksperymentów to są programy napisane w C++ (aktualnie powstają bindingi do pythona). Ciekawostką jeżeli chodzi o ns3 jest to, że wspiera on format plików pcap, dzięki czemu możemy bezproblemowo odczytać wyniki naszej symulacji albo poprzez tcpdump, albo wireshark <-- czyż to nie jest dużo wygodniejsze niż pliki tekstowe?

Więcej informacji można znaleźć na stronie symulatora:

1. ns2 i nam
2. ns3

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.

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

Jeżeli chodzi o zdolność układania to 4x4x4 udało mi się po raz pierwszy ułożyć po około 2h. Następne próby trwały już około 1h. W następnej kolejności zabrałem się za piątkę, ostatecznie również skończyłem po około godzinie . Od teraz chyba nie będę się nudził już na żadnym z wykładów

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ć

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?

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..