https://wiki.otwartaedukacja.pl/api.php?action=feedcontributions&feedformat=atom&user=AdminOtwarta edukacja - Wkład użytkownika [pl]2026-05-21T23:20:42ZWkład użytkownikaMediaWiki 1.38.2https://wiki.otwartaedukacja.pl/index.php?title=Procesor_i_j%C4%99zyk_maszynowy_-_wprowadzenie&diff=172Procesor i język maszynowy - wprowadzenie2022-11-07T20:26:20Z<p>Admin: /* Projektujemy procesor */</p>
<hr />
<div>Informacje o module:<br />
* Poziom: Podstawowy<br />
* Profil: Dla techników i inżynierów<br />
<br />
<br />
<br />
== Struktura komputera ==<br />
<br />
W sklepach z zabawkami można dostać skarbonki w kształcie zwierzęcia, które po wrzuceniu monety w otwór na głowie zamyka usta, jakby coś połykało. W działaniu takiej skarbonki można wyróżnić kilka operacji: wrzucona moneta naciska na przedłużenie szczęki (1), szczęka zamyka się i moneta spada (2), szczęka otwiera się i skarbonka wraca do punktu początkowego (0). Zauważmy, że aby scharakteryzować działanie skarbonki, wystarczy opisać ją w pewnych wybranych momentach czasu. Opis taki nazywamy stanem urządzenia. W naszym przypadku możemy wyróżnić stany: podstawowy (0), wrzucona moneta (1), zamknięta szczęka (2). Samo działanie poza tymi wybranymi momentami nas nie interesuje - w takim opisie czas zmienia się skokowo (mówimy, że '''czas ma charakter dyskretny'''). Jest to oczywiście pewne uproszczenie, ale pozwala na dokonanie opisu w sposób bardzo ścisły.<br />
<br />
=== Komputer jest urządzeniem posiadającym pamięć ===<br />
<br />
Pamięcią&nbsp;nazwiemy urządzenie, którego stan w kolejnych momentach czasu możemy odczytać. Przykładem tak rozumianej pamięci może być zwykły notes. Możemy przeglądając go odczytać umieszczone tam zapiski. Zapiski te stanowią stan notesu. Tego typu pamięć ma jednak pewną wadę - zapis nie daje się łatwo zmieniać i nie może to być wykonane automatycznie. Pamięć komputera poza możliwością zmiany stanu musi charakteryzować się możliwością łatwego określenia zasad tych zmian tak, aby mogło to odbywać się automatycznie. Sposób automatycznej zmiany stanu można określić podając dla każdego stanu stan następny (po zmianie).<br />
<br />
Pamięć prawdziwych komputerów składa się z bardzo prostych elementów elektronicznych. Mogą się one znajdować w jednym z dwóch stanów: 0 lub 1. Stan jest reprezentowany przez wysokość napięcia (wysokie napięcie = 1, niskie = 0). Elementów takich jest za to bardzo dużo. Wielkość pamięci mierzy się w bitach (jeden element dwustanowy = 1 bit). Osiem bitów nazywa się bajtem. 1024 bajty to kilobajt (kB), a 1024 kilobajty to 1 megabajt (MB). Obecnie komputery mają przeważnie 8, 16, 32, 64 lub 128 MB pamięci.<br />
<br />
=== Procesor dokonuje zmian stanu pamięci ===<br />
<br />
Oczywiście zmiany pamięci nie wykonują się same z siebie. Potrzebny jest element który w sposób automatyczny wykona je zgodnie z instrukcjami. Po to właśnie komputer wyposażony jest w procesor, dokonujący zmian pamięci (stanu) w kolejnych momentach czasu.<br />
<br />
[[Plik:Pamiec_procesor.png]]<br />
<br />
Procesor jest układem elektronicznym przetwarzającym sygnały odczytane z pamięci. W jednym momencie odczytuje stan pamięci i oblicza stan następny. W następnym momencie zmienia się stan pamięci na wypracowany przez procesor.<br />
<br />
Kolejne chwile czasu (w których następuje zmiana stanu) wyznacza generator sygnałów elektrycznych zwany zegarem. Częstotliwość generowanego sygnału jest podstawowym parametrem określającym szybkość komputera (mówimy że procesor działa z szybkością 100MHz, 200MHz, itd..)<br />
<br />
<br />
Teoretycznie rzecz biorąc następny stan pamięci zależy od stanu aktualnego całej pamięci. Jak wspomnieliśmy jednak, pamięć komputera jest bardzo duża. Dla uproszczenia konstrukcji procesory wykonuje się więc w ten sposób, że mogą one odczytywać i zmieniać jedynie mały fragment pamięci. Nie ma to większego wpływu na funkcjonalność komputera (zamiast zmienić stan wszystkich elementów równocześnie, zmienia się je po kolei). Sytuację tą można porównać do poruszania się w układzie współrzędnych tylko wzdłuż osi układu. W jednym kroku zmienia się tylko jedna współrzędna, ale nie ogranicza to zasięgu naszego ruchu (dla takich modeli często mówi się o przestrzeni stanów).<br />
<br />
=== Procesor - serce komputera ===<br />
<br />
Cykl działania procesora można więc określić w sposób następujący:<br />
<br />
#. Odczyt fragmentu pamięci (komórki, słowa).<br />
#. Wykonanie operacji (+wyznaczenie następnego stanu tego fragmentu pamięci).<br />
#. Zapis nowych wartości do pamięci.<br />
#. Wyznaczenie nowego fragmentu pamięci do pobrania.<br />
<br />
Poszczególne operacje są wykonywane w takt zegara komputera. Każdy z powyższych punktów może być wykonywany w kilku taktach, ale teoretycznie możliwe jest wykonanie jednego cyklu tylko w dwóch taktach (punkty 2,3 i 4 mogą być wykonane w jednym kroku). Zależy to od budowy procesora.<br />
<br />
Jednym z najistotniejszych pomysłów na jakie wpadli konstruktorzy komputera jest&nbsp;<u>zapis instrukcji dla procesora w pamięci komputera</u>. Aby procesor mógł sam odczytywać rozkazy (instrukcje) z pamięci i efektywnie działać zgodnie z przedstawionym powyżej schematem trzeba było przyjąć kilka dodatkowych założeń:<br />
<br />
#. Wszystkie instrukcje otrzymują swoje kody (załóżmy, że wszystkie informacje zapisane w pamięci są liczbami). Wraz z niektórymi z tych kodów są pamiętane parametry instrukcji (zob. przykład poniżej).<br />
<br />
#. Wszystkie komórki pamięci zostają ponumerowane (0,1,2,...). Mówimy, że komórki są adresowane.<br />
<br />
#. Wydziela się fragmenty pamięci w których będą pamiętane:* <br />
* wynik ostatniej instrukcji (rozkazu)<br />
* kod wykonywanej instrukcji<br />
* numer komórki (adres) zawierającej kod kolejnego rozkazu do wykonania<br />
<br />
<br />
Te fragmenty pamięci nazywamy rejestrami. Rejestry zazwyczaj stanowią część procesora i nie są adresowane tak jak reszta pamięci. W konkretnych realizacjach procesorów ilość rejestrów jest większa (zazwyczaj jednak nie więcej niż 10). Ta wewnętrzna złożoność procesora jest jedną z przyczyn, dla których pewne operacje wymagają więcej niż dwóch taktów zegara.<br />
<br />
== Projektujemy procesor ==<br />
<br />
Budowę procesora najlepiej pokazać na przykładzie. W tym celu zaprojektujemy prosty, przykładowy procesor. Przyjmujemy, że procesor zawiera rejestry:<br />
<br />
* ''akumulator&nbsp;''- wynik operacji<br />
* ''licznik -&nbsp;''adres kolejnej operacji<br />
<br />
<br />
Dodatkowo mamy rejestry pomocnicze, które są używane przez procesor do przechowywania aktualnie wykonywanej instrukcji:<br />
<br />
* ''instrukcji -&nbsp;''kod pobranego rozkazu<br />
* ''parametru -&nbsp;''parametr operacji<br />
<br />
<br />
Każda instrukcja zajmuje w pamięci dwa bajty (kod + parametr). Po pobraniu kodu rozkazu lub parametru licznik automatycznie zwiększa się o jeden (czyli wskazuje na następny rozkaz).<br />
<br />
<br />
[[Plik:Procesor.png]]<br />
<br />
Procesor działa powtarzając trzy operacje (każdy rozkaz jest wykonywany w czasie trzech taktów zegara):<br />
<br />
1. pobranie kodu instrukcji (z miejsca wskazanego przez licznik, zwiększa się o 1)<br />
<br />
2. pobranie parametru (z miejsca wskazanego przez licznik, zwiększa się o 1)<br />
<br />
3. wykonanie operacji<br />
<br />
tak długo, aż napotka rozkaz STOP.<br />
<br />
<br />
Nasz procesor wykonuje następujące instrukcje:<br />
<br />
<br />
{|<br />
|-<br />
| align=center style="border-top:0.2pt double #808080;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | '''nazwa'''<br />
| align=center style="border-top:0.2pt double #808080;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | '''kod'''<br />
| align=center style="border-top:0.2pt double #808080;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | '''parametr'''<br />
| align=center style="border:0.2pt double #808080;padding:0.049cm;" | '''opis'''<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | POBIERZ<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 1<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres danej<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | przepisuje zawartość wskazanej komórki pamięci do akumulatora<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | APOBIERZ<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 2<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres pamięci<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | przepisz do akumulatora zawartość komórki o adresie wskazanym przez&nbsp;adres pamięci<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | WPISZ<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 3<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres danej<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | zapisuje zawartość akumulatora do wskazanej komórki pamięci<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | DODAJ<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 4<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres danej<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | dodaje zawartość wskazanej komórki do zawartości akumulatora<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | USTAW<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 5<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | liczba<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | ustaw zawartość akumulatora na&nbsp;liczba<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | SKOCZ_DO<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 6<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | wpisz&nbsp;adres&nbsp;do licznika<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | ZERO<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 7<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | gdy akumulator zawiera zero, wpisz&nbsp;adres&nbsp;do licznika<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | STOP<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 0<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 0<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | zatrzymaj<br />
|-<br />
|}<br />
Spróbujmy napisać prosty program. Przyjmiemy, że adresy rozkazów zaczynają się od 0, a adresy danych od 100. Pierwsza komórka pamięci (adres 100) zawiera ilość liczb do zsumowania, druga będzie zawierać wynik, a trzecia będzie używana przez nas do adresowania. Następne zawierają liczby do zsumowania.<br />
<br />
Program w postaci symbolicznej będzie wyglądał następująco:<br />
<br />
0: USTAW LICZBY ; adres liczb do zsumowania<br />
<br />
2: WPISZ ADRES ; ustawienie komórki wskazującej sumowaną liczbę<br />
<br />
4: USTAW 0 ; zerowanie<br />
<br />
6: WPISZ WYNIK ; zapisanie wyniku<br />
<br />
8:A: POBIERZ ILOSC ; ilość liczb do zsumowania<br />
<br />
10: ZERO K ; nie ma już liczb do zsumowania<br />
<br />
12: DODAJ -1 ; zmniejsz ilość<br />
<br />
14: WPISZ ILOSC ; zapisz nową ilość<br />
<br />
16: APOBIERZ ADRES ; pobranie kolejnej liczby<br />
<br />
18: DODAJ WYNIK ; dodanie dotychczasowej sumy<br />
<br />
20: WPISZ WYNIK ; zapis wyniku<br />
<br />
22: POBIERZ ADRES ; pobranie adresu<br />
<br />
24: DODAJ 1 ; zwiększenie o 1<br />
<br />
26: WPISZ ADRES ; zapisanie nowego adresu<br />
<br />
28: SKOCZ_DO A ; powtórzenie dla następnej liczby<br />
<br />
30:K: STOP<br />
<br />
W powyższym zapisie mamy pięć kolumn:<br />
<br />
* adres w pamięci (z dwukropkiem)<br />
* opcjonalni: symboliczny zapis adresu (też z dwukropkiem)<br />
* kod instrukcji<br />
* parametr<br />
* komentarz (po średniku)<br />
<br />
<br />
<br />
Zamiast pisać kody instrukcji i adresy użyliśmy symboli. Podobnie zostały przedstawione adresy instrukcji (A, K).<br />
<br />
Wartość symboli:<br />
<br />
LICZBY = 103<br />
<br />
ADRES = 102<br />
<br />
WYNIK = 101<br />
<br />
ILOSC = 100<br />
<br />
A = 8<br />
<br />
K = 30<br />
<br />
Początek pamięci wygląda następująco (na początku wiersza podano adres pierwszej z komórek):<br />
<br />
0: 5; 103; 3; 102; 5; 0; 3;101;1; 100;<br />
<br />
10: 7; 30;4; -1; 3;100;2;102;4;101;<br />
<br />
20: 3;101;22:1;102;4;1;3;102;6;8;0<br />
<br />
Dla ćwiczenia spróbuj zamienić kody symbolami i porównaj z podanym wcześniej zapisem.<br />
<br />
Spróbuj określić zawartość komórek o adresie powyżej 100 i prześledzić jak będą się one zmieniały wraz z wykonywaniem programu.</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Procesor_i_j%C4%99zyk_maszynowy_-_wprowadzenie&diff=171Procesor i język maszynowy - wprowadzenie2022-11-07T20:25:02Z<p>Admin: /* Projektujemy procesor */</p>
<hr />
<div>Informacje o module:<br />
* Poziom: Podstawowy<br />
* Profil: Dla techników i inżynierów<br />
<br />
<br />
<br />
== Struktura komputera ==<br />
<br />
W sklepach z zabawkami można dostać skarbonki w kształcie zwierzęcia, które po wrzuceniu monety w otwór na głowie zamyka usta, jakby coś połykało. W działaniu takiej skarbonki można wyróżnić kilka operacji: wrzucona moneta naciska na przedłużenie szczęki (1), szczęka zamyka się i moneta spada (2), szczęka otwiera się i skarbonka wraca do punktu początkowego (0). Zauważmy, że aby scharakteryzować działanie skarbonki, wystarczy opisać ją w pewnych wybranych momentach czasu. Opis taki nazywamy stanem urządzenia. W naszym przypadku możemy wyróżnić stany: podstawowy (0), wrzucona moneta (1), zamknięta szczęka (2). Samo działanie poza tymi wybranymi momentami nas nie interesuje - w takim opisie czas zmienia się skokowo (mówimy, że '''czas ma charakter dyskretny'''). Jest to oczywiście pewne uproszczenie, ale pozwala na dokonanie opisu w sposób bardzo ścisły.<br />
<br />
=== Komputer jest urządzeniem posiadającym pamięć ===<br />
<br />
Pamięcią&nbsp;nazwiemy urządzenie, którego stan w kolejnych momentach czasu możemy odczytać. Przykładem tak rozumianej pamięci może być zwykły notes. Możemy przeglądając go odczytać umieszczone tam zapiski. Zapiski te stanowią stan notesu. Tego typu pamięć ma jednak pewną wadę - zapis nie daje się łatwo zmieniać i nie może to być wykonane automatycznie. Pamięć komputera poza możliwością zmiany stanu musi charakteryzować się możliwością łatwego określenia zasad tych zmian tak, aby mogło to odbywać się automatycznie. Sposób automatycznej zmiany stanu można określić podając dla każdego stanu stan następny (po zmianie).<br />
<br />
Pamięć prawdziwych komputerów składa się z bardzo prostych elementów elektronicznych. Mogą się one znajdować w jednym z dwóch stanów: 0 lub 1. Stan jest reprezentowany przez wysokość napięcia (wysokie napięcie = 1, niskie = 0). Elementów takich jest za to bardzo dużo. Wielkość pamięci mierzy się w bitach (jeden element dwustanowy = 1 bit). Osiem bitów nazywa się bajtem. 1024 bajty to kilobajt (kB), a 1024 kilobajty to 1 megabajt (MB). Obecnie komputery mają przeważnie 8, 16, 32, 64 lub 128 MB pamięci.<br />
<br />
=== Procesor dokonuje zmian stanu pamięci ===<br />
<br />
Oczywiście zmiany pamięci nie wykonują się same z siebie. Potrzebny jest element który w sposób automatyczny wykona je zgodnie z instrukcjami. Po to właśnie komputer wyposażony jest w procesor, dokonujący zmian pamięci (stanu) w kolejnych momentach czasu.<br />
<br />
[[Plik:Pamiec_procesor.png]]<br />
<br />
Procesor jest układem elektronicznym przetwarzającym sygnały odczytane z pamięci. W jednym momencie odczytuje stan pamięci i oblicza stan następny. W następnym momencie zmienia się stan pamięci na wypracowany przez procesor.<br />
<br />
Kolejne chwile czasu (w których następuje zmiana stanu) wyznacza generator sygnałów elektrycznych zwany zegarem. Częstotliwość generowanego sygnału jest podstawowym parametrem określającym szybkość komputera (mówimy że procesor działa z szybkością 100MHz, 200MHz, itd..)<br />
<br />
<br />
Teoretycznie rzecz biorąc następny stan pamięci zależy od stanu aktualnego całej pamięci. Jak wspomnieliśmy jednak, pamięć komputera jest bardzo duża. Dla uproszczenia konstrukcji procesory wykonuje się więc w ten sposób, że mogą one odczytywać i zmieniać jedynie mały fragment pamięci. Nie ma to większego wpływu na funkcjonalność komputera (zamiast zmienić stan wszystkich elementów równocześnie, zmienia się je po kolei). Sytuację tą można porównać do poruszania się w układzie współrzędnych tylko wzdłuż osi układu. W jednym kroku zmienia się tylko jedna współrzędna, ale nie ogranicza to zasięgu naszego ruchu (dla takich modeli często mówi się o przestrzeni stanów).<br />
<br />
=== Procesor - serce komputera ===<br />
<br />
Cykl działania procesora można więc określić w sposób następujący:<br />
<br />
#. Odczyt fragmentu pamięci (komórki, słowa).<br />
#. Wykonanie operacji (+wyznaczenie następnego stanu tego fragmentu pamięci).<br />
#. Zapis nowych wartości do pamięci.<br />
#. Wyznaczenie nowego fragmentu pamięci do pobrania.<br />
<br />
Poszczególne operacje są wykonywane w takt zegara komputera. Każdy z powyższych punktów może być wykonywany w kilku taktach, ale teoretycznie możliwe jest wykonanie jednego cyklu tylko w dwóch taktach (punkty 2,3 i 4 mogą być wykonane w jednym kroku). Zależy to od budowy procesora.<br />
<br />
Jednym z najistotniejszych pomysłów na jakie wpadli konstruktorzy komputera jest&nbsp;<u>zapis instrukcji dla procesora w pamięci komputera</u>. Aby procesor mógł sam odczytywać rozkazy (instrukcje) z pamięci i efektywnie działać zgodnie z przedstawionym powyżej schematem trzeba było przyjąć kilka dodatkowych założeń:<br />
<br />
#. Wszystkie instrukcje otrzymują swoje kody (załóżmy, że wszystkie informacje zapisane w pamięci są liczbami). Wraz z niektórymi z tych kodów są pamiętane parametry instrukcji (zob. przykład poniżej).<br />
<br />
#. Wszystkie komórki pamięci zostają ponumerowane (0,1,2,...). Mówimy, że komórki są adresowane.<br />
<br />
#. Wydziela się fragmenty pamięci w których będą pamiętane:* <br />
* wynik ostatniej instrukcji (rozkazu)<br />
* kod wykonywanej instrukcji<br />
* numer komórki (adres) zawierającej kod kolejnego rozkazu do wykonania<br />
<br />
<br />
Te fragmenty pamięci nazywamy rejestrami. Rejestry zazwyczaj stanowią część procesora i nie są adresowane tak jak reszta pamięci. W konkretnych realizacjach procesorów ilość rejestrów jest większa (zazwyczaj jednak nie więcej niż 10). Ta wewnętrzna złożoność procesora jest jedną z przyczyn, dla których pewne operacje wymagają więcej niż dwóch taktów zegara.<br />
<br />
== Projektujemy procesor ==<br />
<br />
Budowę procesora najlepiej pokazać na przykładzie. W tym celu zaprojektujemy prosty, przykładowy procesor. Przyjmujemy, że procesor zawiera rejestry:<br />
<br />
* ''akumulator&nbsp;''- wynik operacji<br />
* ''licznik -&nbsp;''adres kolejnej operacji<br />
<br />
<br />
Dodatkowo mamy rejestry pomocnicze, które są używane przez procesor do przechowywania aktualnie wykonywanej instrukcji:<br />
<br />
* ''instrukcji -&nbsp;''kod pobranego rozkazu<br />
* ''parametru -&nbsp;''parametr operacji<br />
<br />
<br />
Każda instrukcja zajmuje w pamięci dwa bajty (kod + parametr). Po pobraniu kodu rozkazu lub parametru licznik automatycznie zwiększa się o jeden (czyli wskazuje na następny rozkaz).<br />
<br />
<br />
[[Plik:Procesor.png]]<br />
<br />
Procesor działa powtarzając trzy operacje (każdy rozkaz jest wykonywany w czasie trzech taktów zegara):<br />
<br />
1. pobranie kodu instrukcji (z miejsca wskazanego przez licznik, zwiększa się o 1)<br />
<br />
2. pobranie parametru (z miejsca wskazanego przez licznik, zwiększa się o 1)<br />
<br />
3. wykonanie operacji<br />
<br />
tak długo, aż napotka rozkaz STOP.<br />
<br />
<br />
Nasz procesor wykonuje następujące instrukcje:<br />
<br />
<br />
{|<br />
|-<br />
| align=center style="border-top:0.2pt double #808080;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | '''nazwa'''<br />
| align=center style="border-top:0.2pt double #808080;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | '''kod'''<br />
| align=center style="border-top:0.2pt double #808080;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | '''parametr'''<br />
| align=center style="border:0.2pt double #808080;padding:0.049cm;" | '''opis'''<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | POBIERZ<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 1<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres danej<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | przepisuje zawartość wskazanej komórki pamięci do akumulatora<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | APOBIERZ<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 2<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres pamięci<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | przepisz do akumulatora zawartość komórki o adresie wskazanym przez&nbsp;adres pamięci<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | WPISZ<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 3<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres danej<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | zapisuje zawartość akumulatora do wskazanej komórki pamięci<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | DODAJ<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 4<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres danej<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | dodaje zawartość wskazanej komórki do zawartości akumulatora<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | USTAW<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 5<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | liczba<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | ustaw zawartość akumulatora na&nbsp;liczba<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | SKOCZ_DO<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 6<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | wpisz&nbsp;adres&nbsp;do licznika<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | ZERO<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 7<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | adres<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | gdy akumulator zawiera zero, wpisz&nbsp;adres&nbsp;do licznika<br />
|-<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | STOP<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 0<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:none;padding:0.049cm;" | 0<br />
| style="border-top:none;border-bottom:0.2pt double #808080;border-left:0.2pt double #808080;border-right:0.2pt double #808080;padding:0.049cm;" | zatrzymaj<br />
|-<br />
|}<br />
Spróbujmy napisać prosty program. Przyjmiemy, że adresy rozkazów zaczynają się od 0, a adresy danych od 100. Pierwsza komórka pamięci (adres 100) zawiera ilość liczb do zsumowania, druga będzie zawierać wynik, a trzecia będzie używana przez nas do adresowania. Następne zawierają liczby do zsumowania.<br />
<br />
Program w postaci symbolicznej będzie wyglądał następująco:<br />
<br />
0: USTAW LICZBY ; adres liczb do zsumowania<br />
<br />
2: WPISZ ADRES ; ustawienie komórki wskazującej sumowaną liczbę<br />
<br />
4: USTAW 0 ; zerowanie<br />
<br />
6: WPISZ WYNIK ; zapisanie wyniku<br />
<br />
8:A: POBIERZ ILOSC ; ilość liczb do zsumowania<br />
<br />
10: ZERO K ; nie ma już liczb do zsumowania<br />
<br />
12: DODAJ -1 ; zmniejsz ilość<br />
<br />
14: WPISZ ILOSC ; zapisz nową ilość<br />
<br />
16: POBIERZ ADRES ; pobranie kolejnej liczby<br />
<br />
18: DODAJ WYNIK ; dodanie dotychczasowej sumy<br />
<br />
20: WPISZ WYNIK ; zapis wyniku<br />
<br />
22: POBIERZ ADRES ; pobranie adresu<br />
<br />
24: DODAJ 1 ; zwiększenie o 1<br />
<br />
26: WPISZ ADRES ; zapisanie nowego adresu<br />
<br />
28: SKOCZ_DO A ; powtórzenie dla następnej liczby<br />
<br />
30:K: STOP<br />
<br />
W powyższym zapisie mamy pięć kolumn:<br />
<br />
* adres w pamięci (z dwukropkiem)<br />
* opcjonalni: symboliczny zapis adresu (też z dwukropkiem)<br />
* kod instrukcji<br />
* parametr<br />
* komentarz (po średniku)<br />
<br />
<br />
<br />
Zamiast pisać kody instrukcji i adresy użyliśmy symboli. Podobnie zostały przedstawione adresy instrukcji (A, K).<br />
<br />
Wartość symboli:<br />
<br />
LICZBY = 103<br />
<br />
ADRES = 102<br />
<br />
WYNIK = 101<br />
<br />
ILOSC = 100<br />
<br />
A = 8<br />
<br />
K = 30<br />
<br />
Początek pamięci wygląda następująco (na początku wiersza podano adres pierwszej z komórek):<br />
<br />
0: 5; 103; 3; 102; 5; 0; 3;101;1; 100;<br />
<br />
10: 7; 30;4; -1; 3;100;2;102;4;101;<br />
<br />
20: 3;101;22:1;102;4;1;3;102;6;8;0<br />
<br />
Dla ćwiczenia spróbuj zamienić kody symbolami i porównaj z podanym wcześniej zapisem.<br />
<br />
Spróbuj określić zawartość komórek o adresie powyżej 100 i prześledzić jak będą się one zmieniały wraz z wykonywaniem programu.</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=RSA&diff=170RSA2022-09-30T14:27:01Z<p>Admin: rsa</p>
<hr />
<div>Algorytm RSA jest jednym z najważniejszych algorytmów związanych z bezpieczeństwem.<br />
<br />
== Podstawy teoretyczne ==<br />
<br />
# Funkcja Eulera: fi(n) - ilość liczb całkowitych dodatnich mniejszych od n i względnie pierwszych z n. 1.1. fi(n) = n-1, gdy n jest liczbą pierwszą (bo każda liczba jest względnie pierwsza z liczbą pierwszą). 1.2. Gdy n =p*q, gdzie p, q - liczby pierwsze, fi(n) = (p-1)*(q-1) Dowód:<br />
#* wszystkich liczb mniejszych od n jest p*q-1<br />
#* liczby mające z n wspólny podzielnik p: p, 2*p, 3*p, ... (q-1)*p - jest ich q-1<br />
#* liczby mające z n wspólny podzielnik q: q, 2*q, 3*q, ... (p-1)*q - jest ich p-1<br />
#* a więc: fi(n) = p*q - (p-1) - (q-1) -1 = p*q - p - q + 1 = (p-1) * (q-1) = fi(p)*fi(q)<br />
# Twierdzenie Eulera: Dla każdych (a, n), takich, że gcd(a,n) = 1 mamy (a^fi(n)) mod n =1 ^ oznacza potęgowanie gcd = największy wspólny podzielnik mod = reszta z dzielenia (modulo), ale określona na liczbach dodatnich (-1 mod 10 = 9 !!!). Dowód:<br />
#* R = {r1, r2,... rfi(n) } - zbiór liczb całkowitych dodatnich, mniejszych od n i względnie pierwszych z n (residuów) (zob. Funkcję Eulera)<br />
#* jeśli każdą z liczb ri pomnożymy przez a modulo n ( (ri * a) mod n ), otrzymamy fi(n) różnych wyników; gdyby bowiem zachodziło: ri * a mod n = rj * a mod n = r, mielibyśmy (ri-rj)*a mod n =0, a więc a i n nie byłyby względnie pierwsze.<br />
#* mamy więc (a*r1)*(a*r2)*....*(a*rfi(n)) = r1*r2*...*rfi(n) czyli (a^fi(n) mod n) * r1*r2*...*rfi(n) = r1*r2*...*rfi(n) a po uproszczeniu a^fi(n) mod n = 1<br />
# Szyfr wykładniczy polega na szyfrowaniu poprzez potęgowanie modulo n. C = M^e mod n Odszyfrowanie można wykonać poprzez potęgowanie używając innego wykładnika (klucza)!: M=C^d mod n Powyższe równania są swoją odwrotnością (czyli pomnożenie ich daje w wyniku 1, albo inaczej (M^e mod n) ^d mod n = M), pod warunkiem, że e*d mod fi(n) = 1 Dowód:<br />
#* (M^e mod n) ^d mod n = M^(e*d) mod n<br />
#* ale:e*d = t * fi(n) +1<br />
#* mamy więc M^e*d mod n = M^(t*fi(n)+1) mod n = M*M^(t*fi(n) mod n = M* (M^(t*fi(n)) mod n) mod n<br />
#* na mocy twierdzenia Eulera mamy M^(t*fi(n)) mod n = ((M^fi(n) mod n)^t) mod n = 1^t mod n = 1<br />
#* a więc M^(e*d) mod n = (M*1) mod n = M<br />
# Generowanie kluczy:<br />
#* wybieramy d względnie pierwsze z fi(n)<br />
#* obliczamy e = inv(d, fi(n)) gdzie inv = odwrotność, czyli (x * inv(x, fi(n)) ) mod fi(n)=1<br />
<br />
Najprostsza implementacja (Python):<syntaxhighlight lang="py3"><br />
import numpy as np<br />
import primesieve<br />
from random import randint<br />
<br />
def gen_prime(min, max):<br />
"""<br />
Eratosthenes sieve http://code.activestate.com/recipes/117119/<br />
https://github.com/hickford/primesieve-python<br />
"""<br />
prime_list = primesieve.primes(min, max)<br />
while (not prime_list):<br />
min=max<br />
max+=100<br />
prime_list = generate_primes(min, max)<br />
n=randint(0, len(prime_list)-1)<br />
return prime_list[n]<br />
<br />
<br />
# The greatest common divisor (GCD) - Euclides<br />
def gcd(x, y):<br />
while y != 0:<br />
(x, y) = (y, x % y)<br />
return x<br />
<br />
# result == x: a*x mod n == 1, 0 < a < n<br />
# extended Euclides<br />
# https://anh.cs.luc.edu/331/notes/xgcd.pdf<br />
def inv(a,n):<br />
v0 = 0<br />
v1 = 1<br />
r0=n<br />
r1=a<br />
while r1 != 0:<br />
d = r0 // r1<br />
(r0, r1) = r1, r0 - d * r1<br />
(v0, v1) = v1, v0 - d * v1<br />
if v0>0:<br />
return v0<br />
else:<br />
return v0+n<br />
<br />
<br />
def rsa_keys(p, q): # p<q<br />
# return: d, e, p * q<br />
n=p*q<br />
fi=(q-1)*(p-1)<br />
# wybieramy d wzglednie pierwsze wzgledem fi z przedzialu [q + 1 .. n-1] <br />
d=q+1<br />
wd=-1<br />
while (wd != 1 ) and (d<n):<br />
wd=gcd(d, fi)<br />
if wd != 1:<br />
d+=1<br />
if wd != 1:<br />
print('nie znaleziono kluczy')<br />
exit(-1)<br />
e = inv(d, fi)<br />
return (d, e, n)<br />
<br />
<br />
def rsa(M, d, n):<br />
return (M ** d) % n<br />
<br />
<br />
if __name__=="__main__":<br />
# przykładowe dane startowe<br />
min=779<br />
d=88<br />
# liczby pierwsze<br />
p=gen_prime(min,min+d)<br />
q=gen_prime(p,p+d)<br />
# klucze<br />
d, e, n = rsa_keys(p, q)<br />
print ('d=%s, e=%s, n=%s' % (d, e, n))<br />
# test<br />
M=input('Liczba=')<br />
Mcrypt=rsa(M,d,n)<br />
print("zaszyfrowana=%s" % Mcrypt)<br />
print("odszyfrowana=%s" % rsa(Mcrypt,e,n))<br />
</syntaxhighlight>Ta implementacja nie nadaje się do praktycznego zastosowania, gdyż program działa zbyt wolno, a przy generowaniu kluczy nie są sprawdzane dodatkowe wymogi odpowiedniej złożoności. Powyższy program służy jedynie do zilustrowania algorytmu. W praktyce stosuje się gotowe biblioteki takie jak OpenSSL.</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytmy&diff=169Algorytmy2022-09-30T14:19:17Z<p>Admin: </p>
<hr />
<div>* [[Proste sortowanie tablic]]<br />
* [[Algorytm Simplex]]<br />
* [[RSA]]</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=168Algorytm Simplex2022-09-30T05:51:24Z<p>Admin: </p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy rozwiązywania układów równań i nierówności liniowych.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowego rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
b = [100, -10]<br />
c = [3,4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej<ref>Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe” https://www.snopes.com/fact-check/the-unsolvable-math-problem/</ref>: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z: wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di: xi ≥ di, wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
----Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie współczynniki funkcji celu [c] są mniejsze lub równe zeru (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: skoro wszystkie wartości zmiennych decyzyjnych X są większe lub równe zeru, to jeśli i-ty element [c] (c[i]) jest większy od zera, zwiększenie współrzędnej i (x[i]>0) powoduje zwiększenie funkcji celu.<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były mniejsze lub równe zeru (przy szukaniu maksimum).<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1). (Na temat wyboru wiersza i kolumn będzie jeszcze mowa poniżej).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zmienione – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą mniejsze lub równe zeru, albo nie uda się znaleźć przekształcenia dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[3,4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
'''Uwaga! Wartości zmiennych w ostatniej kolumnie dotyczą zmiennych bazowych. Jeśli zmienna decyzyjna nie jest obecna w bazie - oznacza to, że w rozwiązaniu jej wartość wynosi zero (0).'''<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” ( https://www.mimuw.edu.pl/~oskar/lecture_13.pdf ), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Przykładowa implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
===== Analiza działania algorytmu =====<br />
Dla tablicy z jedną zmienną decyzyjną x1 i jedną zmienną luzu (x2) wartość funkcji celu będzie wynosić (x1/x1 – z dzielenia wiersza przez x1, a następnie odejmowanie wiersza):<br />
<br />
z = 0-b1*c1*x1/x1<br />
<br />
czyli (zgodnie z oczekiwaniem):<br />
<br />
z=-b1*c1<br />
<br />
Przykład:<br />
{| class="wikitable"<br />
| colspan="4" |Tablica 1<br />
|-<br />
|<br />
|'''x1'''<br />
|'''s1'''<br />
|'''b'''<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''1,00'''<br />
|'''5,00'''<br />
|-<br />
|c<br />
|1,00<br />
|0,00<br />
|0,00<br />
|-<br />
|<br />
| colspan="3" |Wiersz 0 podzielony przez a[0][0] – czyli 1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''1,00'''<br />
|'''5,00'''<br />
|-<br />
|Tablica 2<br />
|<br />
|<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|1,00<br />
|5,00<br />
|-<br />
|c<br />
|0,00<br />
| -1,00<br />
| -5,00<br />
|}<br />
<br />
<br />
Zauważmy, że jeśli c1 byłoby <0 – zadanie nie miałoby rozwiązania dla liczb dodatnich.<br />
<br />
<br />
Weźmy teraz pod uwagę dowolną tablicę Simplex w której została do zredukowania jedna kolumna ze zmienną decyzyjną. Na przykład odpowiadająca nierówności 2*x3<=3, oraz czynnikowi x3*4 w funkcji celu (kolumna x3, wiersz 2):<br />
{| class="wikitable"<br />
|Tablica 1<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|-<br />
|<br />
|x1<br />
|x2<br />
|'''x3'''<br />
|s1<br />
|s2<br />
|'''s3'''<br />
|b<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|'''2,00'''<br />
|1,00<br />
|0,50<br />
|'''0,00'''<br />
|8,50<br />
|-<br />
|1<br />
|0,50<br />
|1,00<br />
|'''0,00'''<br />
|0,00<br />
|0,50<br />
|'''0,00'''<br />
|4,50<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''2,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|3,00<br />
|-<br />
|3<br />
| -0,50<br />
|0,00<br />
|'''4,00'''<br />
|0,00<br />
| -2,50<br />
|'''0,00'''<br />
| -22,50<br />
|-<br />
|<br />
| colspan="5" |Wiersz 2 podzielony przez a[2][2] – czyli 2<br />
|<br />
|<br />
|-<br />
|2<br />
|'''0'''<br />
|'''0'''<br />
|'''1'''<br />
|'''0'''<br />
|'''0'''<br />
|'''0,5'''<br />
|'''1,5'''<br />
|-<br />
| colspan="8" |Tablica 2<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
| -1,00<br />
|5,50<br />
|-<br />
|1<br />
|0,50<br />
|1,00<br />
|0,00<br />
|0,00<br />
|0,50<br />
|0,00<br />
|4,50<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,00<br />
|0,00<br />
|0,50<br />
|1,50<br />
|-<br />
|3<br />
| -0,50<br />
|0,00<br />
|0,00<br />
|0,00<br />
| -2,50<br />
| -2,00<br />
| -28,50<br />
|}<br />
Wykonanie redukcji zmienia wynik funkcji celu o b[2] podzielone przez x3[2] i pomnożone przez c z kolumny x3 (c[2]). Czyli najpierw wyliczamy ile co najwyżej może wynosić x3, a następnie odejmowana jest ta wartość od wyniku funkcji celu (przy liczeniu maksimum wynik jest uzyskiwany ze znakiem minus), po przemnożeniu przez odpowiedni współczynnik (c[2] – czyli 4).<br />
<br />
Czyli redukcja działa dokładnie tak, jakbyśmy to zrobili bez automatu. Tak samo algorytm Simplex zadziałałby, gdyby dodać kolumnę z jedną wartością dla dowolnej wielkości tablicy.<br />
<br />
Zastanówmy się na koniec – co się stanie, jeśli dodana kolumna x3 będzie zawierać wartości różne od zera 0 w więcej niż jednym wierszu. Prześledźmy zmiany tablicy od samego początku:<br />
{| class="wikitable"<br />
| colspan="8" |Tablica 1<br />
|<br />
|-<br />
|<br />
|'''x1'''<br />
|'''x2'''<br />
|'''x3'''<br />
|'''s1'''<br />
|'''s2'''<br />
|'''S3'''<br />
|'''b'''<br />
|'''min. dla X1'''<br />
|-<br />
|0<br />
|2,00<br />
|<nowiki>-1,00</nowiki><br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''4,00'''<br />
|2,00<br />
|-<br />
|1<br />
|1,00<br />
|2,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|9,00<br />
|9,00<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|3,00<br />
|0,00<br />
|'''0,00'''<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|2,00<br />
|5,00<br />
|5,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[0][0] – czyli 2<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|'''0,00'''<br />
|'''0,50'''<br />
|'''0,00'''<br />
|<br />
|'''2,00'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 2<br />
|dla x2<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|0,00<br />
|0,50<br />
|0,00<br />
|0,00<br />
|2,00<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''2,50'''<br />
|0,00<br />
|<nowiki>-0,50</nowiki><br />
|'''1,00'''<br />
|0,00<br />
|7,00<br />
|2,80<br />
|-<br />
|2<br />
|0,00<br />
|'''0,00'''<br />
|3,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|'''6,00'''<br />
|5,00<br />
|<nowiki>-1,00</nowiki><br />
|0,00<br />
|0,00<br />
|<nowiki>-4,00</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][1] – czyli -2.5<br />
|<br />
|-<br />
|'''1'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''-0,20'''<br />
|'''0,40'''<br />
|'''0,00'''<br />
|'''2,80'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 3<br />
|dla x3<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,40<br />
|0,20<br />
|0,00<br />
|3,40<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|<nowiki>-0,20</nowiki><br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''3,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|2,00<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|5,00<br />
|0,20<br />
|<nowiki>-2,40</nowiki><br />
|0,00<br />
|<nowiki>-20,80</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[2][2] – czyli 3<br />
|<br />
|-<br />
|'''2'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''0,33'''<br />
|'''2,00'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 4<br />
|dla s1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|'''0,40'''<br />
|0,20<br />
|0,00<br />
|3,40<br />
|8,50<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|<nowiki>-0,20</nowiki><br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,20<br />
|<nowiki>-2,40</nowiki><br />
|<nowiki>-1,67</nowiki><br />
|<nowiki>-30,80</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][2] – czyli 0,4<br />
|<br />
|-<br />
|2<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
|0,00<br />
|8,50<br />
|<br />
|-<br />
| colspan="8" |Tablica 5<br />
|<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
|0,00<br />
|8,50<br />
|<br />
|-<br />
|1<br />
|0,50<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,50<br />
|0,00<br />
|4,50<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|<nowiki>-0,50</nowiki><br />
|0,00<br />
|0,00<br />
|0,00<br />
|<nowiki>-2,50</nowiki><br />
|<nowiki>-1,67</nowiki><br />
|<nowiki>-32,50</nowiki><br />
|<br />
|}<br />
Baza dla tego przykładu zmienia się następująco (s1,s2,s3) → (x1,s2,s3)→(x1,x2,s3)→(x1,x2,x3)→(s1,x2,x3)<br />
<br />
Zmienna x3 wchodzi do bazy w „Tablicy 4”. Do tego momentu kolumna x3 nie wpływa na resztę tablicy (poza oczywiście uwzględnieniem w wartości funkcji celu). Wtedy wyliczana jest wartość x3 przez podzielenie ograniczenia (b[2]) przez współczynnik (x3[2]).<br />
<br />
Gdyby jednak w tablicy pojawiła się liczba 1 w polu x3[1] - wtedy w miejsce x1+2*x2<9 mielibyśmy x1+2*x2+x3<9. Wtedy przy redukcji kolumny x2 – odpowiadającej wierszowi z wstawioną jedynką – zostanie ona „przeliczona” na wartości 0,2 i 0,4 (Tablica 3, wiersz 0 i 1) – co w tablicy 4 skutkuje zmniejszeniem b[0] i b[1] w tablicy 4 (odpowiednio 2*0,2 oraz 2*0,4).<br />
{| class="wikitable"<br />
| colspan="7" |Tablica 1<br />
|<br />
|<br />
|-<br />
|<br />
|'''x1'''<br />
|'''x2'''<br />
|'''x3'''<br />
|'''s1'''<br />
|'''s2'''<br />
|'''S3'''<br />
|'''b'''<br />
|'''min. dla X1'''<br />
|-<br />
|0<br />
|2,00<br />
| -1,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''4,00'''<br />
|2,00<br />
|-<br />
|1<br />
|1,00<br />
|2,00<br />
|1,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|9,00<br />
|9,00<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|3,00<br />
|0,00<br />
|'''0,00'''<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|2,00<br />
|5,00<br />
|5,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[0][0] – czyli 2<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|'''0,00'''<br />
|'''0,50'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''2,00'''<br />
|<br />
|-<br />
|Tablica 2<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|dla x2<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|0,00<br />
|0,50<br />
|0,00<br />
|0,00<br />
|2,00<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''2,50'''<br />
|1,00<br />
| -0,50<br />
|'''1,00'''<br />
|0,00<br />
|7,00<br />
|2,80<br />
|-<br />
|2<br />
|0,00<br />
|'''0,00'''<br />
|3,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|'''6,00'''<br />
|5,00<br />
| -1,00<br />
|0,00<br />
|0,00<br />
| -4,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][1] – czyli -2.5<br />
|<br />
|-<br />
|'''1'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,40'''<br />
|'''-0,20'''<br />
|'''0,40'''<br />
|'''0,00'''<br />
|'''2,80'''<br />
|<br />
|-<br />
|Tablica 3<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|dla x3<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,20<br />
|0,40<br />
|0,20<br />
|0,00<br />
|3,40<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,40<br />
| -0,20<br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''3,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|2,00<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|2,60<br />
|0,20<br />
| -2,40<br />
|0,00<br />
| -20,80<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[2][2] – czyli 3<br />
|<br />
|-<br />
|'''2'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''0,33'''<br />
|'''2,00'''<br />
|<br />
|-<br />
|Tablica 4<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|dla s1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|'''0,40'''<br />
|0,20<br />
| -0,07<br />
|3,00<br />
|7,50<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
| -0,20<br />
|0,40<br />
| -0,13<br />
|2,00<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,20<br />
| -2,40<br />
| -0,87<br />
| -26,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][2] – czyli 0,4<br />
|<br />
|-<br />
|2<br />
|'''2,50'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,50'''<br />
|'''-0,17'''<br />
|'''7,50'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 5<br />
|<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,50<br />
| -0,17<br />
|7,50<br />
|<br />
|-<br />
|1<br />
|0,50<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,50<br />
| -0,17<br />
|3,50<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
| -0,50<br />
|0,00<br />
|0,00<br />
|0,00<br />
| -2,50<br />
| -0,83<br />
| -27,50<br />
|<br />
|}<br />
To zmniejszenie (b[0], b[1]) należy interpretować jako wyliczenie wpływu x3 na x1 i x2 we wspomnianej wyżej nierówności (wiersz 1). Jak to policzylibyśmy bez tablicy? Przyjmując x1+2*x2+x3 = 9 (wiersz 1) i x3=2 (6/2 - wiersz 2). Jeśli w ostatecznym wyniku x1=0, to x2=(9-2)/2 =3.5. Czyli dokładnie tyle, ile wylicza algorytm.<br />
[[Plik:Simplex3.ods|mały]]</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=167Algorytm Simplex2022-09-30T04:09:57Z<p>Admin: </p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy rozwiązywania układów równań i nierówności liniowych.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowego rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
b = [100, -10]<br />
c = [3,4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej<ref>Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe” https://www.snopes.com/fact-check/the-unsolvable-math-problem/</ref>: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z: wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di: xi ≥ di, wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
----Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie współczynniki funkcji celu [c] są mniejsze lub równe zeru (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: skoro wszystkie wartości zmiennych decyzyjnych X są większe lub równe zeru, to jeśli i-ty element [c] (c[i]) jest większy od zera, zwiększenie współrzędnej i (x[i]>0) powoduje zwiększenie funkcji celu.<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były mniejsze lub równe zeru (przy szukaniu maksimum).<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1). (Na temat wyboru wiersza i kolumn będzie jeszcze mowa poniżej).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zmienione – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą mniejsze lub równe zeru, albo nie uda się znaleźć przekształcenia dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
'''Uwaga! Wartości zmiennych w ostatniej kolumnie dotyczą zmiennych bazowych. Jeśli zmienna decyzyjna nie jest obecna w bazie - oznacza to, że w rozwiązaniu jej wartość wynosi zero (0).'''<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” ( https://www.mimuw.edu.pl/~oskar/lecture_13.pdf ), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Przykładowa implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
===== Analiza działania algorytmu =====<br />
Dla tablicy z jedną zmienną decyzyjną x1 i jedną zmienną luzu (x2) wartość funkcji celu będzie wynosić (x1/x1 – z dzielenia wiersza przez x1, a następnie odejmowanie wiersza):<br />
<br />
z = 0-b1*c1*x1/x1<br />
<br />
czyli (zgodnie z oczekiwaniem):<br />
<br />
z=-b1*c1<br />
<br />
Przykład:<br />
{| class="wikitable"<br />
| colspan="4" |Tablica 1<br />
|-<br />
|<br />
|'''x1'''<br />
|'''s1'''<br />
|'''b'''<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''1,00'''<br />
|'''5,00'''<br />
|-<br />
|c<br />
|1,00<br />
|0,00<br />
|0,00<br />
|-<br />
|<br />
| colspan="3" |Wiersz 0 podzielony przez a[0][0] – czyli 1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''1,00'''<br />
|'''5,00'''<br />
|-<br />
|Tablica 2<br />
|<br />
|<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|1,00<br />
|5,00<br />
|-<br />
|c<br />
|0,00<br />
| -1,00<br />
| -5,00<br />
|}<br />
<br />
<br />
Zauważmy, że jeśli c1 byłoby <0 – zadanie nie miałoby rozwiązania dla liczb dodatnich.<br />
<br />
<br />
Weźmy teraz pod uwagę dowolną tablicę Simplex w której została do zredukowania jedna kolumna ze zmienną decyzyjną. Na przykład odpowiadająca nierówności 2*x3<=3, oraz czynnikowi x3*4 w funkcji celu (kolumna x3, wiersz 2):<br />
{| class="wikitable"<br />
|Tablica 1<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|-<br />
|<br />
|x1<br />
|x2<br />
|'''x3'''<br />
|s1<br />
|s2<br />
|'''s3'''<br />
|b<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|'''2,00'''<br />
|1,00<br />
|0,50<br />
|'''0,00'''<br />
|8,50<br />
|-<br />
|1<br />
|0,50<br />
|1,00<br />
|'''0,00'''<br />
|0,00<br />
|0,50<br />
|'''0,00'''<br />
|4,50<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''2,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|3,00<br />
|-<br />
|3<br />
| -0,50<br />
|0,00<br />
|'''4,00'''<br />
|0,00<br />
| -2,50<br />
|'''0,00'''<br />
| -22,50<br />
|-<br />
|<br />
| colspan="5" |Wiersz 2 podzielony przez a[2][2] – czyli 2<br />
|<br />
|<br />
|-<br />
|2<br />
|'''0'''<br />
|'''0'''<br />
|'''1'''<br />
|'''0'''<br />
|'''0'''<br />
|'''0,5'''<br />
|'''1,5'''<br />
|-<br />
| colspan="8" |Tablica 2<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
| -1,00<br />
|5,50<br />
|-<br />
|1<br />
|0,50<br />
|1,00<br />
|0,00<br />
|0,00<br />
|0,50<br />
|0,00<br />
|4,50<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,00<br />
|0,00<br />
|0,50<br />
|1,50<br />
|-<br />
|3<br />
| -0,50<br />
|0,00<br />
|0,00<br />
|0,00<br />
| -2,50<br />
| -2,00<br />
| -28,50<br />
|}<br />
Wykonanie redukcji zmienia wynik funkcji celu o b[2] podzielone przez x3[2] i pomnożone przez c z kolumny x3 (c[2]). Czyli najpierw wyliczamy ile co najwyżej może wynosić x3, a następnie odejmowana jest ta wartość od wyniku funkcji celu (przy liczeniu maksimum wynik jest uzyskiwany ze znakiem minus), po przemnożeniu przez odpowiedni współczynnik (c[2] – czyli 4).<br />
<br />
Czyli redukcja działa dokładnie tak, jakbyśmy to zrobili bez automatu. Tak samo algorytm Simplex zadziałałby, gdyby dodać kolumnę z jedną wartością dla dowolnej wielkości tablicy.<br />
<br />
Zastanówmy się na koniec – co się stanie, jeśli dodana kolumna x3 będzie zawierać wartości różne od zera 0 w więcej niż jednym wierszu. Prześledźmy zmiany tablicy od samego początku:<br />
{| class="wikitable"<br />
| colspan="8" |Tablica 1<br />
|<br />
|-<br />
|<br />
|'''x1'''<br />
|'''x2'''<br />
|'''x3'''<br />
|'''s1'''<br />
|'''s2'''<br />
|'''S3'''<br />
|'''b'''<br />
|'''min. dla X1'''<br />
|-<br />
|0<br />
|2,00<br />
|<nowiki>-1,00</nowiki><br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''4,00'''<br />
|2,00<br />
|-<br />
|1<br />
|1,00<br />
|2,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|9,00<br />
|9,00<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|3,00<br />
|0,00<br />
|'''0,00'''<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|2,00<br />
|5,00<br />
|5,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[0][0] – czyli 2<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|'''0,00'''<br />
|'''0,50'''<br />
|'''0,00'''<br />
|<br />
|'''2,00'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 2<br />
|dla x2<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|0,00<br />
|0,50<br />
|0,00<br />
|0,00<br />
|2,00<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''2,50'''<br />
|0,00<br />
|<nowiki>-0,50</nowiki><br />
|'''1,00'''<br />
|0,00<br />
|7,00<br />
|2,80<br />
|-<br />
|2<br />
|0,00<br />
|'''0,00'''<br />
|3,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|'''6,00'''<br />
|5,00<br />
|<nowiki>-1,00</nowiki><br />
|0,00<br />
|0,00<br />
|<nowiki>-4,00</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][1] – czyli -2.5<br />
|<br />
|-<br />
|'''1'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''-0,20'''<br />
|'''0,40'''<br />
|'''0,00'''<br />
|'''2,80'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 3<br />
|dla x3<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,40<br />
|0,20<br />
|0,00<br />
|3,40<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|<nowiki>-0,20</nowiki><br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''3,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|2,00<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|5,00<br />
|0,20<br />
|<nowiki>-2,40</nowiki><br />
|0,00<br />
|<nowiki>-20,80</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[2][2] – czyli 3<br />
|<br />
|-<br />
|'''2'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''0,33'''<br />
|'''2,00'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 4<br />
|dla s1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|'''0,40'''<br />
|0,20<br />
|0,00<br />
|3,40<br />
|8,50<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|<nowiki>-0,20</nowiki><br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,20<br />
|<nowiki>-2,40</nowiki><br />
|<nowiki>-1,67</nowiki><br />
|<nowiki>-30,80</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][2] – czyli 0,4<br />
|<br />
|-<br />
|2<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
|0,00<br />
|8,50<br />
|<br />
|-<br />
| colspan="8" |Tablica 5<br />
|<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
|0,00<br />
|8,50<br />
|<br />
|-<br />
|1<br />
|0,50<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,50<br />
|0,00<br />
|4,50<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|<nowiki>-0,50</nowiki><br />
|0,00<br />
|0,00<br />
|0,00<br />
|<nowiki>-2,50</nowiki><br />
|<nowiki>-1,67</nowiki><br />
|<nowiki>-32,50</nowiki><br />
|<br />
|}<br />
Baza dla tego przykładu zmienia się następująco (s1,s2,s3) → (x1,s2,s3)→(x1,x2,s3)→(x1,x2,x3)→(s1,x2,x3)<br />
<br />
Zmienna x3 wchodzi do bazy w „Tablicy 4”. Do tego momentu kolumna x3 nie wpływa na resztę tablicy (poza oczywiście uwzględnieniem w wartości funkcji celu). Wtedy wyliczana jest wartość x3 przez podzielenie ograniczenia (b[2]) przez współczynnik (x3[2]).<br />
<br />
Gdyby jednak w tablicy pojawiła się liczba 1 w polu x3[1] - wtedy w miejsce x1+2*x2<9 mielibyśmy x1+2*x2+x3<9. Wtedy przy redukcji kolumny x2 – odpowiadającej wierszowi z wstawioną jedynką – zostanie ona „przeliczona” na wartości 0,2 i 0,4 (Tablica 3, wiersz 0 i 1) – co w tablicy 4 skutkuje zmniejszeniem b[0] i b[1] w tablicy 4 (odpowiednio 2*0,2 oraz 2*0,4).<br />
{| class="wikitable"<br />
| colspan="7" |Tablica 1<br />
|<br />
|<br />
|-<br />
|<br />
|'''x1'''<br />
|'''x2'''<br />
|'''x3'''<br />
|'''s1'''<br />
|'''s2'''<br />
|'''S3'''<br />
|'''b'''<br />
|'''min. dla X1'''<br />
|-<br />
|0<br />
|2,00<br />
| -1,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''4,00'''<br />
|2,00<br />
|-<br />
|1<br />
|1,00<br />
|2,00<br />
|1,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|9,00<br />
|9,00<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|3,00<br />
|0,00<br />
|'''0,00'''<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|2,00<br />
|5,00<br />
|5,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[0][0] – czyli 2<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|'''0,00'''<br />
|'''0,50'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''2,00'''<br />
|<br />
|-<br />
|Tablica 2<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|dla x2<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|0,00<br />
|0,50<br />
|0,00<br />
|0,00<br />
|2,00<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''2,50'''<br />
|1,00<br />
| -0,50<br />
|'''1,00'''<br />
|0,00<br />
|7,00<br />
|2,80<br />
|-<br />
|2<br />
|0,00<br />
|'''0,00'''<br />
|3,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|'''6,00'''<br />
|5,00<br />
| -1,00<br />
|0,00<br />
|0,00<br />
| -4,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][1] – czyli -2.5<br />
|<br />
|-<br />
|'''1'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,40'''<br />
|'''-0,20'''<br />
|'''0,40'''<br />
|'''0,00'''<br />
|'''2,80'''<br />
|<br />
|-<br />
|Tablica 3<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|dla x3<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,20<br />
|0,40<br />
|0,20<br />
|0,00<br />
|3,40<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,40<br />
| -0,20<br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''3,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|2,00<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|2,60<br />
|0,20<br />
| -2,40<br />
|0,00<br />
| -20,80<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[2][2] – czyli 3<br />
|<br />
|-<br />
|'''2'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''0,33'''<br />
|'''2,00'''<br />
|<br />
|-<br />
|Tablica 4<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|dla s1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|'''0,40'''<br />
|0,20<br />
| -0,07<br />
|3,00<br />
|7,50<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
| -0,20<br />
|0,40<br />
| -0,13<br />
|2,00<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,20<br />
| -2,40<br />
| -0,87<br />
| -26,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][2] – czyli 0,4<br />
|<br />
|-<br />
|2<br />
|'''2,50'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,50'''<br />
|'''-0,17'''<br />
|'''7,50'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 5<br />
|<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,50<br />
| -0,17<br />
|7,50<br />
|<br />
|-<br />
|1<br />
|0,50<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,50<br />
| -0,17<br />
|3,50<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
| -0,50<br />
|0,00<br />
|0,00<br />
|0,00<br />
| -2,50<br />
| -0,83<br />
| -27,50<br />
|<br />
|}<br />
To zmniejszenie (b[0], b[1]) należy interpretować jako wyliczenie wpływu x3 na x1 i x2 we wspomnianej wyżej nierówności (wiersz 1). Jak to policzylibyśmy bez tablicy? Przyjmując x1+2*x2+x3 = 9 (wiersz 1) i x3=2 (6/2 - wiersz 2). Jeśli w ostatecznym wyniku x1=0, to x2=(9-2)/2 =3.5. Czyli dokładnie tyle, ile wylicza algorytm.<br />
[[Plik:Simplex3.ods|mały]]</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=166Algorytm Simplex2022-09-29T22:15:06Z<p>Admin: /* Analiza działania algorytmu */</p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy rozwiązywania układów równań i nierówności liniowych.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowego rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
b = [100, -10]<br />
c = [3,4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej<ref>Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe” https://www.snopes.com/fact-check/the-unsolvable-math-problem/</ref>: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z: wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di: xi ≥ di, wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
----Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie współczynniki funkcji celu [c] są mniejsze lub równe zeru (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: skoro wszystkie wartości zmiennych decyzyjnych X są większe lub równe zeru, to jeśli i-ty element [c] (c[i]) jest większy od zera, zwiększenie współrzędnej i (x[i]>0) powoduje zwiększenie funkcji celu.<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były mniejsze lub równe zeru (przy szukaniu maksimum).<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1). (Na temat wyboru wiersza i kolumn będzie jeszcze mowa poniżej).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zmienione – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą mniejsze lub równe zeru, albo nie uda się znaleźć przekształcenia dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
'''Uwaga! Wartości zmiennych w ostatniej kolumnie dotyczą zmiennych bazowych. Jeśli zmienna decyzyjna nie jest obecna w bazie - oznacza to, że w rozwiązaniu jej wartość wynosi zero (0).'''<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” ( https://www.mimuw.edu.pl/~oskar/lecture_13.pdf ), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Przykładowa implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
===== Analiza działania algorytmu =====<br />
Dla tablicy z jedną zmienną decyzyjną x1 i jedną zmienną luzu (x2) wartość funkcji celu będzie wynosić (x1/x1 – z dzielenia wiersza przez x1, a następnie odejmowanie wiersza):<br />
<br />
z = 0-b1*c1*x1/x1<br />
<br />
czyli (zgodnie z oczekiwaniem):<br />
<br />
z=-b1*c1<br />
<br />
Przykład:<br />
{| class="wikitable"<br />
| colspan="4" |Tablica 1<br />
|-<br />
|<br />
|'''x1'''<br />
|'''s1'''<br />
|'''b'''<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''1,00'''<br />
|'''5,00'''<br />
|-<br />
|c<br />
|1,00<br />
|0,00<br />
|0,00<br />
|-<br />
|<br />
| colspan="3" |Wiersz 0 podzielony przez a[0][0] – czyli 1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''1,00'''<br />
|'''5,00'''<br />
|-<br />
|Tablica 2<br />
|<br />
|<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|1,00<br />
|5,00<br />
|-<br />
|c<br />
|0,00<br />
| -1,00<br />
| -5,00<br />
|}<br />
<br />
<br />
Zauważmy, że jeśli c1 byłoby <0 – zadanie nie miałoby rozwiązania dla liczb dodatnich.<br />
<br />
<br />
Weźmy teraz pod uwagę dowolną tablicę Simplex w której została do zredukowania jedna kolumna ze zmienną decyzyjną. Na przykład odpowiadająca nierówności 2*x3<=3, oraz czynnikowi x3*4 w funkcji celu (kolumna x3, wiersz 2):<br />
{| class="wikitable"<br />
|Tablica 1<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|-<br />
|<br />
|x1<br />
|x2<br />
|'''x3'''<br />
|s1<br />
|s2<br />
|'''s3'''<br />
|b<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|'''2,00'''<br />
|1,00<br />
|0,50<br />
|'''0,00'''<br />
|8,50<br />
|-<br />
|1<br />
|0,50<br />
|1,00<br />
|'''0,00'''<br />
|0,00<br />
|0,50<br />
|'''0,00'''<br />
|4,50<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''2,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|3,00<br />
|-<br />
|3<br />
| -0,50<br />
|0,00<br />
|'''4,00'''<br />
|0,00<br />
| -2,50<br />
|'''0,00'''<br />
| -22,50<br />
|-<br />
|<br />
| colspan="5" |Wiersz 2 podzielony przez a[2][2] – czyli 2<br />
|<br />
|<br />
|-<br />
|2<br />
|'''0'''<br />
|'''0'''<br />
|'''1'''<br />
|'''0'''<br />
|'''0'''<br />
|'''0,5'''<br />
|'''1,5'''<br />
|-<br />
| colspan="8" |Tablica 2<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
| -1,00<br />
|5,50<br />
|-<br />
|1<br />
|0,50<br />
|1,00<br />
|0,00<br />
|0,00<br />
|0,50<br />
|0,00<br />
|4,50<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,00<br />
|0,00<br />
|0,50<br />
|1,50<br />
|-<br />
|3<br />
| -0,50<br />
|0,00<br />
|0,00<br />
|0,00<br />
| -2,50<br />
| -2,00<br />
| -28,50<br />
|}<br />
Wykonanie redukcji zmienia wynik funkcji celu o b[2] podzielone przez x3[2] i pomnożone przez c z kolumny x3 (c[2]). Czyli najpierw wyliczamy ile co najwyżej może wynosić x3, a następnie odejmowana jest ta wartość od wyniku funkcji celu (przy liczeniu maksimum wynik jest uzyskiwany ze znakiem minus), po przemnożeniu przez odpowiedni współczynnik (c[2] – czyli 4).<br />
<br />
Czyli redukcja działa dokładnie tak, jakbyśmy to zrobili bez automatu. Tak samo algorytm Simplex zadziałałby, gdyby dodać kolumnę z jedną wartością dla dowolnej wielkości tablicy.<br />
<br />
Zastanówmy się na koniec – co się stanie, jeśli dodana kolumna x3 będzie zawierać wartości różne od zera 0 w więcej niż jednym wierszu. Prześledźmy zmiany tablicy od samego początku:<br />
{| class="wikitable"<br />
| colspan="8" |Tablica 1<br />
|<br />
|-<br />
|<br />
|'''x1'''<br />
|'''x2'''<br />
|'''x3'''<br />
|'''s1'''<br />
|'''s2'''<br />
|'''S3'''<br />
|'''b'''<br />
|'''min. dla X1'''<br />
|-<br />
|0<br />
|2,00<br />
|<nowiki>-1,00</nowiki><br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''4,00'''<br />
|2,00<br />
|-<br />
|1<br />
|1,00<br />
|2,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|9,00<br />
|9,00<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|3,00<br />
|0,00<br />
|'''0,00'''<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|2,00<br />
|5,00<br />
|5,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[0][0] – czyli 2<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|'''0,00'''<br />
|'''0,50'''<br />
|'''0,00'''<br />
|<br />
|'''2,00'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 2<br />
|dla x2<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|0,00<br />
|0,50<br />
|0,00<br />
|0,00<br />
|2,00<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''2,50'''<br />
|0,00<br />
|<nowiki>-0,50</nowiki><br />
|'''1,00'''<br />
|0,00<br />
|7,00<br />
|2,80<br />
|-<br />
|2<br />
|0,00<br />
|'''0,00'''<br />
|3,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|'''6,00'''<br />
|5,00<br />
|<nowiki>-1,00</nowiki><br />
|0,00<br />
|0,00<br />
|<nowiki>-4,00</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][1] – czyli -2.5<br />
|<br />
|-<br />
|'''1'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''-0,20'''<br />
|'''0,40'''<br />
|'''0,00'''<br />
|'''2,80'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 3<br />
|dla x3<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,40<br />
|0,20<br />
|0,00<br />
|3,40<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|<nowiki>-0,20</nowiki><br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''3,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|2,00<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|5,00<br />
|0,20<br />
|<nowiki>-2,40</nowiki><br />
|0,00<br />
|<nowiki>-20,80</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[2][2] – czyli 3<br />
|<br />
|-<br />
|'''2'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''0,33'''<br />
|'''2,00'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 4<br />
|dla s1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|'''0,40'''<br />
|0,20<br />
|0,00<br />
|3,40<br />
|8,50<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|<nowiki>-0,20</nowiki><br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,20<br />
|<nowiki>-2,40</nowiki><br />
|<nowiki>-1,67</nowiki><br />
|<nowiki>-30,80</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][2] – czyli 0,4<br />
|<br />
|-<br />
|2<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
|0,00<br />
|8,50<br />
|<br />
|-<br />
| colspan="8" |Tablica 5<br />
|<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
|0,00<br />
|8,50<br />
|<br />
|-<br />
|1<br />
|0,50<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,50<br />
|0,00<br />
|4,50<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|<nowiki>-0,50</nowiki><br />
|0,00<br />
|0,00<br />
|0,00<br />
|<nowiki>-2,50</nowiki><br />
|<nowiki>-1,67</nowiki><br />
|<nowiki>-32,50</nowiki><br />
|<br />
|}<br />
Baza dla tego przykładu zmienia się następująco (s1,s2,s3) → (x1,s2,s3)→(x1,x2,s3)→(x1,x2,x3)→(s1,x2,x3)<br />
<br />
Zmienna x3 wchodzi do bazy w „Tablicy 4”. Do tego momentu kolumna x3 nie wpływa na resztę tablicy (poza oczywiście uwzględnieniem w wartości funkcji celu). Wtedy wyliczana jest wartość x3 przez podzielenie ograniczenia (b[2]) przez współczynnik (x3[2]).<br />
<br />
Gdyby jednak w tablicy pojawiła się liczba 1 w polu x3[1] - wtedy w miejsce x1+2*x2<9 mielibyśmy x1+2*x2+x3<9. Wtedy przy redukcji kolumny x2 – odpowiadającej wierszowi z wstawioną jedynką – zostanie ona „przeliczona” na wartości 0,2 i 0,4 (Tablica 3, wiersz 0 i 1) – co w tablicy 4 skutkuje zmniejszeniem b[0] i b[1] w tablicy 4 (odpowiednio 2*0,2 oraz 2*0,4).<br />
{| class="wikitable"<br />
| colspan="7" |Tablica 1<br />
|<br />
|<br />
|-<br />
|<br />
|'''x1'''<br />
|'''x2'''<br />
|'''x3'''<br />
|'''s1'''<br />
|'''s2'''<br />
|'''S3'''<br />
|'''b'''<br />
|'''min. dla X1'''<br />
|-<br />
|0<br />
|2,00<br />
| -1,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''4,00'''<br />
|2,00<br />
|-<br />
|1<br />
|1,00<br />
|2,00<br />
|1,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|9,00<br />
|9,00<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|3,00<br />
|0,00<br />
|'''0,00'''<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|2,00<br />
|5,00<br />
|5,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[0][0] – czyli 2<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|'''0,00'''<br />
|'''0,50'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''2,00'''<br />
|<br />
|-<br />
|Tablica 2<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|dla x2<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|0,00<br />
|0,50<br />
|0,00<br />
|0,00<br />
|2,00<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''2,50'''<br />
|1,00<br />
| -0,50<br />
|'''1,00'''<br />
|0,00<br />
|7,00<br />
|2,80<br />
|-<br />
|2<br />
|0,00<br />
|'''0,00'''<br />
|3,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|'''6,00'''<br />
|5,00<br />
| -1,00<br />
|0,00<br />
|0,00<br />
| -4,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][1] – czyli -2.5<br />
|<br />
|-<br />
|'''1'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,40'''<br />
|'''-0,20'''<br />
|'''0,40'''<br />
|'''0,00'''<br />
|'''2,80'''<br />
|<br />
|-<br />
|Tablica 3<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|dla x3<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,20<br />
|0,40<br />
|0,20<br />
|0,00<br />
|3,40<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,40<br />
| -0,20<br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''3,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|2,00<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|2,60<br />
|0,20<br />
| -2,40<br />
|0,00<br />
| -20,80<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[2][2] – czyli 3<br />
|<br />
|-<br />
|'''2'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''0,33'''<br />
|'''2,00'''<br />
|<br />
|-<br />
|Tablica 4<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|<br />
|dla s1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|'''0,40'''<br />
|0,20<br />
| -0,07<br />
|3,00<br />
|7,50<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
| -0,20<br />
|0,40<br />
| -0,13<br />
|2,00<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,20<br />
| -2,40<br />
| -0,87<br />
| -26,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][2] – czyli 0,4<br />
|<br />
|-<br />
|2<br />
|'''2,50'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,50'''<br />
|'''-0,17'''<br />
|'''7,50'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 5<br />
|<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,50<br />
| -0,17<br />
|7,50<br />
|<br />
|-<br />
|1<br />
|0,50<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,50<br />
| -0,17<br />
|3,50<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
| -0,50<br />
|0,00<br />
|0,00<br />
|0,00<br />
| -2,50<br />
| -0,83<br />
| -27,50<br />
|<br />
|}<br />
To zmniejszenie (b[0], b[1]) należy interpretować jako wyliczenie wpływu x3 na x1 i x2 we wspomnianej wyżej nieruchomości (wiersz 1). Jak to policzylibyśmy bez tablicy? Przyjmując x1+2*x2+x3 = 9 (wiersz 1) i x3=2 (6/2 - wiersz 2). Jeśli w ostatecznym wyniku x1=0, to x2=(9-2)/2 =3.5. Czyli dokładnie tyle, ile wylicza algorytm.<br />
[[Plik:Simplex3.ods|mały]]</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Plik:Simplex3.ods&diff=165Plik:Simplex3.ods2022-09-29T22:14:35Z<p>Admin: </p>
<hr />
<div>Przykład z analizy w arkuszu kalkulacyjnym.</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=164Algorytm Simplex2022-09-29T22:07:56Z<p>Admin: /* Przykładowa implementacja */</p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy rozwiązywania układów równań i nierówności liniowych.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowego rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
b = [100, -10]<br />
c = [3,4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej<ref>Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe” https://www.snopes.com/fact-check/the-unsolvable-math-problem/</ref>: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z: wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di: xi ≥ di, wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
----Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie współczynniki funkcji celu [c] są mniejsze lub równe zeru (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: skoro wszystkie wartości zmiennych decyzyjnych X są większe lub równe zeru, to jeśli i-ty element [c] (c[i]) jest większy od zera, zwiększenie współrzędnej i (x[i]>0) powoduje zwiększenie funkcji celu.<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były mniejsze lub równe zeru (przy szukaniu maksimum).<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1). (Na temat wyboru wiersza i kolumn będzie jeszcze mowa poniżej).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zmienione – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą mniejsze lub równe zeru, albo nie uda się znaleźć przekształcenia dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
'''Uwaga! Wartości zmiennych w ostatniej kolumnie dotyczą zmiennych bazowych. Jeśli zmienna decyzyjna nie jest obecna w bazie - oznacza to, że w rozwiązaniu jej wartość wynosi zero (0).'''<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” ( https://www.mimuw.edu.pl/~oskar/lecture_13.pdf ), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Przykładowa implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
===== Analiza działania algorytmu =====<br />
Dla tablicy z jedną zmienną decyzyjną x1 i jedną zmienną luzu (x2) wartość funkcji celu będzie wynosić (x1/x1 – z dzielenia wiersza przez x1, a następnie odejmowanie wiersza):<br />
<br />
z = 0-b1*c1*x1/x1<br />
<br />
czyli (zgodnie z oczekiwaniem):<br />
<br />
z=-b1*c1<br />
<br />
Przykład:<br />
<br />
<br />
Zauważmy, że jeśli c1 byłoby <0 – zadanie nie miałoby rozwiązania dla liczb dodatnich.<br />
<br />
Uwaga: Teoretycznie funkcja celu może zawierać dodatnie i ujemne współczynniki. Jednak algorytm Simplex może nie znaleźć ekstremem dla takich danych. Na szczęście w praktyce sytuacji w której pojawiają się ujemne współczynniki raczej się nie spotyka.<br />
<br />
Weźmy teraz pod uwagę dowolną tablicę Simplex w której została do zredukowania jedna kolumna ze zmienną decyzyjną. Na przykład odpowiadająca nierówności 2*x3<=3, oraz czynnikowi x3*4 w funkcji celu (kolumna x3, wiersz 2):<br />
<br />
Wykonanie redukcji zmienia wynik funkcji celu o b[2] podzielone przez x3[2] i pomnożone przez c z kolumny x3 (c[2]). Czyli najpierw wyliczamy ile co najwyżej może wynosić x3, a następnie odejmowana jest ta wartość od wyniku funkcji celu (przy liczeniu maksimum wynik jest uzyskiwany ze znakiem minus), po przemnożeniu przez odpowiedni współczynnik (c[2] – czyli 4).<br />
<br />
Czyli redukcja działa dokładnie tak, jakbyśmy to zrobili bez automatu. Tak samo algorytm Simplex zadziałałby, gdyby dodać kolumnę z jedną wartością dla dowolnej wielkości tablicy.<br />
<br />
Zastanówmy się na koniec – co się stanie, jeśli dodana kolumna x3 będzie zawierać wartości różne od zera 0 w więcej niż jednym wierszu. Prześledźmy zmiany tablicy od samego początku:<br />
{| class="wikitable"<br />
| colspan="8" |Tablica 1<br />
|<br />
|-<br />
|<br />
|'''x1'''<br />
|'''x2'''<br />
|'''x3'''<br />
|'''s1'''<br />
|'''s2'''<br />
|'''S3'''<br />
|'''b'''<br />
|'''min. dla X1'''<br />
|-<br />
|0<br />
|2,00<br />
|<nowiki>-1,00</nowiki><br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''4,00'''<br />
|2,00<br />
|-<br />
|1<br />
|1,00<br />
|2,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|'''0,00'''<br />
|9,00<br />
|9,00<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|3,00<br />
|0,00<br />
|'''0,00'''<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|2,00<br />
|5,00<br />
|5,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,00<br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[0][0] – czyli 2<br />
|<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|'''0,00'''<br />
|'''0,50'''<br />
|'''0,00'''<br />
|<br />
|'''2,00'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 2<br />
|dla x2<br />
|-<br />
|0<br />
|'''1,00'''<br />
|'''-0,50'''<br />
|0,00<br />
|0,50<br />
|0,00<br />
|0,00<br />
|2,00<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''2,50'''<br />
|0,00<br />
|<nowiki>-0,50</nowiki><br />
|'''1,00'''<br />
|0,00<br />
|7,00<br />
|2,80<br />
|-<br />
|2<br />
|0,00<br />
|'''0,00'''<br />
|3,00<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|'''6,00'''<br />
|5,00<br />
|<nowiki>-1,00</nowiki><br />
|0,00<br />
|0,00<br />
|<nowiki>-4,00</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][1] – czyli -2.5<br />
|<br />
|-<br />
|'''1'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''-0,20'''<br />
|'''0,40'''<br />
|'''0,00'''<br />
|'''2,80'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 3<br />
|dla x3<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,40<br />
|0,20<br />
|0,00<br />
|3,40<br />
|<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|<nowiki>-0,20</nowiki><br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''3,00'''<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|6,00<br />
|2,00<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|5,00<br />
|0,20<br />
|<nowiki>-2,40</nowiki><br />
|0,00<br />
|<nowiki>-20,80</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 0 podzielony przez a[2][2] – czyli 3<br />
|<br />
|-<br />
|'''2'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''1,00'''<br />
|'''0,00'''<br />
|'''0,00'''<br />
|'''0,33'''<br />
|'''2,00'''<br />
|<br />
|-<br />
| colspan="8" |Tablica 4<br />
|dla s1<br />
|-<br />
|0<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|'''0,40'''<br />
|0,20<br />
|0,00<br />
|3,40<br />
|8,50<br />
|-<br />
|1<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|<nowiki>-0,20</nowiki><br />
|0,40<br />
|0,00<br />
|2,80<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|0,00<br />
|0,00<br />
|0,00<br />
|0,20<br />
|<nowiki>-2,40</nowiki><br />
|<nowiki>-1,67</nowiki><br />
|<nowiki>-30,80</nowiki><br />
|<br />
|-<br />
|<br />
| colspan="7" |Wiersz 1 podzielony przez a[1][2] – czyli 0,4<br />
|<br />
|-<br />
|2<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
|0,00<br />
|8,50<br />
|<br />
|-<br />
| colspan="8" |Tablica 5<br />
|<br />
|-<br />
|0<br />
|2,50<br />
|0,00<br />
|0,00<br />
|1,00<br />
|0,50<br />
|0,00<br />
|8,50<br />
|<br />
|-<br />
|1<br />
|0,50<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,50<br />
|0,00<br />
|4,50<br />
|<br />
|-<br />
|2<br />
|0,00<br />
|0,00<br />
|'''1,00'''<br />
|0,00<br />
|0,00<br />
|0,33<br />
|2,00<br />
|<br />
|-<br />
|s<br />
|<nowiki>-0,50</nowiki><br />
|0,00<br />
|0,00<br />
|0,00<br />
|<nowiki>-2,50</nowiki><br />
|<nowiki>-1,67</nowiki><br />
|<nowiki>-32,50</nowiki><br />
|<br />
|}<br />
Baza dla tego przykładu zmienia się następująco (s1,s2,s3) → (x1,s2,s3)→(x1,x2,s3)→(x1,x2,x3)→(s1,x2,x3)<br />
<br />
Zmienna x3 wchodzi do bazy w „Tablicy 4”. Do tego momentu kolumna x3 nie wpływa na resztę tablicy (poza oczywiście uwzględnieniem w wartości funkcji celu). Wtedy wyliczana jest wartość x3 przez podzielenie ograniczenia (b[2]) przez współczynnik (x3[2]).<br />
<br />
Gdyby jednak w tablicy pojawiła się liczba 1 w polu x3[1] - wtedy w miejsce x1+2*x2<9 mielibyśmy x1+2*x2+x3<9. Wtedy przy redukcji kolumny x2 – odpowiadającej wierszowi z wstawioną jedynką – zostanie ona „przeliczona” na wartości 0,2 i 0,4 (Tablica 3, wiersz 0 i 1) – co w tablicy 4 skutkuje zmniejszeniem b[0] i b[1] w tablicy 4 (odpowiednio 2*0,2 oraz 2*0,4).<br />
<br />
To zmniejszenie (b[0], b[1]) należy interpretować jako wyliczenie wpływu x3 na x1 i x2 we wspomnianej wyżej nieruchomości (wiersz 1). Jak to policzylibyśmy bez tablicy? Przyjmując x1+2*x2+x3 = 9 (wiersz 1) i x3=2 (6/2 - wiersz 2). Jeśli w ostatecznym wyniku x1=0, to x2=(9-2)/2 =3.5. Czyli dokładnie tyle, ile wylicza algorytm.</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Logika_i_instrukcje_warunkowe&diff=163Logika i instrukcje warunkowe2022-09-29T01:13:13Z<p>Admin: </p>
<hr />
<div>Informacje o module:<br />
<br />
* Poziom: Podstawowy<br />
* Profil: Dla wszystkich<br />
<br />
<br />
<br />
== Czy komputery się mylą? ==<br />
<br />
Często słyszymy o spektakularnych skutkach błędów oprogramowania. Ostatnio mieliśmy w USA kilka wypadków (w tym jeden śmiertelny) spowodowanych przez programy, którym powierzono prowadzenie samochodów bez kierowcy. Bardziej poprawne jest mówienie o błędach programistów – ostatnio raczej o tym, że nie wszystko zostało w programach uwzględnione. Tak było z samochodem, który „nie zobaczył” naczepy, gdyż miała ona stosunkowo duży prześwit pod spodem, a czujniki były oślepione słońcem. Pomijając awarie sprzętowe, '''komputery działają bezbłędnie'''!<br />
<br />
W pewnym sensie bezbłędne są także programy – inaczej nie przeszłyby przez kompilację. Nie zawsze robią to czego oczekujemy, ale zawsze to co programista zakodował!<br />
<br />
Co zatem znaczy, że program jest poprawny?<br />
<br />
Dla programisty znaczy to, że:<br />
# Jest napisany zgodnie z regułami określonymi w specyfikacji języka programowania.<br />
# Jest sensowny – czyli inaczej mówiąc napisany precyzyjnie. Nie odwołuje się do nie istniejących danych i kończy swe działanie w rozsądnym czasie.<br />
# Wykonuje dokładnie to, co zamierzył programista (lub zleceniodawca).<br />
<br />
<br />
<br />
Ten ostatni punkt – choć najważniejszy – jest przedmiotem zainteresowania inżynierii oprogramowania.<br />
<br />
Punkt pierwszy – czyli kodowanie zgodnie z regułami wymuszają na nas translatory (gdy translacja prowadzi do uzyskani kodu maszynowego, translator nazywamy kompilatorem) lub interpretery (czyli translatory uruchamiane w procesie uruchamiania programu).<br />
<br />
Pisanie programów sensownych jest natomiast sztuką inżynierską, której musimy się nauczyć.<br />
<br />
Program musi bardzo precyzyjnie opisać działanie komputera. To jest zasadnicza różnica wobec posługiwania si językiem naturalnym (w naszym wypadku polskim). Gdy komuś powiemy, że coś jedzie drogą – to każdy się domyśli, że chodzi o pojazd, a w razie potrzeby – sprawdzi co dokładnie. Gdybyśmy taką nieokreśloną instrukcję zawarli w komputerze – w najlepszym razie dostaniemy komunikat w rodzaju „nie rozumiem”. <br />
<br />
Poprawne wypowiedzi dotyczące rzeczywistości muszą mówić o tym co jest naprawdę. Czyli poprawny = prawdziwy. W komputerze „poprawność” oznacza, że program działa zawsze tak samo i na dodatek zgodnie ze specyfikacją.<br />
<br />
Brak sprzeczności oraz determinizm w działaniu wynikają z samej istoty działania komputera. '''Determinizm''' oznacza, że dla danych warunków efekt zawsze będzie taki sam. Jeśli komputer nie ulega awarii – to w tym sensie jego obliczenia zawsze są prawdziwe. Jednak źle napisany program może sprawić, że „dane warunki” nie zawsze będą takie same – w szczególności mogą odbiegać od założeń. Jeśli na przykład program odwołuje się do zmiennej, której wartości wcześniej nie zainicjował – to otrzymana wartość zależy od historii działania komputera i można ja uznać za losową.<br />
<br />
Także sprzeczność jest łatwa do wprowadzenia. Weźmy na przykład fragment programu:<br />
<br />
<pre><br />
jeśli a>=b to napisz(‘a>b’);<br />
jeśli a<=b to napisz(‘a<b’);<br />
</pre><br />
<br />
Program dla a=b napisze, że '''a>b''' i '''a<b''' równocześnie. Takie błędy (użycie złego znaku porównania) są bardzo często spotykane. <br />
<br />
Jak to ma się do tezy, że w komputerze nie może być sprzeczności? Na poziomie kodu maszynowego nie ma żadnej sprzeczności w działaniu. Komputer wypisuje w określonej sytuacji określony wynik on nawet „nie wie”, że drukowany napis ‘a>b’ zawiera wyrażenie logiczne (dla niego to tylko dana – ciąg bitów). Warto w tym miejscu przypomnieć rozróżnienie języka i metajęzyka (moduł 2 w pierwszej części). <br />
<br />
Najczęstszym jednak źródłem uzyskiwania nieoczekiwanych wyników są błędne dane, jakie są przedmiotem obliczeń. Informatycy sformułowali nawet sentencję określającą tą sytuację:<br />
<br />
<div style="text-align:center;">ŚMIECI NA WEJŚCIU = ŚMIECI NA WYJŚCIU</div><br />
<br />
To określenie dotyczy także programów, które są daną wejściową dla translatorów. Chcąc uzyskać poprawny program, musimy samemu zachować precyzje i stosować zasady logiki.<br />
<br />
== Problem złożoności ==<br />
<br />
Pamięć komputera zawiera bity. Co to dokładnie znaczy? Bit to najmniejsza porcja informacji – wybór jednego z dwóch elementów. Najczęściej wybieramy między zerem a jedynką (tak jest w komputerach). Odpowiada to oczywiście wartościom fałsz (zero) i prawda (jeden) w logice.<br />
<br />
Zaprojektujmy sobie najprostszy komputer, który komputer, który liczy jedynie sumy wyłączne (XOR) z sygnałów podanych na wejściu. Suma wyłączna (A XOR B) czyli inaczej „albo albo” daje na wynik prawdę, gdy prawda jest na wejściu A albo na wyjściu B, ale nie na obu. Natomiast iloczyn (A i B, A AND B) daje prawdę, gdy zarówno A jak i B mają wartość prawda.<br />
<br />
Odpowiedni przykład funkcji przejścia można przetestować na stronie [http://logic.ly/demo/ http://logic.ly/demo/] (trzeba wybrać przykład opisany jako „1-Bit Full Adder”):<br />
<br />
[[Plik:Sumator.jpg]]<br />
<br />
Zmieniając przyciski A i B możemy obserwować co dzieje się na wyjściu – czy pali się lampka Sum. W tym przykładzie mamy dodatkowo sygnały przeniesienia (Carry IN na wejściu i Carry OUT na wyjściu). Umożliwiają one połączenie kaskadowo tych sumatorów dla uzyskania sumy z więcej niż dwóch wejść (wynik Carry OUT łączymy do Carry IN z następnej pary).<br />
<br />
Żeby można było mówić o komputerze, a nie tylko o układzie elektronicznym, poszczególnym elementom wejścia i wyjścia muszą odpowiadać komórki pamięci, a wynik obliczeń powinien zostać zapisany w komórkach odpowiadających wyjściu w takt zegara odliczającego instrukcje. <br />
<br />
W tak prostym przykładzie mamy 5 jednobitowych komórek pamięci i 5 układów elektronicznych (bramek logicznych). <br />
<br />
Jaka zatem powinna być złożoność komputera przetwarzającego informację o złożoności liczonej w milionach bitów? Ogromna. Prostszym jest pytanie postawione od drugiej strony: ile maksymalnie bitów zmieniają za jednym razem współczesne komputery? Jeśli słyszymy, że mamy procesor 64-bitowy, to oznacza właśnie tyle, że naraz może odczytać lub zapisać 64 bity. Większą ilość komórek pamięci można zmienić w wielu kolejnych taktach zegara. Niektóre obliczenia są tak złożone, że takie sekwencyjne (krok po kroku) obliczenia nie skończyłyby się nawet za tysiąc lat.<br />
<br />
== Instrukcje warunkowe ==<br />
<br />
Nie tylko ograniczenia sprzętowe (budowa komputera) sprawiają, że z zasady obliczenia w komputerze odbywają się w sposób sekwencyjny: instrukcja po instrukcji. Człowiek także nie jest w stanie myśleć równolegle (podobno kobiety mają większą podzielność uwagi – ale to zrównoleglenie też nie jest wielkie ;-)).<br />
<br />
Jakie instrukcje są nam potrzebne, aby zapisać dowolny proces obliczeniowy? Okazuje się, że wyliczaniem wartości wyrażeń arytmetycznych i logicznych potrzebujemy jedynie instrukcji warunkowych (wykonaj coś pod warunkiem) oraz mechanizmu pozwalającego przeglądać zbiór danych. Takim mechanizmem są tak zwane pętle (choć może to też być też tak zwany mechanizm rezolucji – dla bardzo zaawansowanych: [https://pl.wikipedia.org/wiki/Rezolucja_(matematyka https://pl.wikipedia.org/wiki/Rezolucja_(matematyka]), [https://pl.wikipedia.org/wiki/Prolog_(język_programowania https://pl.wikipedia.org/wiki/Prolog_(j%C4%99zyk_programowania])). <br />
<br />
Dla przykładu z sumą wyłączną ciąg instrukcji wyliczającej XOR dla 4 danych wejściowych (A,B,C,D) może wyglądać następująco:<br />
<br />
<pre><br />
jeżeli (A XOR B) to<br />
jeżeli (C XOR D) to<br />
napisz(‘prawda’);<br />
</pre><br />
<br />
Proszę zwrócić uwagę na tak zwane wcięcia (odstępy z lewej) – powszechnie stosowane dla większej czytelności programów.<br />
<br />
Instrukcje warunkowe są podstawą programowania. Można wykazać, że do takiego zbioru instrukcji daje się sprowadzić wszystkie wyrażenia logiczne! Istnieją języki programowania, które składają się wyłącznie z takich warunkowych instrukcji. Nie ma zaś żadnego bardziej złożonego języka programowania, który nie zawierałby takich instrukcji.<br />
<br />
'''Logiczne myślenie – uwaga metodologiczna: '''<br />
<br />
Zbudowanie przez&nbsp;[http://www.matematycy.interklasa.pl/biografie/matematyk.php?str=boole Boole'a]&nbsp;rachunku logicznego na wzór algebry było bardzo ważnym odkryciem. Wpłynęło jednak na to, że najbardziej naturalną umiejętność człowieka postrzegamy dzisiaj jako rzecz trudną. Nauki logiki nie powinno się zaczynać od operowania na symbolach i wyrażeniach, ale od prostych pytań w rodzaju: co zrobić, aby osiągnąć jakiś efekt. To mogą być proste historie (na przykład: aby włączyć notebooka trzeba podnieść klapę i nacisnąć przycisk, ale jeśli bateria jest rozładowana, musimy włączyć go dodatkowo do prądu). Po dojściu do końca w analizie postawionego problemu, można zapisać działania w odpowiedniej kolejności, uzyskując prosty algorytm.<br />
<br />
<br />
'''Zadanie''': Napisać program w postaci instrukcji warunkowych JEŚLI, wyliczający ilość dni dowolnego miesiąca w dowolnym roku<br />
<br />
html:<br />
<syntaxhighlight lang="html" line="1" ><br />
<form><br />
rok= <input id="rok" type=text value="2016"><br /><br />
miesiąc= <input id="mies" type=text value="01"><br /><br />
<input type="button" onclick="javascript:licz()" value="licz"/><br ><br />
dni= <input id='dni' type=text value="00" readonly/><br /><br />
</form><br />
</syntaxhighlight><br />
<br />
Javascript:<br />
<syntaxhighlight lang="javascript" line="1" ><br />
function licz(){<br />
rok=document.getElementById('rok').value;<br />
mies=document.getElementById('mies').value;<br />
var dni='31';<br />
if (mies=='02') {<br />
dni='28';<br />
if (rok==2016) { dni='29'; }<br />
}<br />
if (mies=='04') { dni='30'; }<br />
if (mies=='06') { dni='30'; }<br />
if (mies=='09') { dni='30'; }<br />
if (mies=='01') { dni='30'; }<br />
document.getElementById('dni').value=dni;<br />
}<br />
</syntaxhighlight><br />
<br />
<br />
Implementacja w JavaScript: [http://codepen.io/pen/ http://codepen.io/pen/] lub [https://jsfiddle.net/ https://jsfiddle.net/] lub [http://jsbin.com/ http://jsbin.com/]<br />
(dla innych języków: [https://repl.it/ https://repl.it]).<br />
<br />
<br />
<br />
<span style="color:#006600;">Zadanie domowe: zrobić program dla dowolnych lat.</span><br />
<br />
== Podsumowanie ==<br />
<br />
* Komputery działają w sposób deterministyczny – czyli dla danych warunków efekt zawsze będzie taki sam.<br />
* Poprawność działania komputera nie gwarantuje tego, że obliczenia są wykonywane zgodnie z naszymi oczekiwaniami. Aby to zapewnić, program dostarczany do translatora musi być napisany zgodnie z zasadami logiki.<br />
* Teoretycznie do tworzenia dowolnych programów wystarczy, by w języku programowania był zawarty interpreter wyrażeń arytmetycznych i logicznych, instrukcje warunkowe i mechanizm przeglądania zbiorów danych.</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Proste_sortowanie_tablic&diff=162Proste sortowanie tablic2022-09-28T23:42:11Z<p>Admin: Utworzono nową stronę "Sortowanie przez proste wybieranie jest chyba najprostszym algorytmem sortowania. Tablicę dzielimy na dwie części: lewa posortowana i prawa nie posortowana. Wyszukujemy w nie posortowanej części najmniejszy element i zamieniamy z pierwszym elementem nie posortowanej części. Dzięki temu - możemy zwiększyć obszar posortowany o kolejny (ten wybrany) element. Na poniższym rysunku pionowa strzałka czarna wskazuje na pierwszy element nie posortowanej częśc…"</p>
<hr />
<div>Sortowanie przez proste wybieranie jest chyba najprostszym algorytmem sortowania. Tablicę dzielimy na dwie części: lewa posortowana i prawa nie posortowana. Wyszukujemy w nie posortowanej części najmniejszy element i zamieniamy z pierwszym elementem nie posortowanej części. Dzięki temu - możemy zwiększyć obszar posortowany o kolejny (ten wybrany) element. Na poniższym rysunku pionowa strzałka czarna wskazuje na pierwszy element nie posortowanej części, a czerwona - na najmniejszy element tej części. Łuk łączy miejsca zamiany:<br />
<br />
[[Plik:Sortowanie-wybieranie.png|alt=Sortowanie przez proste wybieranie]]<br />
<br />
<br />
Sortowanie przez proste wstawianie jest podobne do układania kart do gry branych ze stołu w kolejności ich wielkości:<br />
<br />
[[Plik:Sortowanie kart.png]]<br />
<br />
źródło rysunku: Cormen Thomas H., Leiserson Charles E., Rivest Ronald L, Clifford Stein "Wprowadzenie do algorytmów"<br />
<br />
Algorytm sortowania tabeli przez proste wstawianie polega on na tym, że tabelę dzielimy na dwie części: elementy już posortowane (jak karty w ręce) - to lewa część tabeli. Elementy pozostałe (jak karty na stole) - to prawa część tabeli. Bierzemy kolejne elementy z pozostałych (prawej części) i wstawiamy do lewej tak, by zachować sortowanie.<br />
<br />
Dla tabeli zawierającej liczby: <code>9,12,7,11,8,3,</code> algorytm zadziała następująco:<br />
<br />
[[Plik:Sortowanie-wstawianie.png|alt=Sortowanie przez proste wstawianie]]</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Plik:Sortowanie-wstawianie.png&diff=161Plik:Sortowanie-wstawianie.png2022-09-28T23:38:52Z<p>Admin: </p>
<hr />
<div>Sortowanie przez proste wstawianie</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Plik:Sortowanie_kart.png&diff=160Plik:Sortowanie kart.png2022-09-28T23:36:15Z<p>Admin: </p>
<hr />
<div>źródło rysunku: Cormen Thomas H., Leiserson Charles E., Rivest Ronald L, Clifford Stein "Wprowadzenie do algorytmów"</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Plik:Sortowanie-wybieranie.png&diff=159Plik:Sortowanie-wybieranie.png2022-09-28T23:34:11Z<p>Admin: </p>
<hr />
<div>Sortowanie przez proste wybieranie</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytmy&diff=158Algorytmy2022-09-28T23:30:54Z<p>Admin: </p>
<hr />
<div>* [[Proste sortowanie tablic]]<br />
* [[Algorytm Simplex]]</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=157Algorytm Simplex2022-09-28T22:52:10Z<p>Admin: /* Algorytm Simplex */</p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy rozwiązywania układów równań i nierówności liniowych.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowego rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
b = [100, -10]<br />
c = [3,4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej<ref>Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe” https://www.snopes.com/fact-check/the-unsolvable-math-problem/</ref>: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z: wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di: xi ≥ di, wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
----Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie współczynniki funkcji celu [c] są mniejsze lub równe zeru (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: skoro wszystkie wartości zmiennych decyzyjnych X są większe lub równe zeru, to jeśli i-ty element [c] (c[i]) jest większy od zera, zwiększenie współrzędnej i (x[i]>0) powoduje zwiększenie funkcji celu.<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były mniejsze lub równe zeru (przy szukaniu maksimum).<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1). (Na temat wyboru wiersza i kolumn będzie jeszcze mowa poniżej).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zmienione – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą mniejsze lub równe zeru, albo nie uda się znaleźć przekształcenia dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
'''Uwaga! Wartości zmiennych w ostatniej kolumnie dotyczą zmiennych bazowych. Jeśli zmienna decyzyjna nie jest obecna w bazie - oznacza to, że w rozwiązaniu jej wartość wynosi zero (0).'''<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” ( https://www.mimuw.edu.pl/~oskar/lecture_13.pdf ), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Przykładowa implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=154Algorytm Simplex2022-09-27T00:53:29Z<p>Admin: /* Postać standardowa problemu */</p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowego rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
b = [100, -10]<br />
c = [3,4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej<ref>Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe” https://www.snopes.com/fact-check/the-unsolvable-math-problem/</ref>: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z: wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di: xi ≥ di, wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
----Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie współczynniki funkcji celu [c] są mniejsze lub równe zeru (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: skoro wszystkie wartości zmiennych decyzyjnych X są większe lub równe zeru, to jeśli i-ty element [c] (c[i]) jest większy od zera, zwiększenie współrzędnej i (x[i]>0) powoduje zwiększenie funkcji celu.<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były mniejsze lub równe zeru (przy szukaniu maksimum).<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1). (Na temat wyboru wiersza i kolumn będzie jeszcze mowa poniżej).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zmienione – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą mniejsze lub równe zeru, albo nie uda się znaleźć przekształcenia dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” ( https://www.mimuw.edu.pl/~oskar/lecture_13.pdf ), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Przykładowa implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=153Algorytm Simplex2022-09-27T00:43:15Z<p>Admin: /* Równania i nierówności liniowe */</p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowego rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
b = [100, -10]<br />
c = [3,4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej<ref>Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe” https://www.snopes.com/fact-check/the-unsolvable-math-problem/</ref>: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1). (Na temat wyboru wiersza i kolumn będzie jeszcze mowa poniżej).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zmienione – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
----------------------<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” ( https://www.mimuw.edu.pl/~oskar/lecture_13.pdf ), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Przykładowa implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Matematyka_obiektowa&diff=152Matematyka obiektowa2022-09-25T18:39:27Z<p>Admin: przypisy</p>
<hr />
<div>Często słyszymy, że podstawą informatyki jest matematyka. Tak – ale nie jest to taka matematyka, jaką męczą dzieci w szkole. W przeciwieństwie do matematyki, informatyka w całej swej historii dąży do jak najprostszego i zrozumiałego opisu tworzonych systemów. Nie ma też mowy o jakichkolwiek niedopowiedzeniach. Ma być jasno i precyzyjnie. Dlatego kreowany przez programistów świat wirtualny jest łatwiejszy do zrozumienia niż świat matematycznych abstrakcji.<br />
<br />
Może więc należałoby sytuację odwrócić, traktując informatykę jako klucz do zrozumienia matematyki?<br />
<br />
=== Czy matematyka jest trudna? ===<br />
Niektóre teorie czy twierdzenia matematyczne są rzeczywiście bardzo trudne. Jednak na podstawowym poziomie matematyka powinna być bez większych problemów przyswajana przez każdego rozgarniętego człowieka. Dlaczego tak się nie dzieje? Jedną z przyczyn jest przyjęcie przez matematyków zasady „nieoglądowości” – czyli braku odwołań do pojęć jakich używamy w odniesieniu do postrzeganych rzeczy.<br />
<br />
Jeszcze w XVII wieku powszechnie uważano, że nasz ogląd świata jest źródłem pojęć z których budujemy sądy matematyczne<ref>Zob. Jerzy Dadaczyński „''Filozofia matematyki Immanuela. Kanta jako punkt odniesienia filozofii matematyki stowarzyszonych z klasycznymi kierunkami badań podstaw matematyki''” <nowiki>[https://bazhum.muzhp.pl/media/files/Slaskie_Studia_Historyczno_Teologiczne/Slaskie_Studia_Historyczno_Teologiczne-r1999-t32/Slaskie_Studia_Historyczno_Teologiczne-r1999-t32-s22-36/Slaskie_Studia_Historyczno_Teologiczne-r1999-t32-s22-36.pdf ]</nowiki>: ''Wymóg nieogladowości dowodów, zawarty we współczesnej metodologii matematyki, który zadomowił się tam ostatecznie od czasów Hilberta, wydaje się oczywisty i niepodważalny. Dziwne może nawet wydać się przypuszczenie, że kiedykolwiek można było wypowiedzieć twierdzenie przeciwne. Był jednak taki okres w dziejach metodologii matematyki − a precyzyjniej: w dziejach filozofii matematyki − kiedy twierdzono, że dowodząc tez matematycznych, nie tylko można, ale wręcz koniecznie trzeba odwoływać się do pewnych form oglądowości, do pewnego rodzaju przedstawień naocznych. Twórcą tego poglądu był Immanuel Kant''.</ref>. Oczyszczanie matematyki z odniesień do rzeczywistości i naszych wyobrażeń wiązało się z dążeniem do precyzji i absolutnej pewności. Proces ten został domknięty przez Davida Hilberta<ref>https://encyklopedia.pwn.pl/haslo/Hilbert-David;3911678.html</ref>, który w celu wykazania niesprzeczności matematyki postulował jej aksjomatyzację – czyli przyjęcie, że każda teoria wynika logicznie z przyjętego zbioru aksjomatów<ref>Cel Hilberta (matematyka z wykazaną zupełnością i niesprzecznością) nie jest osiągalny.</ref>. Ostatecznie zwyciężył pogląd, że język matematyki jest całkowicie abstrakcyjny<ref>Jak zauważa Jerzy Daczyński (dz.cyt.): „''współczesne stanowisko można by za pomocą terminologii Kantowskiej oddać następująco: matematyka jest wiedzą czysto pojęciową, w żadnym dowodzie nie można się odwoływać do jakichkolwiek wyobrażeń (empirycznych czy apriorycznych)''”. Czyli zdania matematyki nie są – jak uważał Kant – sądami syntetycznymi apriori, tylko sądami analitycznymi!</ref>. Nawet liczby naturalne definiuje się obecnie w oparciu o abstrakcyjną teorię mnogości.<br />
<br />
<br />
Ta sytuacja ma ogromne znaczenie w nauczaniu matematyki. Nauka matematyki to poznawanie świata abstrakcji, co stanowi poważną barierę dla wielu jej adeptów. Na dodatek archaiczna maniera matematyków każe im używać języka naszpikowanego trudnymi do zapamięta symbolami jednoliterowymi (kto dzisiaj zna alfabet grecki?).<br />
<br />
=== Matematyka z informatyką ===<br />
Matematycy posługiwali się odniesieniami do rzeczywistego świata, które okazały się zbędne na pewnym etapie rozwoju tej nauki. Do zobrazowania tej sytuacji można przywołać za Wittgensteinem metaforę drabiny. Matematycy wspinali się po jej szczeblach (z których każdy był bardziej abstrakcyjny), aż na poziom całkowitej abstrakcji. Po odrzuceniu drabiny mamy czystą matematykę. Tylko dlaczego osobom studiującym matematykę odmawia się użycia tej „drabiny”?<br />
<br />
Jest to tym bardziej dziwne, że matematycy w swych publikacjach wcale nie są tak pryncypialni. Weźmy na przykład elementarny tekst na temat „rachunku zdań”: http://wazniak.mimuw.edu.pl/index.php?title=Logika_i_teoria_mnogo%C5%9Bci/Wyk%C5%82ad_2:_Rachunek_zda%C5%84 . Próżno w nim szukać na przykład definicji używanego pojęcia „zmienna zdaniowa”. Intuicyjnie rozumiemy, że chodzi o symbol reprezentujący zdanie.<br />
<br />
Takie podejście ma zasadniczą wadę: autor zakłada, że czytelnik potrafi trafnie uchwycić znaczenie wprowadzonych pojęć (intuicyjnie, lub poprzez studiowanie innych publikacji). To może być założeniem błędnym.<br />
<br />
Połączenie nauki matematyki i programowania sprawia natomiast, że możemy zakładać zrozumienie odwołań do pojęć z dziedziny informatyki. Takie powiązanie matematyki z informatyką nie wiąże się z zagrożeniem, któremu miało zapobiec „oczyszczenie” matematyki z „obrazowości”. Komputery są deterministyczne, a zasada ich działanie daje się opisać przy pomocy elementarnej logiki. Nie ma więc mowy o tym, by powyższy związek był źródłem błędów.<br />
<br />
=== Uniwersalność matematyki ===<br />
Powyżej wspomniano o dwóch różnicach między informatyką i matematyką:<br />
<br />
1) silny związek informatyki ze światem rzeczywistym wobec dążenia matematyki do abstrakcji;<br />
<br />
2) język informatyki ma być możliwie najbardziej zrozumiały, czego nie oczekujemy od języka matematyki;<br />
<br />
Gdyby różnice między informatyką i matematyką sprowadzały się do takich „drobiazgów” – nie byłoby powodu traktować tych dziedzin jako odrębne (i pewnie z czasem nastąpiłoby „ujednolicenie”).<br />
<br />
Istnieją jednak różnice o wiele poważniejsze, które można uznać za fundamentalne.<br />
<br />
Porównajmy dwa objaśnienia algorytmu Simplex: matematyczne i informatyczne<ref>Marek Mika, „Teoretyczne podstawy programowania liniowego” (<nowiki>http://www.cs.put.poznan.pl/mmika/Teoretyczne%20podstawy%20programowania%20liniowego.pdf</nowiki> ).</ref>. Jednym z kluczowych pojęć jest w tym algorytmie wierzchołek wielościanu wielowymiarowego.<br />
<br />
Matematyczna definicja wierzchołka (punktu ekstremalnego zbioru wypukłego)<ref>Definicja przytoczona przez Wikipedię pochodzi z John B. Conway: „''A course in functional analysis''”.</ref>:<br />
<br />
''Punkt e ∈ K jest punktem ekstremalnym zbioru wypukłego K, gdy równość''<br />
<br />
''e = 𝜆𝐱 + (1 − 𝜆) y dla pewnych x,y ∈ K oraz 𝜆 ∈ [0,1] implikuje, że e = x lub e = y .''<br />
<br />
W tej definicji chodzi o to, że jeśli mamy jakiś odcinek (x,y) zawarty w zbiorze wypukłym, to wierzchołkiem może być jedynie jego początek lub koniec. Po tym objaśnieniu - chyba definicja staje się zrozumiała<ref>Wyjaśnienie wypukłości oraz przytoczonej definicji odcinka znajdziesz na blogu <nowiki>https://byc-matematykiem.pl/tajniki-interpolacji-czesc-1/</nowiki></ref>. Tyle, że w kontekście algorytmu Simplex mało użyteczna.<br />
<br />
Porównajmy z definicją wierzchołka sformułowaną przez informatyka<ref>[[Algorytm Simplex]]</ref>:<br />
<br />
''Ograniczenia [równania liniowe wielu zmiennych] definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”. W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń. Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi. .''<br />
<br />
Najważniejszą różnicą między tymi definicjami nie jest użycie jednoliterowych symboli.<br />
<br />
Definicja matematyczna w sposób dość typowy używa implikacji do zawężenia zbioru możliwości.<br />
<br />
Taka definicja jest bardziej uniwersalna, niż opis informatyka (‘jak to jest zrobione i co z tego wynika’). To wspaniale! Dzięki takiemu dążeniu do uniwersalności, wszystkie twierdzenia mogą znaleźć szersze zastosowanie! Tyle, że informatyka nie interesuje ogólne zastosowanie definicji, ale zastosowanie jej w objaśnieniu algorytmu który chce zaimplementować lub zastosować! Jego definicja zawiera własności wierzchołka, które po przyjęciu ogólniejszej definicji trzeba by dopiero udowodnić!<br />
<br />
Czy definicja informatyka jest mniej precyzyjna? Taki zarzut staje się bezprzedmiotowy, jeśli definicja zostanie wprost przełożona na działający poprawnie program. Świat komputera z takim programem jest lokalnym „uniwersum”, które możemy objaśniać poprzez zastosowania (świat realny) lub … matematykę! Informatyk może traktować matematykę tak jak elektronikę: są niezbędne, ale rzadko zachodzi potrzeba zgłębiania ich tajników.<br />
<br />
=== Matematyka obiektowa ===<br />
Współczesny świat budują inżynierowie, dla których – jak się słusznie uważa – matematyka jest podstawą. W szczególności dotyczy to informatyków. Matematyka we współczesnej formie stanowi jedną z barier w kształceniu odpowiedniej ilości programistów. Z drugiej strony – świat kreowany przez programistów jest trudno dostępny dla przeciętnego użytkownika informatycznych produktów. Tu także może pomóc podniesienie ogólnego poziomu znajomości matematyki z uwzględnieniem jej związków z informatyką.<br />
<br />
Nadzieję na zmianę tej sytuacji daje podjęcie powszechnej edukacji w zakresie programowania. Niestety wygląda na to, że zmieniono ten z założenia szlachetny przedmiot w naukę programu Scratch. Ten absurd jest już tak ugruntowany, że nawet trudno liczyć na zmianę.<br />
<br />
Z powyższej refleksji zrodziła się idea stworzenia „matematyki obiektowej”.<br />
<br />
Dlaczego „matematyka obiektowa”? Po co tworzyć nowe terminy, skoro istnieje „matematyka dyskretna”? Termin „matematyka dyskretna” określa zakres (dziedzinę) matematyki związanej z informatyką<ref>Matematyka dyskretna to nauka o strukturach matematycznych zawierających skończoną liczbę elementów. [Ryan T. White, Archana Tikayat Ray „Practical Discrete Mathematics”]</ref>. Matematyka obiektowa wprowadza język i system pojęć pomocnych w opisaniu i zrozumieniu tej dziedziny wiedzy.<br />
<br />
Abstrakcyjna idea obiektów jest łatwą do zrozumienia (przez analogie ze światem realnych obiektów). Współczesne języki programowania w większości mają charakter obiektowy. Można więc w nich tworzyć obiekty, które objaśniają matematyczne pojęcia i twierdzenia.<br />
<br />
Obiekty matematyczne są opisywane poprzez definicje związków i działań w nich zachodzących. By zrozumieć ten opis, nierzadko trzeba zgłębić bardziej elementarne teorie i zapamiętać stosowane oznaczenia. Tymczasem obiekty w programowaniu są opisywane w sposób umożliwiający ich natychmiastowe użycie. Do ich zrozumienia często wystarczą przykłady użycia.<br />
<br />
Zmiana terminologii wiąże się więc ze zmianą podejścia: zastępujemy teorię (jak to jest zbudowane) przez praktykę (jak tego użyć). O ile w odniesieniu do elementarnych zagadnień takie podejście jest tylko jednym z możliwych<ref>Alternatywne podejście: „Need for Equipping Student Teachers with Language of Mathematics” „''Znaczenie programu nauczania w budowaniu języka matematyki, który umożliwia uczącym się konstruowanie i przekazywanie wiedzy matematycznej, nie zostało docenione, mimo że od lat dyskutuje się o wyzwaniach pedagogicznych, przed którymi stają uczniowie w nauce matematyki. Nauka języka matematyki jest nie tylko cenna sama w sobie, ale także przydatna w zrozumieniu innych dziedzin wiedzy, zwłaszcza nauk ścisłych. Uważa się, że posługiwanie się narzędziami języka matematyki jest nawet pomocne w nauce języków potocznych, zwłaszcza w nauce gramatyki, rytmiki i wersyfikacji. Oczywiste jest, że rozumienie języka matematyki i jego specjalnych terminów tak płynnie, jak to możliwe, oprócz innych korzyści, uwalnia procesy poznawcze w uczącym się, aby móc podejmować bardziej przydatne czynności, w tym rozwiązywać problem. Dlatego ważne jest, aby programy kształcenia nauczycieli uwzględniały w nim elementy składowe lub elementy matematyki w taki sposób, aby struktura języka matematyki była zrozumiała dla uczniów. W artykule omówiono znaczenie języka matematyki, jego strukturę i znaczenie w kształceniu matematycznym. Sugeruje ponadto sposoby przekazywania nowicjuszom zrozumienia języka matematyki. Mając na uwadze znaczenie języka matematyki w nauczaniu uczenia się, w niniejszym opracowaniu rozważono również strategie, które można zastosować, aby wyposażyć przyszłych nauczycieli w umiejętności i kompetencje niezbędne do radzenia sobie z językiem matematyki”.''</ref>, to w przypadku zaawansowanych teorii pragmatyzm staje się często koniecznością (gdy chcemy z nich korzystać, ale nie mamy czasu na ich studiowanie).<br />
<br />
=== Semantyka matematyki (refleksja filozoficzna) ===<br />
Podejście obiektowe może być skuteczne zwłaszcza w matematyce dyskretnej. Czy w ten sposób można opisać całą matematykę?<br />
<br />
Najpierw należałoby wyjaśnić – co znaczy „opisać”. Możemy na przykład zrobić zdjęcie dowolnego tekstu czy rysunku i po zeskanowaniu wgrać do komputera. Drugą skrajnością są systemy / programy komputerowe, w których zaimplementowano reguły matematycznej teorii. Interesujące jest jedynie pytanie o tą drugą możliwość. Czyli pytanie - czy można matematykę zredukować do informatyki? Całą matematykę? Odpowiedź na tak postawione pytanie wiąże się z semantyką matematyki.<br />
<br />
Jeśli język matematyki jest całkowicie abstrakcyjny, to znaczenie jego zdań możemy ustalić wyłącznie przez odwołanie się do innych zdań matematyki – w tym aksjomatów.<br />
<br />
Semantyka referencyjna z odwołaniem do rzeczywistości (np. liczba jako uogólnienie równolicznych zbiorów przedmiotów) groziłaby pozbawieniem matematyki absolutnej pewności.<br />
<br />
Takich problemów nie ma, gdy odwołujemy się do rzeczywistości wirtualnej – czyli tworów informatycznych, które dają się zredukować do zdań matematyki.<br />
<br />
Gdyby udałoby się zachować jednoznaczne przyporządkowanie konstrukcji matematycznych abstrakcjom (obiektom) informatycznym – można by takie przyporządkowanie uznać za semantykę (referencyjną) języka matematyki. Czy to wykonalne? Konieczne byłaby możliwość zapisania w pamięci komputera odpowiednika dowolnych obiektów matematycznych.<br />
<br />
W komputerze można zapisać dowolne obiekty. Jednak może być ich tylko skończona ilość. Nigdy nie będą to więc wszystkie możliwe konstrukcje matematyczne (wynika to z twierdzenia Goedla). Dlatego matematyka nigdy nie zostanie zredukowana do informatyki.<br />
<br />
Ten wynik ma ważne konsekwencje semantyczne, filozoficzne i technologiczne.<br />
<br />
1. Mamy tu wyjaśnienie dlaczego logicyzm<ref>„W najprostszej postaci aksjomat nieskończoności powiada, że dla każdej liczby naturalnej istnieje jej następnik, zaś aksjomat wyboru postuluje, że dla każdej rodziny zbiorów parami rozłącznych istnieje jej selektor. Nie są to aksjomaty logiczne (postulują one istnienie jakichś obiektów, czego aksjomaty logiki nie robią)”. <nowiki>https://open.uj.edu.pl/mod/book/view.php?id=20&chapterid=112</nowiki></ref> nie jest możliwy.<br />
<br />
2. Możemy w systemie komputerowym zapisać symbol nieskończoności. Jednak ten symbol nie będzie się odnosił do niczego, co istnieje w systemie komputerowym. Nawet gdy stworzymy obiekty pozwalające na operowanie nieskończonością. Z punktu widzenia semantyki to tylko definiowanie nieznanego przez nieznane. Ściśle rzecz biorąc – w poszukiwaniu znaczenia symboli w komputerze możemy dojść do definicji maszyny iteracyjnej<ref>Maszyna iteracyjna to teoretyczny konstrukt Zdzisława Pawlaka. Można ją traktować jako alternatywę dla Maszyny Turinga. Składa się z pamięci (elementu o wielu stanach) i funkcji przejścia – wyliczającej na podstawie stanu pamięci w jakim stanie znajdzie się ona w chwili następnej.</ref>, albo do „czegoś z zewnątrz”<ref>Ten wynik jest zgodny z poglądami Cantora: <nowiki>https://bazhum.muzhp.pl/media/files/Humanistyka_i_Przyrodoznawstwo/Humanistyka_i_Przyrodoznawstwo-r2004-t10/Humanistyka_i_Przyrodoznawstwo-r2004-t10-s51-68/Humanistyka_i_Przyrodoznawstwo-r2004-t10-s51-68.pdf</nowiki></ref>.<br />
<br />
3. Konieczność odwołań do „czegoś z zewnątrz” (istnieje coś więcej) to mocny argument przeciw komputacjonizmowi<ref>http://www.filozoficznie.pl/4/40_M_Milkowski_Analiza_tezy_komputacjonizmu.pdf</ref>.<br />
<br />
=== Podsumowanie ===<br />
Matematyka obiektowa absolutnie nie ma być „nową” matematyką, ale nowym jej przedstawieniem – łatwiejszym do przyswojenia. Łączy „oglądowość” z ideą abstrakcji, zastępując odniesienia do rzeczywistości, odniesieniami do świata wirtualnego, opisywanego w języku informatyki. Matematyka postrzegana jako teoretyczne objaśnienie elementów świata maszyn cyfrowych wydaje się łatwiejsza do zrozumienia niż matematyka jako czysto abstrakcyjny system.<br />
<br />
Dodatkowo, dzięki komputerom abstrakcyjne obiekty informatyki stają się częścią naszej rzeczywistości. Wzmacnia to efekt „oglądowości” (wyjaśniając pojęcia matematyczne można się odwoływać do komputerowych kreacji).<br />
<br />
Obiektowy język informatyki powinien ułatwić nauczanie matematyki - zwłaszcza gdy wzorem krajów skandynawskich zastosujemy kształcenie poprzez udział w zespołach rozwiązujących interdyscyplinarne problemy.<br />
<br />
''Jerzy Wawro, 2022''</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=151Algorytm Simplex2022-09-25T18:25:43Z<p>Admin: </p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowego rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej<ref>Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe” https://www.snopes.com/fact-check/the-unsolvable-math-problem/</ref>: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1). (Na temat wyboru wiersza i kolumn będzie jeszcze mowa poniżej).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zmienione – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
----------------------<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” ( https://www.mimuw.edu.pl/~oskar/lecture_13.pdf ), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Przykładowa implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=150Algorytm Simplex2022-09-25T17:48:23Z<p>Admin: </p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowego rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej<ref>Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe” https://www.snopes.com/fact-check/the-unsolvable-math-problem/</ref>: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
----------------------<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=149Algorytm Simplex2022-09-25T17:41:26Z<p>Admin: </p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[index.php?title=Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<blockquote><br />
------<br />
</blockquote><br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
----------------------<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: https://github.com/j2kun/ opisana w tekście: https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
* Zmienne decyzyjne - decision variables<br />
* Funkcja celu - objective function<br />
* Ograniczenia - constraints<br />
* Zmienne ograniczeń - variable bounds<br />
* zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
* sąsiad – neighbor<br />
* iloczyn skalarny - dot product<br />
* analiza wrażliwości (sensitivity analysis)<br />
* rozwiązanie (solution)<br />
* rozwiązanie wierzchołkowe (cornerpoint solution)<br />
* dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
* sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
* stopnie swobody (degrees of freedom, df)<br />
* test minimalnej proporcji (minimum ratio test)<br />
<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
tableau = initialTableau(c, A, b)<br />
while canImprove(tableau):<br />
pivot = findPivotIndex(tableau)<br />
pivotAbout(tableau, pivot)<br />
return tableau, objectiveValue(tableau)<br />
<br />
<syntaxhighlight><br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def initialTableau(c, A, b):<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
tableau.append([ci for ci in c] + [0])<br />
return tableau<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def canImprove(tableau):<br />
lastRow = tableau[-1]<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def findPivotIndex(tableau):<br />
# wybór elementu ostatniego wiersza, dla którego x>0<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)<br />
if all(row[column] <= 0 for row in tableau):<br />
raise Exception('Linear program is unbounded.')<br />
# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz<br />
quotients = [(i, r[-1] / r[column])<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
if moreThanOneMin(quotients):<br />
raise Exception('Linear program is degenerate.')<br />
# wybór indeksu wiersza o minimalnym ilorazie<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
return row, column<br />
<br />
</syntaxhighlight><br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
def pivotAbout(tableau, pivot):<br />
i,j = pivot<br />
pivotDenom = tableau[i][j]<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
for k,row in enumerate(tableau):<br />
if k != i:<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
</syntaxhighlight><br />
<br />
Główny program dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
if __name__ == "__main__":<br />
b = [4, 9, 3]<br />
c = [2, 5]<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
# add slack variables by hand<br />
A[0] += [1, 0, 0]<br />
A[1] += [0, 1, 0]<br />
A[2] += [0, 0, 1]<br />
c += [0, 0, 0]<br />
t, v = simplex(c, A, b)<br />
print("wynik:")<br />
print("tabela simplex=")<br />
for w in t:<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
print("wartość funkcji celu=")<br />
print(v)<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=148Algorytm Simplex2022-09-25T17:33:18Z<p>Admin: /* Równania i nierówności liniowe */</p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
[[index.php?title=Plik:Równania_liniowe.png|alt=Przykład 1]]<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<blockquote><br />
A | b<br />
<blockquote><br />
------<br />
</blockquote><br />
c | 0<br />
</blockquote><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
<br />
<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<nowiki><br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
</nowiki><br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=147Algorytm Simplex2022-09-25T17:23:26Z<p>Admin: /* Algorytm Simplex */</p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
[[Plik:Równania liniowe.png|ramka|alt=Przykład 1|Przykład 1]]<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
[[Plik:Simplex - ilość.png]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<nowiki><br />
<br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
<br />
</nowiki><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki><br />
<br />
--------------<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
</nowiki><br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
<br />
[[Plik:Simplex - przykład 3.png]]<br />
<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<nowiki><br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
</nowiki><br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=146Algorytm Simplex2022-09-25T17:20:30Z<p>Admin: /* Postać standardowa problemu */</p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
[[Plik:Równania liniowe.png|ramka|alt=Przykład 1|Przykład 1]]<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
[[Plik:Simplex - ilość.png|mały]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<nowiki><br />
<br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
<br />
</nowiki><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki><br />
<br />
--------------<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
</nowiki><br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
[[Plik:Simplex - przykład 3.png|ramka]]<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<nowiki><br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
</nowiki><br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=145Algorytm Simplex2022-09-25T15:53:58Z<p>Admin: /* Postać standardowa problemu */</p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
[[Plik:Równania liniowe.png|ramka|alt=Przykład 1|Przykład 1]]<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
W postaci standardowej:<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
A=[ [-1,2,1,0],<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121''''' <br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:<br />
<br />
x1*4 + x2*2 - x3 = 250<br />
<br />
x1*3 + x2*6 - x4 = 300<br />
<br />
x1*12 + x2*15 → max<br />
<br />
x1, x2, x3, x4 >= 0<br />
<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
[[Plik:Simplex - ilość.png|mały]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<nowiki><br />
<br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
<br />
</nowiki><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki><br />
<br />
--------------<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
</nowiki><br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
[[Plik:Simplex - przykład 3.png|ramka]]<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<nowiki><br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
</nowiki><br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Uczymy_si%C4%99_my%C5%9Ble%C4%87_abstrakcyjnie&diff=144Uczymy się myśleć abstrakcyjnie2022-09-25T13:05:33Z<p>Admin: </p>
<hr />
<div>{|<br />
|-<br />
| |Moduł: Podstawy<br />
|-<br />
| |Poziom: Podstawowy<br />
|-<br />
| |Profil: Dla wszystkich <br />
|-<br />
| |Wymagania: Zapoznanie się z modułem 1<br />
|-<br />
|}<br />
<br />
== Symbole ==<br />
<br />
Każdy użytkownik współczesnych smartfonów i komputerów wie co to są ikony. To takie uproszczone symbole oznaczające różne programy. W zależności od wielkości ikonki można pokazać więcej lub mniej szczegółów. Poniżej mamy szereg symboli psa:<br />
<br />
[[Plik:symbol.png]]<br />
<br />
<div style="margin-left:20px;color:green;">Pomoc dydaktyczna: karty z rysunkami zwierząt, rzeczy i pojęć - coraz bardziej abstrakcyjnych. Na jednej stronie karty (zakrytej) może być na przykład zdjęcie psa. Na drugiej (odkrytej) kolejne jego schematyczne przedstawienia – aż do najbardziej abstrakcyjnych. Dziecko otrzymując zadanie pogrupowania kart z takimi rysunkami – jak powyżej - może opanować ideę symbolicznego przedstawiania rzeczy. </div><br />
<br />
W przypadku symboli należy odróżnić to co one '''oznaczają''' – czyli na co wskazują i to co one '''znaczą''' – czyli jaką mają pozycję w systemie (jak je rozumiemy, jak wpływają na otoczenie, co nimi wyrażamy, etc).<br />
<br />
Na przykład w przypadku ikony – ważne jest to co symbol oznacza - na co wskazuje,<br />
<br />
W przypadku znaku drogowego ważniejsze jest jego znaczenie – jak należy go rozumieć, choć czasem oznacza on też miejsce na drodze.<br />
<br />
<br />
[[Plik:Znak_drogowy.png]]<br />
<br />
Zadanie: opisać co oznacza (na co wskazuje) i jakie ma znaczenie (co znaczy, jak wpływa na oglądających go) powyższy znak drogowy. <br />
<br />
Nie zawsze rozróżnienie znaczenia i oznaczania jest łatwe tak jak w przypadku znaku drogowego. Należy jednak zdawać sobie sprawę z tego rozróżnienia – bo to jest ważne dla zrozumienia logiki, będącej fundamentem programowania.<br />
<br />
== Logika w automatycznych obliczeniach ==<br />
<br />
Każdy symbol w programach to także komórka w pamięci, której zawartość wpływa na działanie systemu. Możemy więc mówić, że symbol ma pewne '''znaczenie''' (wpływ na system). Czy jednak także coś '''oznacza''' – albo inaczej, czy się do czegoś odnosi? A może w systemie komputerowym te odniesienia są jedynie innym sposobem opisu tego, jak zmienna/symbol wpływa na system – czyli jakie ma '''znaczenie''' w systemie? Jeśli chodzi o odniesienia do rzeczywistości (co oznacza symbol poza wirtualnym światem komputerów) – to one w samych obliczeniach nie są ważne. Odniesienia te są symbolom nadawane poprzez urządzenia peryferyjne w komputerze, albo człowieka, interpretującego wyniki działania programów. <br />
<br />
<div style="text-align:center;">'''W świecie wirtualnym ważne jest wyłącznie znaczenie symboli, a nie to co one oznaczają.'''</div><br />
<br />
To jest istota wirtualności! Programowanie komputerów to budowanie struktur wirtualnego świata!<br />
<br />
Takie abstrahowanie od rzeczywistości nie jest wyłącznie domeną informatyki! Tak samo wyglądają wytwory artystów i matematyków. Teoretycznie te dziedziny mogą istnieć nawet gdyby nie było żadnej rzeczywistości (poza nośnikiem wytwarzanych treści oczywiście ;-)).<br />
<br />
Czy w świecie wirtualnym istnieje pełna „swoboda twórcza”? W świecie rzeczywistym istnieją ograniczenia fizyczne. Nie możemy iść prosto przed siebie, bo zawsze trafimy na jakąś przeszkodę nie do pokonania. Czy takie ograniczenia istnieją również w świecie wirtualnym?<br />
<br />
Tak – przyjęto, że poprawne jest myślenie i programowanie (!) '''zgodne z regułami logiki'''. Programy komputerowe budowane ściśle według zasad klasycznego rachunku zdań! W komputerach nie ma nic co łamałoby zasady logiki. Funkcja przejścia jest wyrażeniem logicznym:<br />
<br />
[[Plik:Sys_iteracyjny_logika.png]]<br />
<br />
<br />
Tak ściśle rzecz ujmując jest to zbiór wyrażeń logicznych, z których każde mówi – czy po następnym takcie zegara konkretna komórka pamięci będzie miała wartość 1 lub 0.<br />
<br />
== Semantyka języków programowania ==<br />
<br />
Funkcja przejścia jest fizyczną realizacją wyrażenia logicznego i liczy się wyłącznie sposób połączenia między wejściem i wyjściem (jak w kolejnych taktach zegara zmienia się stan).<br />
<br />
Jednak napisanie złożonego wyrażenia logicznego obejmującego miliony połączeń jest zadaniem trudnym – jeśli nie nadamy fragmentom pamięci jakichś oznaczeń i nie posłużymy się językiem programowania (zbiorem instrukcji), który ma swoją '''semantykę''' (czyli znaczenie symboli).<br />
<br />
Semantyka to pojęcie z dziedziny lingwistyki (nauki o językach) i dotyczy znaczenia wypowiedzi. Jest to też pojęcie mające zastosowanie w informatyce.<br />
<br />
Programując zapisujemy zbiór instrukcji (zdań jakiegoś języka) które odnoszą się do zawartości pamięci komputera. Mało tego – w informatyce tworzy się bardziej abstrakcyjne języki, które są następnie tłumaczone na język prostszy, a dopiero później na coś co nazywa się „językiem maszyny” i jest wpisywane do pamięci komputera. Mamy więc sytuację analogiczną do tej jak w językoznawstwie – gdzie używa się pojęcia „metajęzyk”. Jest to język w którym opisujemy wypowiedzi w innym języku. W polskim podręczniku do języka angielskiego metajęzykiem wobec języka angielskiego jest język polski. W komputerze metajęzykiem dla języka programowania jest najczęściej język maszynowy (nazywany asemblerem), który opisuje znaczenie i oznaczanie (odniesienia do pamięci komputera) użytych przez programistę wyrażeń. Taki proces nazywa się translacją (czyli inaczej tłumaczeniem).<br />
<br />
Pisząc program opisujemy w rzeczywistości to jak powinien działać komputer – czyli jaka ma być zawartość pamięci i jakie wyrażenie logiczne wyznaczające na podstawie stanu pamięci stan następny. Jednak dzięki istnieniu translatorów (takich jak Google Translator), możemy posługiwać się językiem bardziej dla nas wygodnym niż asembler i operować abstrakcyjnymi pojęciami, a następnie przetłumaczyć program na „język maszyny” - czyli de facto stworzyć rzeczywisty program.<br />
<br />
Nawet pisząc proste wyrażenie logiczne takie jak „'''a lub b i c'''” używamy symboli, które są abstrakcyjne. Czyli symbole te mają jakieś znaczenie, ale nie oznaczają niczego konkretnego (nie odnoszą się do niczego poza tym wyrażeniem). Gdy jednak programista opisuje (lub planuje) działanie komputera, to przecież te symbole odnoszą się do komórek pamięci! Nadal więc oznaczanie symboli jest istotne – tyle, że symbole odnoszą się do rzeczywistości wirtualnej.<br />
<br />
Mamy więc:<br />
<br />
[[Plik:Semantyka.png]]<br />
<br />
<br />
Posługujemy się symbolami i opisujemy jak ma się zmieniać pamięć. Symbole mogą oznaczać miejsce w pamięci – wtedy to miejsce oznaczone symbolem nazywamy zmienną.<br />
<br />
<div style="text-align:center;">'''W PROGRAMACH NAZWA ZMIENNYCH JEST SYMBOLEM'''</div><br />
<br />
'''Zawartość zmiennej jest tym, co ta zmienna oznacza. Symbole jakimi się posługujemy na co dzień odnoszą się najczęściej do rzeczywistości. Zmienne w programach – niekoniecznie. Tym się różni świat realny od wirtualnego.'''<br />
<br />
Tak naprawdę należałoby mówić o '''świecie abstrakcyjnym '''a nie wirtualnym. Gdy mówimy o świecie realnym, poprawne są wypowiedzi sformułowane w sposób zrozumiały (posiadające znaczenie) i mówiące prawdę (oznaczanie). Prawdziwe są te wypowiedzi, które opisują stan faktyczny. Prawdą jest, że „koń pasie się na łące”, gdy rzeczywiście koń pasie się na łące. <br />
<br />
W świecie abstrakcyjnym poprawne są te wypowiedzi, które w zrozumiały (dla kompilatora) sposób opisują działanie abstrakcyjnego systemu. <br />
<br />
<span style="color:#007826;">'''Zadanie domowe: zapoznać się z klasyczną definicją prawdy Arystotelesa i nawiązującą do tej definicji teorii Tarskiego </span>[https://pl.wikipedia.org/wiki/Prawda https://pl.wikipedia.org/wiki/Prawda]<span style="color:#007826;">, </span><span style="color:#007826;">pojęciem metajęzyka </span>[https://pl.wikipedia.org/wiki/Metajęzyk https://pl.wikipedia.org/wiki/Metaj%C4%99zyk]<span style="color:#007826;"> </span><span style="color:#007826;">oraz pojęciem semantyki referencyjnej </span>[https://pl.wikipedia.org/wiki/Semantyka_(językoznawstwo)#Semantyka_referencyjna https://pl.wikipedia.org/wiki/Semantyka_(j%C4%99zykoznawstwo)#Semantyka_referencyjna]<span style="color:#007826;"> '''</span><br />
<br />
== Obiekty ==<br />
<br />
Jednym z najważniejszych pojęć we współczesnej informatyce jest pojęcie obiektu. Kiedyś zmienne oznaczały po prostu fragment pamięci. Obecnie podobnie jak w przypadku hierarchii języków - stosuje się także coraz bardziej złożone struktury pamięci, które są tłumaczone na struktury prostsze. Na przykład uporządkowany zbiór wartości jest przechowywany w strukturze nazywanej listą. Z uwagi na to, że zawartość pamięci jest traktowana jako „'''dane'''” dla programów – mówimy o takich strukturach jako o strukturach danych. Najbardziej zaawansowaną strukturą w językach programowania jest obiekt. Jest to struktura, która ma swoje własności (które także mogą być obiektami) i metody zmian tych własności.<br />
<br />
Na przykład obiekt opisujący samochód będzie miał własności takie jak drzwi, koła, szyby etc… Metodą zmiany może być komenda uruchomienia wydawana przez przekręcenie kluczyka w stacyjce. <br />
<br />
Najczęściej spotykanym przez nas obiektem komputerowym jest dokument HTML – czyli strona internetowa. Ona też ma swoją obiektową strukturę, nazywaną modelem DOM:<span style="color:#007826;"> </span>[https://pl.wikipedia.org/wiki/Obiektowy_model_dokumentu https://pl.wikipedia.org/wiki/Obiektowy_model_dokumentu]<span style="color:#007826;"> </span><br />
<br />
== Analiza przykładu ==<br />
<br />
Te teoretyczne rozważania zilustrujmy konkretnym programem. Wykorzystamy język JavaScript używany w przeglądarkach internetowych. Istnieje kilka stron na których można testować takie programy ([http://codepen.io/pen/ http://codepen.io/pen/] lub [https://jsfiddle.net/ https://jsfiddle.net/] lub [http://jsbin.com/ http://jsbin.com/]).<br />
<br />
'''Przykład 1:'''<br />
<br />
[http://jsbin.com/folowenasa/edit?html,css,js,console,output http://jsbin.com/folowenasa/edit?html,css,js,console,output]<br />
<br />
Wpiszmy w treść strony jakiś tekst – na przykład „Kliknij tutaj”.<br />
<br />
Do znacznika <body> dodajmy własność „onclick” i nadajmy jej wartość „test();”. Będzie to znaczyć, że po kliknięciu na stronie wykona się procedura „test”.<br />
<br />
<syntaxhighlight lang="html" line="1" ><br />
<br />
<body onclick="test();">kliknij tutaj</body><br />
<br />
</syntaxhighlight><br />
<br />
Procedura musi zostać napisana – żeby się wykonała:<br />
<br />
<syntaxhighlight lang="javascript" line="1" ><br />
<br />
function test() {<br />
alert('!');<br />
}<br />
<br />
</syntaxhighlight><br />
<br />
Jakie jest znaczenie i oznaczanie użytych symboli?<br />
<br />
<br />
{| class="wikitable"<br />
|-<br />
| symbol<br />
| Znaczenie<br />
| oznaczanie<br />
|-<br />
| body<br />
| Część języka HTML w którym opisujemy strony internetowe. W tym wypadku znacznik używany do ograniczenia całej strony.<br />
| Oznacza wnętrze (treść) strony.<br />
|-<br />
| < ><br />
| Dwa symbole określające początek i koniec znacznika. <br />
| Miejsce w tekście gdzie zaczyna się i kończy znacznik.<br />
|-<br />
| /<br />
| Zmienia znaczenie znacznika (koniec oznaczanego obszaru) – o ile występuje natychmiast po znaku <<br />
| <br />
|-<br />
| onclick<br />
| Własność dodawana do znacznika. Po znaku = nadaje się tej własności wartość.<br />
| Co się stanie, gdy klikniemy na wskazywane przez znacznik miejsce.<br />
|-<br />
| function<br />
| Symbol używany do zdefiniowania fragmentu kodu (programu) nazywanego funkcją.<br />
| Definicję jakiejś funkcji.<br />
|-<br />
| test<br />
| Symbol zdefiniowany przez nas – konkretnej funkcji.<br />
| Definicję konkretnej funkcji test.<br />
|-<br />
| alert<br />
| Wyświetlenie komunikatu<br />
| Funkcję zdefiniowaną (wbudowaną) w przeglądarce.<br />
|-<br />
| {<br />
| Znaki używane dla interpretera (przeglądarki internetowej) – aby mógł zrozumieć znaczenie tekstu <br />
| Początek procedury<br />
|-<br />
| }<br />
| Koniec procedury<br />
|-<br />
| <nowiki>;</nowiki><br />
| Koniec fragmentu procedury zawierającą instrukcję (zob niżej).<br />
|-<br />
| '''"'''<br />
| Cudzysłów oznaczający początek i koniec napisu.<br />
|-<br />
| <nowiki>=</nowiki><br />
| Znak równości (własność ma określoną wartość)<br />
|-<br />
| (<br />
| Początek miejsca na parametry funkcji<br />
|-<br />
| )<br />
| Koniec miejsca na parametry funkcji<br />
|-<br />
|}<br />
<br />
Więcej informacji: [http://www.w3schools.com/html/html_intro.asp http://www.w3schools.com/html/html_intro.asp] (można wybrać polskie tłumaczenie – jest dość porządne).<br />
[http://pdf.helion.pl/e14te3/e14te3.pdf http://pdf.helion.pl/e14te3/e14te3.pdf] (rozdział 3.8 i dalej)<br />
<br />
<br />
Nie zawsze rozróżnienie znaczenia i oznaczania jest oczywiste. W przypadku symbolu „/” mamy do czynienia jedynie z modyfikacją znaczenia innego symbolu. Można na siłę określić co on oznacza (miejsce po którym nastąpi nazwa zmodyfikowanego symbolu?) - ale czy to nam jest potrzebne?<br />
<br />
Dodatkowego wyjaśnienia wymaga znaczenie symbolu „funkcja” i pojęcia które się za nim kryje.<br />
<br />
Funkcja to fragment kodu programu określony nazwą. Zamiast słowa funkcja używa się czasem określenia ‘procedura’, które nie oznacza jednak dokładnie tego samego (wybiegając nieco w przyszłość: funkcja zwraca wartość, procedura nie). <br />
<br />
<br />
<span style="color:#6600cc;">'''Uwaga metodyczna: używanie praktycznych środowisk programistycznych ma tą przewagę nad zabawami typu Scratch lub Baltie (które raczej są przeznaczone dla szkół podstawowych) – że pozwala doświadczyć czegoś najpiękniejszego w pracy programisty: natychmiast widocznego i użytecznego efektu, którym można się pochwalić.'''</span><br />
<br />
== Definicja a użycie symbolu ==<br />
<br />
Należy odróżnić użycie i definicję symbolu. Symbol „test” jest zastosowany w powyższym przykładzie dwa razy: raz go definiujemy (po słowie function), drugi raz używamy. W pierwszym przypadku ważniejsze jest to co symbol oznacza (definicję procedury) w drugim – co znaczy (taki sposób funkcjonowania strony, że kliknięcie w jej fragment spowoduje wyświetlenie komunikatu).<br />
<br />
Czym symbol „alert” różni się od symbolu „test”?<br />
<br />
Funkcję „test” musieliśmy zdefiniować. Funkcja „alert” została zdefiniowana przez twórców JavaScript i po prostu możemy jej używać.<br />
<br />
Co jeszcze możemy powiedzieć o symbolach? Poza rozróżnienie znaczenia i oznaczania mamy jeszcze sam symbol jako byt (obiekt fizyczny). Znaczek biegnących dzieci jest namalowany na znaku drogowym – najczęściej blaszanym i z użyciem farby.<br />
<br />
'''Pomoc dydaktyczna: odróżnienie symbolu od kryjących się pod nim treści można przedstawić za pomocą pudełek w których ukrywamy różne rzeczy. Można na przykład dzieciom zrobić konkurs na symbole oznaczające kosze na różnego rodzaju odpadki (przy okazji uczymy ekologii ;-)).'''<br />
<br />
== Kontekst i znaczenie ==<br />
<br />
Znaczenie symbolu zależy od kontekstu w którym go używamy. Słowo „alert” oznacza po angielsku alarm. W środowisku przeglądarki internetowej powoduje wyświetlenie komunikatu. Użycie symbolu w powyższym zdaniu jest jego przytoczeniem (cytatem). Po to używamy cudzysłowów. Jeśli w definicji funkcji test zmienimy alert(‘!’) na alert(‘alert’) to nie wykona się dwa razy funkcja „alert”, tylko zostanie wyświetlona (przytoczona) jej nazwa.<br />
<br />
Kontekst jest ważny, bo w różnych miejscach ten sam symbol może oznaczać coś innego. Nie należy tego nadużywać (lepiej stosować różne symbole). <br />
<br />
'''Przykład 2:'''<br />
<br />
html:<br />
<br />
<syntaxhighlight lang="html" line="1" ><br />
<br />
<body><span style="color:blue" id="test" onclick="test();"> kliknij tutaj</span></body><br />
<br />
</syntaxhighlight><br />
<br />
Javascript:<br />
<br />
<syntaxhighlight lang="javascript" line="1" ><br />
<br />
function test() { <br />
alert(document.getElementById("test").style.color); <br />
}<br />
<br />
</syntaxhighlight><br />
<br />
W przykładzie tym użyliśmy nowego znacznika '''span''' – którym określamy fragment tekstu. Dodatkowa własność znacznika to style - oznacza ona sposób wyświetlania. W tym wypadku zdefiniowaliśmy kolor jako niebieski. Symbol „test” został użyty na określenie zarówno funkcji jak i fragmentu tekstu w znaczniku span.<br />
<br />
Użyliśmy też innej zdefiniowanej funkcji: document.getElementById – która zwraca nam część strony określoną identyfikatorem (własność id). Możemy w JavaScript odnosić się do własności tej części strony. Na przykład document.getElementById("test").style.color oznacza odwołanie do stylu i wybranie z tego stylu nazwy koloru.<br />
<br />
Możemy ten kolor też w JavaScript zmieniać. Na przykład dodanie instrukcji: document.getElementById("test").style.color = "red"; spowoduje zmianę koloru na czerwony.<br />
<br />
'''Ćwiczenie:'''<br />
<br />
1) próbujmy zmieniać nazwy symbolu ''test'' w różnych miejscach gdzie go użyto. Które z tych zmian mają sens?<br />
<br />
2) Dodajmy zmianę koloru na czerwony.<br />
<br />
Przy próbach zmiany symbolu może wystąpić taka sytuacja, że odwołujemy się do elementu, którego nie ma (bo na przykład zmieniliśmy id=”test” na id=”test1” a odwołujemy się do „test”). Najczęściej ma to miejsce wskutek pomyłek. Co się wówczas dzieje? Pojawia się '''symbol pusty''' (z angielskiego null). Słowo ‘null’ nie oznacza nicości (w komputerze nie ma czegoś takiego), tylko właśnie symbol pusty.<br />
<br />
'''Pojęcie symbolu pustego występuje na przykład w grze w domino („mydło”).''' Wyobraźmy sobie choinkę i prezenty, w pudełkach oznaczane imionami domowników. Te imiona są symbolem oznaczającym prezent dla konkretnej osoby. A co będzie gdy pojawi się pudełko bez symbolu? Może to po prostu ktoś zostawił opakowanie po ozdobach choinkowych? W środku nic nie ma. Mamy przykład symbolu pustego.<br />
<br />
'''To co symbole oznaczają może się zmieniać'''. Pojęcie zmiennej (pudełko oznaczone symbolem) jest chyba najważniejszym w programowaniu komputerów. W naszym przykładzie symbol „color” znaczy kolor wyświetlania, a oznacza konkretny kolor (‘blue’, lub ‘red’). <br />
<br />
== Podsumowanie ==<br />
<br />
* Symbole jakich używamy mają swoje znaczenie i mogą coś oznaczać (na coś wskazywać).<br />
* W logice posługujemy się symbolami abstrakcyjnymi, które nie odnoszą się do konkretnych rzeczy.<br />
* Komputer działa zgodnie z zasadami logiki. Funkcję przejścia można teoretycznie opisać jako zbiór wyrażeń logicznych.<br />
* W praktyce posługujemy się językami programowania, które są tłumaczone na język maszynowy przez translator.<br />
* Symbole w językach programowania mają znaczenie i mogą oznaczać miejsce w pamięci. W tym drugim przypadku mówimy o zmiennych, a miejsce oznaczone tą nazwą nazywamy zmienną.<br />
* Języki programowania mogą tworzyć hierarchię (bardziej abstrakcyjny może być tłumaczony na bardzie zbliżony do języka maszynowego - asemblera). Odpowiada to podziałowi na język i metajęzyk w językoznawstwie.<br />
* Struktury pamięci (struktury danych, zmienne) mogą także być złożone i tworzyć obiekty.<br />
* Obiekt to struktura danych która ma swoje własności i metody zmian tych własności. Przykładem takiej struktury jest dokument HTML.</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_%E2%80%93_program_%E2%80%93_system&diff=143Algorytm – program – system2022-09-25T13:03:34Z<p>Admin: /* Od łamigłówki do programu */</p>
<hr />
<div>{|<br />
|-<br />
| |Moduł: Podstawy<br />
|-<br />
| |Poziom: Podstawowy<br />
|-<br />
| |Profil: Dla wszystkich<br />
|-<br />
|}<br />
<br />
== Od łamigłówki do programu ==<br />
<br />
Łamigłówka „Wieże Hanoi” (https://pl.wikipedia.org/wiki/Wieże_Hanoi) polega na przełożeniu krążków z pierwszego na trzeci słupek zgodnie z regułami:<br />
* za każdym razem jeden; <br />
* nie wolno kłaść większego krążka na mniejszy <br />
<br />
<br />
<div><br />
[[Plik:Hanoi.png]]Pomoc dydaktyczna: klocki Wieże Hanoi.</div><br />
<br />
Oznaczmy liczbami krążki (od najmniejszego do największego).<br />
<br />
Opracowujemy plan działania:<br />
<br />
{| style="border-spacing:0;width:3.201cm;border:1px solid black"<br />
|-<br />
| | Lp<br />
| align=center | działanie<br />
|-<br />
| | 1<br />
| | 1-C<br />
|-<br />
| | 2<br />
| | 2-B<br />
|-<br />
| | 3<br />
| | 1-B<br />
|-<br />
| | 4<br />
| | 3-C<br />
|-<br />
| | 5<br />
| | 1-A<br />
|-<br />
| | 6<br />
| | 2-C<br />
|-<br />
| | 7<br />
| | 1-C<br />
|-<br />
|}<br />
<br />
<br />
Przetestujmy: https://pl.khanacademy.org/computing/computer-science/algorithms/towers-of-hanoi/e/move-three-disks-in-towers-of-hanoi<br />
<br />
<div style="color:#007826;">Zadanie domowe:<br />
# Spróbować dla większej ilości klocków. <br />
# Czy daje się to uogólnić dla n klocków (zadanie bardzo zaawansowane)? <br />
</div><br />
<br />
<br />
<br />
Ułożenie takiego planu działania wymaga '''abstrakcyjnego myślenia'''. Abstrakcja – czyli abstrahowanie od fizycznych elementów. Klocki, słupki i działania zmieniają się w abstrakcyjny zapis – na przykład 1-B. Umiejętność abstrakcyjnego myślenia jest najważniejsza dla programisty. Jeśli ktoś tego nie potrafi – nie może być programistą i nigdy nie zrozumie matematyki.<br />
<br />
Taki abstrakcyjny plan działania nazywa się '''algorytmem'''. <br />
<br />
'''Program''' to algorytm wykonywany przez '''automat'''.<br />
<br />
<br />
<br />
Ilustracja: program Hanoi (dołączone do kursu źródła UWAGA! Program został napisany w przestarzałej technologii Flash - może nie działać na nowych przeglądarkach).<br />
<br />
[http://otwartaedukacja.pl/programowanie/hanoi/ http://otwartaedukacja.pl/programowanie/hanoi/] <br />
<br />
<br />
[[Plik:Hanoi_prg.png]]<br />
<br />
Każdy program jest uruchamiany w pewnym '''środowisku'''. Tutaj środowiskiem są trzy słupki z krążkami. Dla programów (Hanoi, https://pl.khanacademy.org/computing/computer-science/algorithms/towers-of-hanoi/e/move-three-disks-in-towers-of-hanoi) środowiskiem jest przeglądarka internetowa w której uruchomiono program napisany w języku JavaScript.<br />
<br />
Przejście od środowiska fizycznego (klocki) do przeglądarki internetowej wydaje się nam czymś naturalnym. To jednak wymaga pewnej refleksji – gdyż w ten sposób wchodzimy do świata wirtualnego. '''Wirtualny''' – czyli nie istniejący realnie.<br />
<br />
<div style="text-align:center;">'''PROGRAM KOMPUTEROWY TO AUTOMAT DZIAŁAJĄCY W ŚWIECIE WIRTUALNYM'''</div><br />
<br />
<br />
[[Plik:Robot.png]]<br />
<br />
Najważniejszą cechą automatu jest '''determinizm''' – czyli kolejne działanie jest ściśle określone i zależy wyłącznie od stanu w jakim znajduje się maszyna. '''Programowanie maszyn = dążenie do determinizmu''' (ścisłego określenia co ma się wydarzyć w danym stanie maszyny, a nie tylko co może się wydarzyć).<br />
<br />
== System ==<br />
<br />
Elementy automatu są powiązane ze sobą w taki sposób, aby w całości uzyskać pożądaną funkcjonalność. Na przykład bankomat składa się z liczarki banknotów, klawiatury, monitora, obudowy, czytnika kart i sterującego wszystkim komputera. Jego podstawową funkcją jest wydawanie pieniędzy. Taki zbiór elementów powiązanych ze sobą w sposób umożliwiający uzyskanie pewnej funkcjonalności nazywa się '''systemem'''.<br />
<br />
<div style="margin-left:1.251cm;margin-right:0cm;"><span style="color:#007826;">Zadanie domowe: zapoznać się z hasłem „System” w Wikipedii: </span>[https://pl.wikipedia.org/wiki/System https://pl.wikipedia.org/wiki/System]<span style="color:#007826;"> </span></div><br />
<br />
Złożone systemy komputerowe uzyskuje się poprzez składanie ich z systemów prostszych (modułów, podprogramów). Idąc w kierunku przeciwnym – do rzeczy coraz prostszych sięgamy do istoty obliczeń. Polski matematyk Zdzisław Pawlak taki najprostszy system nazwał „systemem iteracyjnym”. <br />
<br />
Składa się on z pamięci i funkcji przejścia. Pamięć wyraża stan aktualny automatu, a funkcja przejścia determinuje (określa) stan następny.<br />
<br />
System iteracyjny:<br />
<br />
[[Plik:Sys_iteracyjny.png]]<br />
<br />
<div style="text-align:center;"><br />
'''MASZYNA OBLICZENIOWA = PAMIĘĆ + FUNKCJA PRZEJŚCIA'''<br />
<br />
'''FUNKCJA PRZEJŚCIA WYZNACZA STAN NASTĘPNY (NOWĄ ZAWARTOŚĆ PAMIĘCI)'''<br />
'''PROGRAMOWANIE = BUDOWANIE FUNKCJI PRZEJŚCIA'''</div><br />
<br />
Pawlak posługuje się przykładem kostki do gry.<br />
<br />
<div style="color:#ff0000;margin-left:2.499cm;margin-right:0cm;">Pomoc dydaktyczna: kostka do gry lub kostka Rubika</div><br />
<br />
<br />
[[Plik:Kostka.png]]<br />
<br />
Przykład programu:<br />
<br />
<br />
{| style="border-spacing:0;width:6.085cm;"<br />
|- style="border:none;padding:0cm;"<br />
|| STAN<br />
|| NASTĘPNY<br />
|- style="border:none;padding:0cm;"<br />
|| 1<br />
|| STOP<br />
|- style="border:none;padding:0cm;"<br />
|| 2<br />
|| STOP<br />
|- style="border:none;padding:0cm;"<br />
|| 3<br />
|| 1<br />
|- style="border:none;padding:0cm;"<br />
|| 4<br />
|| 2<br />
|- style="border:none;padding:0cm;"<br />
|| 5<br />
|| 1<br />
|- style="border:none;padding:0cm;"<br />
|| 6<br />
|| 2<br />
|-<br />
|}<br />
Pytanie: co ten program wylicza?<br />
<br />
Odpowiedź: zatrzymuje się na 1 lub 2 w zależności od tego, czy początkowo była ilość parzysta lub nieparzysta oczek.<br />
<br />
Pisząc program określamy warunki jego zatrzymania się. Najczęściej jest to zakończenie wykonywania algorytmu (zakończenie obliczeń). <br />
<br />
Zadanie domowe: zapoznać się z problemem stopu [https://pl.wikipedia.org/wiki/Problem_stopu https://pl.wikipedia.org/wiki/Problem_stopu]<br />
<br />
== Arkusz kalkulacyjny jako środowisko w którym uruchamiamy programy ==<br />
<br />
[[Plik:Arkusz.png]]<br />
<br />
'''KOMÓRKI = PAMIĘĆ'''<br />
'''REGUŁY = FUNKCJA PRZEJŚCIA'''<br />
<br />
== Zmienna ==<br />
<br />
W arkuszu kalkulacyjnym wiadomo gdzie zapisać wynik – w tej samej komórce, w której zapisano regułę. W programie musimy zarezerwować miejsce w pamięci. Komórka arkusza kalkulacyjnego ma swoją nazwę. W programie posługujemy się nazwą zmiennej (identyfikatorem).<br />
<br />
'''Nazwa komórki = identyfikator zmiennej'''<br />
<br />
Przykład identyfikatora w języku php: '''$a1 '''(użyto identyfikatora zgodnie z konwencją nazywania komórek w arkuszu kalkulacyjnym).<br />
<br />
Najprostsze programy to formuły w arkuszu.<br />
<br />
Na przykład: <br />
<br />
<nowiki>= $a1 + 10</nowiki><br />
<br />
Odpowiednia instrukcja w języku php:<br />
<br />
$wynik = $a1+10;<br />
<br />
Zarezerwowane dwa miejsca w pamięci – zmienne $a1 i $wynik<br />
<br />
== Algorytm a program ==<br />
<br />
Często spotyka się z wyjaśnieniem, że program jest implementacją algorytmu. Czyli takim zapisem algorytmu, by mogła go wykonać maszyna. To wyjaśnienie wymaga komentarza. Algorytmy jakie spotykamy na co dzień są najczęściej trywialne. Na przykład: aby otworzyć drzwi, włóż klucz do zamka, przekręć w prawo do oporu a następnie naciśnij klamkę.<br />
<br />
Jednak algorytmy bywają też bardzo trudne. Nawet najprostszy algorytm sortowania liczb wymaga odrobiny wysiłku intelektualnego, aby go zrozumieć. Naukę programowania często myli się z algorytmiką (czyli układaniem algorytmów), co jest trudne. Dla większości zadań z jakimi spotyka się programista ich trudność można porównać z algorytmem otwierania drzwi (sama czynność jest prostsza, niż jej ścisłe opisanie).<br />
<br />
Algorytmika jest trudna. Programowanie jest łatwe. Układanie i implementacja algorytmów wymaga wiedzy, umiejętności i talentu. Programować może każdy. I każdy, kto ma styczność z tworami nowoczesnej techniki to robi (choćby programując programy w telewizorze).<br />
<br />
[[Plik:Molier.png]]<br />
MOLIER „MIESZCZANIN SZLACHCICEM” (w oryginale bohater był zdziwiony, że mówi prozą!)<br />
<br />
== Podsumowanie ==<br />
<br />
* Programowanie komputerów wymaga abstrakcyjnego myślenia.<br />
* Układamy algorytmy i zapisujemy je przy pomocy abstrakcyjnych symboli.<br />
* Programy są uruchamiane w środowisku tworzącym system obliczeniowy.<br />
* Istotę działania takiego systemu wyjaśnia system iteracyjny.<br />
* Najprostszym środowiskiem jest arkusz kalkulacyjny.<br />
* Przechodząc od arkusza do zwykłych programów – wprowadzamy pojęcie zmiennej (zastępujące komórkę arkusza).<br />
* Programowanie nie jest trudne! Programy pisze każdy użytkownik arkusza kalkulacyjnego (a nawet gdy tylko układa w myśli plan działania)! Trudne natomiast może być układanie algorytmów (czym zajmuje się algorytmika).</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_%E2%80%93_program_%E2%80%93_system&diff=142Algorytm – program – system2022-09-25T13:01:35Z<p>Admin: nieaktywny link</p>
<hr />
<div>{|<br />
|-<br />
| |Moduł: Podstawy<br />
|-<br />
| |Poziom: Podstawowy<br />
|-<br />
| |Profil: Dla wszystkich<br />
|-<br />
|}<br />
<br />
== Od łamigłówki do programu ==<br />
<br />
Łamigłówka „Wieże Hanoi” (https://pl.wikipedia.org/wiki/Wieże_Hanoi) polega na przełożeniu krążków z pierwszego na trzeci słupek zgodnie z regułami:<br />
* za każdym razem jeden; <br />
* nie wolno kłaść większego krążka na mniejszy <br />
<br />
<br />
<div><br />
[[Plik:Hanoi.png]]Pomoc dydaktyczna: klocki Wieże Hanoi.</div><br />
<br />
Oznaczmy liczbami krążki (od najmniejszego do największego).<br />
<br />
Opracowujemy plan działania:<br />
<br />
{| style="border-spacing:0;width:3.201cm;border:1px solid black"<br />
|-<br />
| | Lp<br />
| align=center | działanie<br />
|-<br />
| | 1<br />
| | 1-C<br />
|-<br />
| | 2<br />
| | 2-B<br />
|-<br />
| | 3<br />
| | 1-B<br />
|-<br />
| | 4<br />
| | 3-C<br />
|-<br />
| | 5<br />
| | 1-A<br />
|-<br />
| | 6<br />
| | 2-C<br />
|-<br />
| | 7<br />
| | 1-C<br />
|-<br />
|}<br />
<br />
<br />
Przetestujmy: https://pl.khanacademy.org/computing/computer-science/algorithms/towers-of-hanoi/e/move-three-disks-in-towers-of-hanoi<br />
<br />
<div style="color:#007826;">Zadanie domowe:<br />
# Spróbować dla większej ilości klocków. <br />
# Czy daje się to uogólnić dla n klocków (zadanie bardzo zaawansowane)? <br />
</div><br />
<br />
<br />
<br />
Ułożenie takiego planu działania wymaga '''abstrakcyjnego myślenia'''. Abstrakcja – czyli abstrahowanie od fizycznych elementów. Klocki, słupki i działania zmieniają się w abstrakcyjny zapis – na przykład 1-B. Umiejętność abstrakcyjnego myślenia jest najważniejsza dla programisty. Jeśli ktoś tego nie potrafi – nie może być programistą i nigdy nie zrozumie matematyki.<br />
<br />
Taki abstrakcyjny plan działania nazywa się '''algorytmem'''. <br />
<br />
'''Program''' to algorytm wykonywany przez '''automat'''.<br />
<br />
<br />
Ilustracja: program Hanoi (dołączone do kursu źródła).<br />
<br />
[http://otwartaedukacja.pl/programowanie/hanoi/ http://otwartaedukacja.pl/programowanie/hanoi/] <br />
<br />
<br />
[[Plik:Hanoi_prg.png]]<br />
<br />
Każdy program jest uruchamiany w pewnym '''środowisku'''. Tutaj środowiskiem są trzy słupki z krążkami. Dla programów (Hanoi, [http://www.zagraj.republika.pl/hanoi.html http://www.zagraj.republika.pl/hanoi.html]) środowiskiem jest przeglądarka internetowa w której uruchomiono program napisany w języku JavaScript.<br />
<br />
Przejście od środowiska fizycznego (klocki) do przeglądarki internetowej wydaje się nam czymś naturalnym. To jednak wymaga pewnej refleksji – gdyż w ten sposób wchodzimy do świata wirtualnego. '''Wirtualny''' – czyli nie istniejący realnie.<br />
<br />
<div style="text-align:center;">'''PROGRAM KOMPUTEROWY TO AUTOMAT DZIAŁAJĄCY W ŚWIECIE WIRTUALNYM'''</div><br />
<br />
<br />
[[Plik:Robot.png]]<br />
<br />
Najważniejszą cechą automatu jest '''determinizm''' – czyli kolejne działanie jest ściśle określone i zależy wyłącznie od stanu w jakim znajduje się maszyna. '''Programowanie maszyn = dążenie do determinizmu''' (ścisłego określenia co ma się wydarzyć w danym stanie maszyny, a nie tylko co może się wydarzyć).<br />
<br />
== System ==<br />
<br />
Elementy automatu są powiązane ze sobą w taki sposób, aby w całości uzyskać pożądaną funkcjonalność. Na przykład bankomat składa się z liczarki banknotów, klawiatury, monitora, obudowy, czytnika kart i sterującego wszystkim komputera. Jego podstawową funkcją jest wydawanie pieniędzy. Taki zbiór elementów powiązanych ze sobą w sposób umożliwiający uzyskanie pewnej funkcjonalności nazywa się '''systemem'''.<br />
<br />
<div style="margin-left:1.251cm;margin-right:0cm;"><span style="color:#007826;">Zadanie domowe: zapoznać się z hasłem „System” w Wikipedii: </span>[https://pl.wikipedia.org/wiki/System https://pl.wikipedia.org/wiki/System]<span style="color:#007826;"> </span></div><br />
<br />
Złożone systemy komputerowe uzyskuje się poprzez składanie ich z systemów prostszych (modułów, podprogramów). Idąc w kierunku przeciwnym – do rzeczy coraz prostszych sięgamy do istoty obliczeń. Polski matematyk Zdzisław Pawlak taki najprostszy system nazwał „systemem iteracyjnym”. <br />
<br />
Składa się on z pamięci i funkcji przejścia. Pamięć wyraża stan aktualny automatu, a funkcja przejścia determinuje (określa) stan następny.<br />
<br />
System iteracyjny:<br />
<br />
[[Plik:Sys_iteracyjny.png]]<br />
<br />
<div style="text-align:center;"><br />
'''MASZYNA OBLICZENIOWA = PAMIĘĆ + FUNKCJA PRZEJŚCIA'''<br />
<br />
'''FUNKCJA PRZEJŚCIA WYZNACZA STAN NASTĘPNY (NOWĄ ZAWARTOŚĆ PAMIĘCI)'''<br />
'''PROGRAMOWANIE = BUDOWANIE FUNKCJI PRZEJŚCIA'''</div><br />
<br />
Pawlak posługuje się przykładem kostki do gry.<br />
<br />
<div style="color:#ff0000;margin-left:2.499cm;margin-right:0cm;">Pomoc dydaktyczna: kostka do gry lub kostka Rubika</div><br />
<br />
<br />
[[Plik:Kostka.png]]<br />
<br />
Przykład programu:<br />
<br />
<br />
{| style="border-spacing:0;width:6.085cm;"<br />
|- style="border:none;padding:0cm;"<br />
|| STAN<br />
|| NASTĘPNY<br />
|- style="border:none;padding:0cm;"<br />
|| 1<br />
|| STOP<br />
|- style="border:none;padding:0cm;"<br />
|| 2<br />
|| STOP<br />
|- style="border:none;padding:0cm;"<br />
|| 3<br />
|| 1<br />
|- style="border:none;padding:0cm;"<br />
|| 4<br />
|| 2<br />
|- style="border:none;padding:0cm;"<br />
|| 5<br />
|| 1<br />
|- style="border:none;padding:0cm;"<br />
|| 6<br />
|| 2<br />
|-<br />
|}<br />
Pytanie: co ten program wylicza?<br />
<br />
Odpowiedź: zatrzymuje się na 1 lub 2 w zależności od tego, czy początkowo była ilość parzysta lub nieparzysta oczek.<br />
<br />
Pisząc program określamy warunki jego zatrzymania się. Najczęściej jest to zakończenie wykonywania algorytmu (zakończenie obliczeń). <br />
<br />
Zadanie domowe: zapoznać się z problemem stopu [https://pl.wikipedia.org/wiki/Problem_stopu https://pl.wikipedia.org/wiki/Problem_stopu]<br />
<br />
== Arkusz kalkulacyjny jako środowisko w którym uruchamiamy programy ==<br />
<br />
[[Plik:Arkusz.png]]<br />
<br />
'''KOMÓRKI = PAMIĘĆ'''<br />
'''REGUŁY = FUNKCJA PRZEJŚCIA'''<br />
<br />
== Zmienna ==<br />
<br />
W arkuszu kalkulacyjnym wiadomo gdzie zapisać wynik – w tej samej komórce, w której zapisano regułę. W programie musimy zarezerwować miejsce w pamięci. Komórka arkusza kalkulacyjnego ma swoją nazwę. W programie posługujemy się nazwą zmiennej (identyfikatorem).<br />
<br />
'''Nazwa komórki = identyfikator zmiennej'''<br />
<br />
Przykład identyfikatora w języku php: '''$a1 '''(użyto identyfikatora zgodnie z konwencją nazywania komórek w arkuszu kalkulacyjnym).<br />
<br />
Najprostsze programy to formuły w arkuszu.<br />
<br />
Na przykład: <br />
<br />
<nowiki>= $a1 + 10</nowiki><br />
<br />
Odpowiednia instrukcja w języku php:<br />
<br />
$wynik = $a1+10;<br />
<br />
Zarezerwowane dwa miejsca w pamięci – zmienne $a1 i $wynik<br />
<br />
== Algorytm a program ==<br />
<br />
Często spotyka się z wyjaśnieniem, że program jest implementacją algorytmu. Czyli takim zapisem algorytmu, by mogła go wykonać maszyna. To wyjaśnienie wymaga komentarza. Algorytmy jakie spotykamy na co dzień są najczęściej trywialne. Na przykład: aby otworzyć drzwi, włóż klucz do zamka, przekręć w prawo do oporu a następnie naciśnij klamkę.<br />
<br />
Jednak algorytmy bywają też bardzo trudne. Nawet najprostszy algorytm sortowania liczb wymaga odrobiny wysiłku intelektualnego, aby go zrozumieć. Naukę programowania często myli się z algorytmiką (czyli układaniem algorytmów), co jest trudne. Dla większości zadań z jakimi spotyka się programista ich trudność można porównać z algorytmem otwierania drzwi (sama czynność jest prostsza, niż jej ścisłe opisanie).<br />
<br />
Algorytmika jest trudna. Programowanie jest łatwe. Układanie i implementacja algorytmów wymaga wiedzy, umiejętności i talentu. Programować może każdy. I każdy, kto ma styczność z tworami nowoczesnej techniki to robi (choćby programując programy w telewizorze).<br />
<br />
[[Plik:Molier.png]]<br />
MOLIER „MIESZCZANIN SZLACHCICEM” (w oryginale bohater był zdziwiony, że mówi prozą!)<br />
<br />
== Podsumowanie ==<br />
<br />
* Programowanie komputerów wymaga abstrakcyjnego myślenia.<br />
* Układamy algorytmy i zapisujemy je przy pomocy abstrakcyjnych symboli.<br />
* Programy są uruchamiane w środowisku tworzącym system obliczeniowy.<br />
* Istotę działania takiego systemu wyjaśnia system iteracyjny.<br />
* Najprostszym środowiskiem jest arkusz kalkulacyjny.<br />
* Przechodząc od arkusza do zwykłych programów – wprowadzamy pojęcie zmiennej (zastępujące komórkę arkusza).<br />
* Programowanie nie jest trudne! Programy pisze każdy użytkownik arkusza kalkulacyjnego (a nawet gdy tylko układa w myśli plan działania)! Trudne natomiast może być układanie algorytmów (czym zajmuje się algorytmika).</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=141Algorytm Simplex2022-09-25T08:58:51Z<p>Admin: </p>
<hr />
<div>= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe <ref>https://www.snopes.com/fact-check/the-unsolvable-math-problem/ </ref>), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
[[Plik:Równania liniowe.png|ramka|alt=Przykład 1|Przykład 1]]<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html ):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości<br />
<br />
mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: http://smurf.mimuw.edu.pl/node/1121 >'''''<br />
<br />
'''Algorytm opisany przez tego samego autora: '' http://smurf.mimuw.edu.pl/node/1122 '''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
'''1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:'''<br />
<br />
'''x1*4 + x2*2 - x3 = 250'''<br />
<br />
'''x1*3 + x2*6 - x4 = 300'''<br />
<br />
'''x1*12 + x2*15 → max'''<br />
<br />
'''x1, x2, x3, x4 >= 0'''<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
[[Plik:Simplex - ilość.png|mały]]<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
b=[100,-10]<br />
c=[3,4,0,0]<br />
<br />
</syntaxhighlight><br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
<nowiki><br />
<br />
A | b<br />
<br />
------<br />
<br />
c | 0<br />
<br />
</nowiki><br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
S=[<br />
[-1, 2, 1, 0, 100],<br />
[1, -0.5, 0, 1, - 10],<br />
[-3,-4,0,0,0]<br />
]<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki><br />
<br />
--------------<br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
</nowiki><br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
[[Plik:Simplex - przykład 3.png|ramka]]<br />
<br />
rysunek dzięki https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html<br />
<br />
<syntaxhighlight lang="python" line start="1" ><br />
<br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
b = [4, 9, 3]<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
druk_tabeli(S)<br />
print('wybrany wiersz 0 kolumna 0:')<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 1 kolumna 1:')<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
druk_tabeli(S)<br />
print('wybrany wiersz 2 kolumna 2:')<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
druk_tabeli(S)<br />
<br />
</syntaxhighlight><br />
<br />
<br />
rozwiązanie:<br />
<br />
<nowiki><br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
--------------<br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
--------------<br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
--------------<br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
</nowiki><br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Plik:Simplex_-_ilo%C5%9B%C4%87.png&diff=140Plik:Simplex - ilość.png2022-09-25T08:57:46Z<p>Admin: </p>
<hr />
<div>Ilość kombinacji</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Plik:Simplex_-_przyk%C5%82ad_3.png&diff=139Plik:Simplex - przykład 3.png2022-09-25T08:55:15Z<p>Admin: </p>
<hr />
<div>Przykład 3</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Plik:R%C3%B3wnania_liniowe.png&diff=138Plik:Równania liniowe.png2022-09-25T08:50:20Z<p>Admin: </p>
<hr />
<div>Przykład równań / nierówności liniowych</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Elementy_j%C4%99zykoznawstwa_dla_programist%C3%B3w&diff=135Elementy językoznawstwa dla programistów2022-09-25T07:55:08Z<p>Admin: </p>
<hr />
<div>{|<br />
|-<br />
| |Moduł: Elementy językozawstwa dla programistów <br />
|-<br />
| |Poziom: Zaawanowany<br />
|-<br />
| |Profil: Dla profesjonalistów<br />
|-<br />
|}<br />
<br />
<br />
Każda wypowiedź ma swoją strukturę, którą określamy terminem „[https://pl.wikipedia.org/wiki/Syntaktyka_(językoznawstwo syntaktyka]” lub składnia, oraz swoje znaczenie określane terminem „[https://pl.wikipedia.org/wiki/Semantyka_(językoznawstwo) semantyka]”. Obydwie te dziedziny są przedmiotem zainteresowania informatyki – ale ich znaczenie jest zupełnie różne. Semantyka to przedmiot badania sztucznej inteligencji (komunikacja w języku naturalnym, przetwarzanie wiedzy) oraz filozofii informatyki. Badania syntaktyki zostały natomiast wykorzystywane w rozwoju języków programowania.<br />
<br />
[[Plik:j_gr2.png]]<br />
<br />
Analizy językoznawców wykazały, że zdania dowolnego języka daje się opisać w postaci reguł budowania złożonych wypowiedzi z prostszych struktur. Proces generacji zdań nazywa się też procesem „wywodu”. <br />
<br />
Przykład:<br />
<br />
[[Plik:j_gr3.png]]<br />
<br />
Powstała struktura ma kształt odwróconego drzewa. Dlatego nazywa się ją „drzewem wywodu”.<br />
<br />
<br />
== Gramatyka struktur frazowych ==<br />
Językoznawca [https://pl.wikipedia.org/wiki/Noam_Chomsky Noam Chomsky] stworzył teorię zwaną gramatyką generatywną (lub gramatyką struktur frazowych) opisującą ten proces generacji (dla zdań w formie podstawowej). Informatycy podążyli dalej w tym kierunku tworząc sztuczne języki i automaty je analizujące (translatory). Podstawą była formalizacja teorii gramatyk, którą w zarysie przedstawiono poniżej.<br />
<br />
Gramatyka składa się z: * zbioru symboli terminalnych T (symboli wchodzących w skład wygenerowanych zdań); <br />
* zbioru symboli nieterminalnych N (zbiór symboli pomocniczych służących do przeprowadzenia generacji, oznacza się je często przez ujęcie w nawiasy ostre <...> <nowiki>= zob. </nowiki>[https://pl.wikipedia.org/wiki/Notacja Notacja][https://pl.wikipedia.org/wiki/Notacja_BNF BNF]); <br />
* symbolu początkowego S (wyróżniony symbol nieterminalny od którego rozpoczyna się wywód); <br />
* reguł wywodu pozwalających na zastępowanie symboli nieterminalnych przez ciągi symboli terminalnych i nieterminalnych aż do otrzymania samych symboli terminalnych; <br />
<br />
<br />
<br />
<u>'''Przykład:'''</u><br />
<br />
Dla zdania na powyższym obrazku można zaproponować gramatykę:<br />
<br />
<nowiki><br />
T = { Jan, Zosia, trzyma, ma, czapka, pióro } <br />
N = { <zdanie>, <fraza rzeczownika>, <fraza czasownika>, <rzeczownik>, <czasownik> } <br />
S = <zdanie> <br />
<br />
reguły wywodu ( ::= oznacza operację zastępowania): <br />
<br />
(1) <zdanie> ::= <fraza rzeczownika><fraza czasownika> <br />
(2) <fraza rzeczownika> ::= <rzeczownik> <br />
(3) <fraza czasownika> ::= <czasownik><fraza rzeczownika> <br />
(4) <rzeczownik> ::= Jan | Zosia | czapka | pióro (5) <czasownik> ::= trzyma | ma <br />
</nowiki><br />
<br />
Znak '|' oznacza alternatywę - np. można użyć reguły ''<czasownik> ::= trzyma'' lub ''<czasownik> ::= ma''<br />
<br />
Wywód przykładowego zdania ( w nawiasach podano numery użytych reguł ): <br />
<br />
<br />
S '''-(1)-> '''<fraza rzeczownika> <fraza czasownika> '''-(2)-> '''<rzeczownik><fraza czasownika> '''-(4)-> '''Zosia <fraza czasownika> '''-(3)->''' Zosia <czasownik> <fraza rzeczownika> '''-(5)->''' Zosia ma <fraza rzeczownika> '''-(2)->''' Zosia ma <rzeczownik> '''-(4)-> '''Zosia ma pióro <br />
<br />
<br />
Powyższy wywód można przedstawić w postaci drzewo wywodu, pokazanego na powyższym rysunku. Przy analizie drzewo wywodu nazywane jest też drzewem rozkładu (w jaki sposób zdanie rozkładamy na jego reprezentację). Drzewo to służy następnie wygenerowaniu kodu programu - wykonywanego przez komputer.<br />
<br />
Liście tego drzewa stanowią symbole terminalne. Każde poddrzewo drzewa wywodu nazywa się frazą. Ze względu na typ użytych reguł wywodu, gramatyki dzieli się na: <br />
* <u>regularne</u>: wszystkie reguły są w postaci A ::= aB, lub A ::= a, gdzie A, B - oznaczają symbole nieterminalne, a - symbol terminalny; <br />
* <u>bezkontekstowe</u>: daje się sprowadzić do zbioru takich reguł, że po lewej stronie każdej reguły wywodu znajduje się pojedynczy symbol nieterminalny (zob. [https://pl.wikipedia.org/wiki/Postać_normalna_Greibach postać normalna Greibach])<nowiki>; </nowiki><br />
* <u>kontekstowe</u>: reguły wywodu mogą być dowolnej postaci; <br />
<br />
<br />
<br />
Mniej formalnie można powiedzieć, że gramatyka bezkontekstowa to taka, że przy analizie wypowiedzi można na podstawie wczytanych symboli dokładnie ustalić którą regułę wywodu należy zastosować. <br />
<br />
Zależnie od gramatyki jaka jest konieczna do wygenerowania zdań języka mówimy o językach regularnych, bezkontekstowych i kontekstowych. <br />
<br />
Gramatyki regularne opisują między innymi budowę poszczególnych elementów używanych w językach programowania komputerów (identyfikatory, liczby, słowa kluczowe). Instrukcje języków takich jak Pascal pochodzą z języków bezkontekstowych. W praktyce analiza języków programowania odbywa się dwustopniowo. Najpierw tzw. skaner wydziela z wejściowego łańcucha znaków 'tokeny', czyli wspomniane wcześniej proste elementy znaczeniowe. Później 'parser' analizuje ciąg tokenów tworząc z nich instrukcje języka. Skaner jest zazwyczaj automatem implementującym gramatykę regularną.<br />
<br />
== Języki regularne. Automaty. ==<br />
<br />
Tokeny (liczby, napisy, słowa kluczowe), na które skaner dzieli przetwarzany ciąg znaków mają strukturę, którą można opisać gramatyką języków regularnych. Najbardziej naturalną metodą zapisywania konstrukcji języka regularnego są wyrażenia regularne. Użycie znaku * w tym wyrażeniu oznacza powtórzenie >=0 ilość razy poprzedzającego go symbolu.<br />
<br />
Przykład: <br />
<br />
<br />
{| style="margin:auto;"<br />
|-<br />
| style="background-color:#e6e6e6;border:0.05;" | wyrażenie&nbsp;<br />
| style="background-color:#e6e6e6;border:0.05pt;" | przykłady użycia&nbsp;<br />
|-<br />
| style="border:0.05pt;" | xy*z&nbsp;<br />
| style="border:0.05pt;;" | &nbsp;xyyz, xz, xyyyz<br />
|-<br />
| style="border:0.05pt;" | (xy)*z*&nbsp;<br />
| style="border:0.05pt;" | xyxyzzzz, xyzzzz&nbsp;<br />
|-<br />
|}<br />
<br />
<br />
Analizę języków regularnych wygodnie jest opisywać (a niekiedy także implementować) jako działanie automatów skończenie-stanowych. Automat skończenie-stanowy to zbiór stanów połączonych ze sobą przy pomocy etykietowanych symbolami łuków (lub innych połączeń). Wyróżniany jest jeden stan jako stan początkowy i zbiór stanów końcowych. <br />
<br />
Zadaniem automatu jest analiza ciągu znaków. Jego działanie polega na przechodzeniu od stanu do stanu począwszy od stanu początkowego. Przejście jest możliwe, o ile analizowany symbol (znak) jest identyczny z definicją (etykietą) przejścia. Po przejściu pobierany jest do analizy następny symbol (znak). Jeśli po przetworzeniu całego ciągu znaków automat znajdzie się w stanie końcowym, ciąg należy do języka regularnego (jest akceptowalny przez automat), a stan końcowy wskazuje na to, co ciąg ten oznacza. <br />
<br />
'''Przykład: '''<br />
<br />
[[Plik:j_gr1.png]]<br />
<br />
Automat akceptujący ciąg symboli: a, ab*, lub ab*c oznaczenia:* okrąg oznacza stan początkowy <br />
* prostokąty z okrągłymi rogami (niebieskie) - oznaczają stany końcowe <br />
* prostokąty(pomarańczowe) - pozostałe stany <br />
<br />
<br />
<br />
Uzupełnieniem tego niniejszego są programy z repozytorium [https://github.com/galicea/eduprog https://github.com/galicea/eduprog]. W podkatalogu lang można znaleźć program '''autogram''', który tworzy automat na podstawie wyrażeń regularnych. Wywołanie dla powyższego przykładu: <br />
<br />
'''autogram -a -i "a(&b&)@'''c"<br />
<br />
<br />
W wyniku analizy otrzymujemy tabelkę przejść:<br />
<br />
<br />
<br />
{| style="margin:auto;"<br />
| style="background-color:#e6e6e6;border:0.05;" | | a | b | c<br />
|-<br />
| style="padding:2pt;border:0.05;" | 1 | 2| 0| 0<br />
|-<br />
| style="padding:2pt;border:0.05;"| 2 | 0| 2| 3<br />
|-<br />
| style="padding:2pt;border:0.05;"| 3 | 0| 0| 0<br />
|}<br />
<br />
<br />
W wierszach są zawarte stany automatu, a w kolumnach symbole wyrażenia. Kolumny opisują do którego stanu automat przejdzie po wczytaniu symbolu. Na przykład w stanie 2 symbol '''b '''powoduje pozostanie w tym samym stanie, a symbol '''c - '''przejście do końcowego stanu 3 (gdzie już nic nie można przyjąć).<br />
<br />
== Gramatyki bezkontekstowe ==<br />
<br />
Aby utworzyć drzewo wywodu dla dowolnego zdania zbudowanego w oparciu o gramatykę należałoby po kolei próbować zastosować wszystkie produkcje (poddrzewa), wracając w razie niepowodzenia do wcześniejszego stadium analizy. Ten sposób analizy (analiza z powrotami) jest jednak bardzo nieefektywny. W praktyce na gramatyki bezkontekstowe nakłada się dodatkowe ograniczenia pozwalające jednoznacznie wskazać którą produkcję należy wybrać na podstawie: * dotychczasowego przebiegu analizy (stanu w którym znajduje się analizator (automat)); <br />
* k symboli na wejściu (w praktyce prawie zawsze k=1); <br />
<br />
<br />
<br />
Analiza lewostronna (wywód lewostronny) polega na tym, że czytamy kolejne symbole i na tej podstawie decydujemy jaką regułę zastosować. Potrzebna do tego gramatyka jest określana mianem [https://pl.wikipedia.org/wiki/Parser_LL LL(1)] – dla podkreślenia, że chodzi o 1 symbol z lewej strony drzewa wywodu. Taką gramatykę zastosowano w języku Pascal. Drugą metodą analizy jest analiza prawostronna. Polega ona na tym, że wczytujemy kolejne symbole aż do chwili, gdy skompletujemy wszystkie symbole potrzebne do zastosowania reguły wywodu. Decyduje o tym zawsze ostatni wczytany symbol – czyli symbol z prawej strony drzewa wywodu. Stąd określenie [https://pl.wikipedia.org/wiki/Parser_LR LR(1)]. <br />
<br />
== Gramatyki LL(1) ==<br />
<br />
Gramatyka LL(1) ma tą własność, że każdą produkcję można zidentyfikować na podstawie pierwszego z lewej symbolu po prawej jej stronie. Gramatyki tego typu są najczęściej stosowane przy 'ręcznym' konstruowaniu analizatora. Stosuje się przy tym analizę rekurencyjną. Polega ona na tym, że dla każdej produkcji tworzy się procedurę ją analizującą. Procedury te identyfikują i wywołują odpowiednie procedury dla zanalizowania podfrazy. Dokładny opis tej metody analizy można znaleźć w podręczniku N.Wirtha [2]. <br />
<br />
Poniżej prosty przykład kalkulatora wyrażeń w języku Python, który zawiera analizator LL(1). W przykładzie założono, że liczby są dodatnie jednocyfrowe, a dostępne działania to tylko mnożenie i dodawanie. Dzięki temu skaner (next_token) to tylko pobieranie kolejnego znaku (znak dolara oznacza koniec wejścia a wykrzyknik błąd). Proszę zauważyć, że wystarczy zawsze sprawdzić jaki jest kolejny token, by zdecydować o następnym kroku analizy. Ta stosunkowo prosta zasada sprawia, że analizatory LL(1) można zaimplementować ‘ręcznie’ - bez programów wspierających – takich jak [https://pl.wikipedia.org/wiki/Yacc Yacc] czy [https://www.gnu.org/software/bison/ Bison].<br />
<br />
<syntaxhighlight lang="python" line="1" ><br />
<br />
class calculator():<br />
source=[]<br />
digits = ('0','1','2','3','4','5','6','7','8','9')<br />
result=0<br />
token='!'<br />
<br />
def next_token(self):<br />
if len(self.source)==0:<br />
self.token='$'<br />
else:<br />
self.token=self.source[0]<br />
del self.source[0]<br />
<br />
def factor(self): # czynnik<br />
self.result=0<br />
if self.token=='(':<br />
self.next_token()<br />
self.expr()<br />
if self.token != ')':<br />
self.token='!'<br />
else:<br />
self.next_token()<br />
elif self.token in self.digits:<br />
self.result=int(self.token)<br />
self.next_token()<br />
<br />
def term(self): # skladnik<br />
self.factor()<br />
mem=self.result<br />
while self.token=='*':<br />
self.next_token()<br />
self.factor()<br />
mem=mem*self.result<br />
self.result=mem<br />
<br />
def expr(self):<br />
self.result=0<br />
self.term()<br />
mem=self.result<br />
while (self.token=='+'):<br />
self.next_token()<br />
self.term()<br />
mem=mem+self.result<br />
self.result=mem<br />
<br />
def calc(self,expression):<br />
self.source=list(expression)<br />
self.next_token()<br />
self.expr()<br />
if self.token=='$':<br />
return self.result<br />
else:<br />
return None<br />
<br />
</syntaxhighlight><br />
<br />
Przykładowe użycie kalkulatora:<br />
<br />
<syntaxhighlight lang="python" line="1" ><br />
<br />
c=calculator()<br />
res=c.calc('4*(2+3)')<br />
if res != None:<br />
print(res)<br />
else:<br />
print('error')<br />
<br />
</syntaxhighlight><br />
<br />
'''Gramatyki LR(1) '''<br />
<br />
W przeciwieństwie do poprzedniej, tą gramatykę stosuje się najczęściej przy użyciu generatorów przy pomocy których konstruuje się analizator. Pouczającym może być analiza takiego generatora. W repozytorium [https://github.com/galicea/eduprog https://github.com/galicea/eduprog], w podkatalogu lang znajduje się moduł u_makerl1 i program autogram wykorzystujący ten moduł generatora. Oprogramowanie jest napisane w języku Pascal (z polskimi komentarzami). Może więc być łatwiejsze w analizie (zwłaszcza, że poniżej podano szczegółowe objaśnienie algorytmu), niż rozbudowane generatory wspomniane wcześniej. <br />
<br />
=== Metoda analizy ===<br />
<br />
Analizator jest automatem ze stosem. Oznacza to, że zawiera on pamięć w postaci stosu do której może dopisywać dane dotyczące aktualnego stanu (wkładanie na stos). Możliwe jest także odczytywanie danych w kolejności odwrotnej do tej w jakiej były zapisywane (zdejmowanie ze stosu). Automat pobiera kolejne symbole, wkłada je na stos i zmienia swój stan. Bieżący stan automatu jest zapisywany na stosie wraz z symbolem. Stan automatu opisuje całą zawartość stosu. Jeśli stan ten wskazuje, że na stosie jest pełna fraza - następuje redukcja. Polega ona na zdjęciu ze stosu symboli składających się na tą frazę i zastąpieniu ich symbolem nieterminalnym będący lewą stroną produkcji dającej taką frazę. <br />
<br />
Dzięki pamiętaniu stanu na stosie - po redukcji można ustalić nowy stan automatu. Stan zapisany na wierzchołku stosu opisuje bowiem całą jego zawartość i możemy ustalić jaki stan powstanie po dodaniu nowego symbolu. <br />
<br />
Analiza kończy się poprawnie, gdy pojawi się symbol sygnalizujący koniec danych, a na stosie znajduje się symbol początkowy gramatyki. <br />
<br />
Gramatyka dla takiej metody analizy musi spełniać jeden warunek: prawe części żadnych dwóch produkcji nie mogą być jednakowe (trzeba wiedzieć w oparciu o którą produkcję dokonać analizy). <br />
<br />
Ponieważ w trakcie analizy badamy zawsze jeden - ostatni z prawej symbol wywodu - metoda ta, oraz gramatyka noszą nazwę LR(1). <br />
<br />
=== Algorytm tworzenia automatu LR(1) ===<br />
<br />
1/ Ułożyć gramatykę LR(1) języka. Ponumerować wszystkie produkcje. <br />
<br />
2/ Spisać wszystkie możliwe stany automatu. Jeśli dowolną produkcję można przedstawić w postaci X::=PS, to P jest jednym z możliwych stanów automatu. <br />
<br />
3/ Utworzyć funkcję zmiany stanu stosu przy akceptacji tokenów. Rozróżniamy dwa rodzaje operacji: przesunięcie i redukcja. Przesunięcie polega na dodaniu tokenu na stos. Po przesunięciu pobierany jest następny token. Redukcja polega na zdjęciu ze stosu pełnej frazy.<br />
<br />
<br />
'''PRZESUNIĘCIE:''' <br />
<br />
1) Jeśli istnieją stany stosu PQ i Qt, to dla tokenu t istnieje przejście od stanu PQ do stanu Qt; (oznacza to przejście do analizy podfrazy będącej bardziej z prawej strony).<br />
<br />
2) Jeśli nie zachodzi przypadek 1 - badamy zamiast t wszystkie symbole z których t można wyprowadzić lewostronnie. Oznacza to że jeśli istnieją stany PQ i z QR, oraz z R można wyprowadzić lewostronnie t, to dla tokenu t istnieje przejście od stanu PQ do stanu t;<br />
<br />
'''REDUKCJA: '''<br />
<br />
Dla każdego stanu stosu PQ szukamy najdłuższego łańcucha Q spełniającego warunki: - istnieje produkcja (reguła gramatyczna) r, dla której Q stanowi prawą stronę; - istnieje stan Pl(r), gdzie l(r) oznacza lewą stronę produkcji r; Redukcja r jest wykonywana w sytuacji, gdy przy stanie PQ pojawi się token, dl którego nie można dokonać przesunięcia.# Utworzyć funkcję przejścia do nowego stanu przy redukcji. Jeśli po dołączeniu do stanu ze szczytu stosu lewej strony produkcji r otrzymamy poprawny stan - jest to stan do którego następuje przejście automatu. Jeśli taki stan nie istnieje - następuje próba zanalizowania nowej frazy. Ustalany jest nowy stan opisujący lewą stronę użytej produkcji.<br />
<br />
4/ Zbudować automat działający wg. zasady:<br />
<br />
<syntaxhighlight lang="pascal"><br />
<br />
repeat <br />
PobierzNastępnySymbol; <br />
if symbol=znacznikKońcaDanych i na stosie znajduje się symbol początkowy then <br />
koniec <br />
else if dla danego tokenu, oraz aktualnego stanu stosu <br />
istnieje przejście zgodne z funkcja przejścia (pkt. 3) then <br />
włóż symbol na stos z zaznaczeniem nowego stanu <br />
else if istnieje produkcja której prawa strona jest zawarta aktualnie na stosie then <br />
wykonaj redukcję, zmieniając stan na wskazany przez funkcję przejścia zbudowaną w pkt. 4 <br />
else <br />
wystapił błąd <br />
until błąd lub koniec;<br />
<br />
</syntaxhighlight><br />
<br />
<br />
Szczegółowy opis gramatyk LR(1) można znaleźć w pracy [1].<br />
<br />
== Przykład ==<br />
<br />
Programem autogram, który zawiera opisany powyżej generator stworzono automat analizujący proste wyrażenia arytmetyczne:<br />
<br />
gramatyka (plik gram.lr1): <br />
<br />
<nowiki><br />
gramatyka (plik gram.lr1): stany: <br />
1: <Z> ::= <W> 1 : <W> <br />
2: <W> ::= <W> + <A> 2 : <W>+ <br />
3: <W> ::= <W> - <A> 3 : <W>+<A> <br />
4: <W> ::= <A> 4 : <W>- <br />
5: <A> ::= <A> * <A> 5 : <W>-<A> <br />
6: <A> ::= <A> / <A> 6 : <A> <br />
7: <A> ::= <B> 7 : <A>* <br />
8: <B> ::= + <C> 8 : <A>*<A> <br />
9: <B> ::= - <C> 9 : <A>/ <br />
10: <B> ::= <C> 10 : <A>/<A> <br />
11: <C> ::= ( <W> ) 11 : <B> <br />
12 : <C> ::= NUM 12 : +<br />
13 : +<C> <br />
14 : - <br />
15 : -<C> <br />
16 : <C> <br />
17 : ( <br />
18 : (<W> <br />
19 : (<W>) <br />
20 : NUM <br />
</nowiki><br />
<br />
<br />
Fragmenty tablic sterujących działaniem automatu:<br />
<nowiki><br />
analiza: <br />
| tokeny <br />
stan: | + - * / ( NUM EOIN <br />
------+-------------------------------------------<br />
0 | 12 14 17 20 <br />
1 | 2 4 <br />
2 | 12 14 17 20 <br />
3 | -2 -2 7 9 -2 -2 -2 <br />
<br />
liczbami dodatnimi oznaczono nowe stany przy przesunięciu, a ujemnymi numery produkcji użytych do redukcji. <br />
EOI = znacznik końca danych <br />
nowe stany po dokonaniu redukcji: <br />
numer | stan <br />
produkcji | 1 2 3 ...... 16 17 18 <br />
----------+--------------------------------------<br />
2 | 1 1 1 1 18 1 <br />
</nowiki><br />
<br />
Zauważ że generator tworzy pewną nadmiarowość. Wynik jego działania można poprawić usuwając dane dotyczące stanów przez które automat nie powinien przechodzić (na przykład w stanie 3 nie może pojawić się symbol '('). Ten automat wykonuje działania tak długo jak to jest możliwe, zamiast zatrzymywać się przy pierwszej nieprawidłowości. <br />
<br />
Na podstawie tego automatu stworzono moduł kalkulatora KALK_LR1.PAS. Dla porównania analogiczny kalkulator zbudowano w oparciu o gramatykę LL(1): KALK_LL1.PAS<br />
<br />
== Bibliografia ==<br />
<br />
# W.M. Waite, G. Goos ''"Konstrukcja kompilatorów"'' <br />
# N. Wirth ''"Algorytmy+struktury danych = programy". ''</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=134Algorytm Simplex2022-09-25T07:52:11Z<p>Admin: /* Równania i nierówności liniowe */</p>
<hr />
<div><br />
= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe[[Algorytm Simplex#sdfootnote1sym|<sup>1</sup>]]), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz <nowiki>https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html</nowiki>):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
for i,x in enumerate(S[wiersz]):<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
for i,x in enumerate(S[wiersz2]):<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
</syntaxhighlight><br />
<br />
Na naszym przykładzie:<br />
<br />
<syntaxhighlight lang="python"><br />
<br />
S = [[-1, 2, 100],[1, -0.5, - 10],]<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
</syntaxhighlight><br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
<syntaxhighlight lang="python"><br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
</syntaxhighlight><br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości<br />
<br />
mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: <nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''''<br />
<br />
'''Algorytm opisany przez tego samego autora: ''<nowiki>http://smurf.mimuw.edu.pl/node/1122</nowiki>'''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
'''1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:'''<br />
<br />
'''x1*4 + x2*2 - x3 = 250'''<br />
<br />
'''x1*3 + x2*6 - x4 = 300'''<br />
<br />
'''x1*12 + x2*15 → max'''<br />
<br />
'''x1, x2, x3, x4 >= 0'''<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4,0,0]<br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
A | b<br />
<br />
<nowiki>------</nowiki><br />
<br />
c | 0<br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
S=[<br />
<br />
[-1, 2, 1, 0, 100],<br />
<br />
[1, -0.5, 0, 1, - 10],<br />
<br />
[-3,-4,0,0,0]<br />
<br />
]<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
r<br />
<br />
ysunek dzięki <nowiki>https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html</nowiki><br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 0 kolumna 0:')<br />
<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 1 kolumna 1:')<br />
<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 2 kolumna 2:')<br />
<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
<br />
druk_tabeli(S)<br />
<br />
rozwiązanie:<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=133Algorytm Simplex2022-09-25T07:48:07Z<p>Admin: Algorytm Simplex</p>
<hr />
<div><br />
= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe[[Algorytm Simplex#sdfootnote1sym|<sup>1</sup>]]), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz <nowiki>https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html</nowiki>):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
<br />
for i,x in enumerate(S[wiersz]):<br />
<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
<br />
for i,x in enumerate(S[wiersz2]):<br />
<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
Na naszym przykładzie:<br />
<br />
S = [<br />
<br />
[-1, 2, 100],<br />
<br />
[1, -0.5, - 10],<br />
<br />
]<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości<br />
<br />
mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: <nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''''<br />
<br />
'''Algorytm opisany przez tego samego autora: ''<nowiki>http://smurf.mimuw.edu.pl/node/1122</nowiki>'''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
'''1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:'''<br />
<br />
'''x1*4 + x2*2 - x3 = 250'''<br />
<br />
'''x1*3 + x2*6 - x4 = 300'''<br />
<br />
'''x1*12 + x2*15 → max'''<br />
<br />
'''x1, x2, x3, x4 >= 0'''<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
'''Każdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: http://smurf.mimuw.edu.pl/node/1121<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4,0,0]<br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
A | b<br />
<br />
<nowiki>------</nowiki><br />
<br />
c | 0<br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
S=[<br />
<br />
[-1, 2, 1, 0, 100],<br />
<br />
[1, -0.5, 0, 1, - 10],<br />
<br />
[-3,-4,0,0,0]<br />
<br />
]<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
r<br />
<br />
ysunek dzięki <nowiki>https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html</nowiki><br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 0 kolumna 0:')<br />
<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 1 kolumna 1:')<br />
<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 2 kolumna 2:')<br />
<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
<br />
druk_tabeli(S)<br />
<br />
rozwiązanie:<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=132Algorytm Simplex2022-09-25T07:31:31Z<p>Admin: </p>
<hr />
<div><br />
= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe[[Algorytm Simplex#sdfootnote1sym|<sup>1</sup>]]), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz <nowiki>https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html</nowiki>):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
<syntaxhighlight lang="python" line><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
<br />
for i,x in enumerate(S[wiersz]):<br />
<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
<br />
for i,x in enumerate(S[wiersz2]):<br />
<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
Na naszym przykładzie:<br />
<br />
S = [<br />
<br />
[-1, 2, 100],<br />
<br />
[1, -0.5, - 10],<br />
<br />
]<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości<br />
<br />
mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: <nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''''<br />
<br />
'''Algorytm opisany przez tego samego autora: ''<nowiki>http://smurf.mimuw.edu.pl/node/1122</nowiki>'''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
'''1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:'''<br />
<br />
'''x1*4 + x2*2 - x3 = 250'''<br />
<br />
'''x1*3 + x2*6 - x4 = 300'''<br />
<br />
'''x1*12 + x2*15 → max'''<br />
<br />
'''x1, x2, x3, x4 >= 0'''<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
'''K'''<br />
<br />
'''ażdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: '''<nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4,0,0]<br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
A | b<br />
<br />
<nowiki>------</nowiki><br />
<br />
c | 0<br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
S=[<br />
<br />
[-1, 2, 1, 0, 100],<br />
<br />
[1, -0.5, 0, 1, - 10],<br />
<br />
[-3,-4,0,0,0]<br />
<br />
]<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
r<br />
<br />
ysunek dzięki <nowiki>https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html</nowiki><br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 0 kolumna 0:')<br />
<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 1 kolumna 1:')<br />
<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 2 kolumna 2:')<br />
<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
<br />
druk_tabeli(S)<br />
<br />
rozwiązanie:<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=131Algorytm Simplex2022-09-25T07:19:45Z<p>Admin: </p>
<hr />
<div><br />
= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe[[Algorytm Simplex#sdfootnote1sym|<sup>1</sup>]]), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz <nowiki>https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html</nowiki>):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<syntaxhighlight lang="python"><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
</syntaxhighlight><br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
<br />
for i,x in enumerate(S[wiersz]):<br />
<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
<br />
for i,x in enumerate(S[wiersz2]):<br />
<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
Na naszym przykładzie:<br />
<br />
S = [<br />
<br />
[-1, 2, 100],<br />
<br />
[1, -0.5, - 10],<br />
<br />
]<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości<br />
<br />
mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: <nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''''<br />
<br />
'''Algorytm opisany przez tego samego autora: ''<nowiki>http://smurf.mimuw.edu.pl/node/1122</nowiki>'''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
'''1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:'''<br />
<br />
'''x1*4 + x2*2 - x3 = 250'''<br />
<br />
'''x1*3 + x2*6 - x4 = 300'''<br />
<br />
'''x1*12 + x2*15 → max'''<br />
<br />
'''x1, x2, x3, x4 >= 0'''<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
'''K'''<br />
<br />
'''ażdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: '''<nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4,0,0]<br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
A | b<br />
<br />
<nowiki>------</nowiki><br />
<br />
c | 0<br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
S=[<br />
<br />
[-1, 2, 1, 0, 100],<br />
<br />
[1, -0.5, 0, 1, - 10],<br />
<br />
[-3,-4,0,0,0]<br />
<br />
]<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
r<br />
<br />
ysunek dzięki <nowiki>https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html</nowiki><br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 0 kolumna 0:')<br />
<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 1 kolumna 1:')<br />
<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 2 kolumna 2:')<br />
<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
<br />
druk_tabeli(S)<br />
<br />
rozwiązanie:<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=130Algorytm Simplex2022-09-25T07:10:37Z<p>Admin: </p>
<hr />
<div><br />
= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe[[Algorytm Simplex#sdfootnote1sym|<sup>1</sup>]]), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz <nowiki>https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html</nowiki>):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
```<br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
```<br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
<br />
for i,x in enumerate(S[wiersz]):<br />
<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
<br />
for i,x in enumerate(S[wiersz2]):<br />
<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
Na naszym przykładzie:<br />
<br />
S = [<br />
<br />
[-1, 2, 100],<br />
<br />
[1, -0.5, - 10],<br />
<br />
]<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości<br />
<br />
mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: <nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''''<br />
<br />
'''Algorytm opisany przez tego samego autora: ''<nowiki>http://smurf.mimuw.edu.pl/node/1122</nowiki>'''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
'''1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:'''<br />
<br />
'''x1*4 + x2*2 - x3 = 250'''<br />
<br />
'''x1*3 + x2*6 - x4 = 300'''<br />
<br />
'''x1*12 + x2*15 → max'''<br />
<br />
'''x1, x2, x3, x4 >= 0'''<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
'''K'''<br />
<br />
'''ażdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: '''<nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4,0,0]<br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
A | b<br />
<br />
<nowiki>------</nowiki><br />
<br />
c | 0<br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
S=[<br />
<br />
[-1, 2, 1, 0, 100],<br />
<br />
[1, -0.5, 0, 1, - 10],<br />
<br />
[-3,-4,0,0,0]<br />
<br />
]<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
r<br />
<br />
ysunek dzięki <nowiki>https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html</nowiki><br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 0 kolumna 0:')<br />
<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 1 kolumna 1:')<br />
<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 2 kolumna 2:')<br />
<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
<br />
druk_tabeli(S)<br />
<br />
rozwiązanie:<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
[[Plik:Simplex2.ods|mały|Tablica simplex w arkuszu kalkulacyjnym]]<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Plik:Simplex2.ods&diff=129Plik:Simplex2.ods2022-09-25T07:06:34Z<p>Admin: </p>
<hr />
<div>Przykład tablicy Simplex w arkuszu kalkulacyjnym</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytm_Simplex&diff=128Algorytm Simplex2022-09-25T06:56:52Z<p>Admin: Publikacja artykułu</p>
<hr />
<div><br />
= '''Algorytm Simplex''' =<br />
Algorytm Simplex jest fascynujący z wielu względów. Począwszy od jego twórcy (to on jest tym studentem z anegdoty, który rozwiązał bardzo trudny problem, sądząc, że to zadanie domowe[[Algorytm Simplex#sdfootnote1sym|<sup>1</sup>]]), a skończywszy na współczesnych opisach algorytmu. Co w nich jest fascynującego? Zanim przejdziesz dalej – spróbuj znaleźć w internecie jakiś opis i zrozumieć na jego podstawie, jak ten algorytm działa i dlaczego. Wspomniane opis można z grubsza podzielić na dwie grupy: opis „techniczny” wyjaśnia jakie działania wykonać na danych, aby osiągnąć wynik. Opis teoretyczny zaś wyjaśnia proste zasady, które Simplex wykorzystuje w taki sposób, że bez studiowania algebry wyższej nie jesteś w stanie tego pojąć. Ewidentnie brakuje informacji, które pozwoliłyby nie tylko używać algorytmu, albo pisać naukowe dzieła na jego temat, ale po prostu go zrozumieć. Mam nadzieję, że poniższy tekst wypełni ten brak.<br />
<br />
== '''Problem programowania liniowego''' ==<br />
Mamy zbiór warunków (ograniczeń) określonych przez nierówności liniowe oraz funkcję celu, zdefiniowaną także w postaci równania liniowego. Chcemy znaleźć rozwiązanie spełniające warunki ograniczeń i maksymalizujące (lub minimalizujące) funkcję celu – definiowaną także jako funkcja liniowa.<br />
<br />
Na przykład produkujemy kosmetyki p1 i p2, które mają składy (liczone w porcjach):<br />
<br />
dla p1: s1*4+s2*3<br />
<br />
dla p2: s1*2+s2*3<br />
<br />
produkt p1 kosztuje 12 zł, a produkt p2 kosztuje 15zł. Mamy na magazynie 250 porcji składnika s1 i 300 składnika s2.<br />
<br />
Powyższe zagadnienie możemy opisać następująco.<br />
<br />
Ograniczenia:<br />
<br />
x1*4 + x2*2 < 250<br />
<br />
x1*3 + x2*6 < 300<br />
<br />
Funkcja celu:<br />
<br />
x1*12 + x2*15 → max<br />
<br />
przy czym x1 i x2>=0<br />
<br />
Oczywiście x1 to ilość produktu p1 do wyprodukowania z zapasów magazynowych. Natomiast x2 to ilość produktu p2 do wyprodukowania.<br />
<br />
'''Jest to typowe zagadnienie programowania liniowego.'''<br />
<br />
Najpopularniejszym algorytmem rozwiązywania problemów programowania liniowego, jest wymyślony w latach czterdziestych XX wieku przez George'a Dantziga algorytm Simplex.<br />
<br />
Stosując algorytm Simplex znaleźć rozwiązanie dla powyższego problemu: x1=50 a x2=25, natomiast zarobek wynosi 975zł. W dalszej części tekstu znajdziesz wyjaśnienie jak to zrobić.<br />
<br />
== Równania i nierówności liniowe ==<br />
W algorytmie Simplex rozwiązywane są układy równań i nierówności liniowych. Zanim przejdziemy do algorytmu Simplex, musimy poznać przynajmniej podstawy tego zagadnienia.<br />
<br />
Rozważmy prosty układ równań:<br />
<br />
(1) x1=2*x2 - 100<br />
<br />
(2) x1=0.5*x2 - 10<br />
<br />
rozwiązanie:<br />
<br />
0 = 1.5*x2 - 90 | odejmujemy stronami<br />
<br />
x2 = 90/1.5 = 60<br />
<br />
x1=2*60-100=20<br />
<br />
Jeśli zamienimy równania na nierówności – rozwiązaniem będzie trójkąt ograniczony prostymi (zamalowany na niebiesko na powyższym rysunku):<br />
<br />
(1) x1>=2*x2 - 100<br />
<br />
(2) x1<=0.5*x2 - 10<br />
<br />
x1>=0, x2>=0<br />
<br />
''W zagadnieniu programowania liniowgo rozwiązujemy tego typu zbiory nierówności z uwzględnieniem dodatkowo zdefiniowanej '''funkcji celu''', określonej także poprzez równanie liniowe. Nierówności są przy tym interpretowane jako ograniczenia jakie muszą spełniać zmienne występujące w funkcji celu.''<br />
<br />
Zagadnienie programowania liniowego ma postać standardową, jeśli w ograniczeniach występują wyłącznie równości (=), a wszystkie zmienne przyjmują wartości nie mniejsze niż zero. Zamiana nierówności na równania jest banalnie prosta (wystarczy dodać / odjąć dodatkową zmienną – szczegóły poniżej). Możemy więc poprzestać na rozwiązywaniu równań.<br />
<br />
Będziemy przy tym posługiwać się zapisem macierzowym (zobacz <nowiki>https://edu.pjwstk.edu.pl/wyklady/alg/scb/index35.html</nowiki>):<br />
<br />
Ograniczenia:<br />
<br />
A*[x] = [b]<br />
<br />
[x]>=0<br />
<br />
Funkcja celu:<br />
<br />
z = f(x) = <[c] * [x]><br />
<br />
Gdzie <> oznacza iloczyn skalarny<br />
<br />
W języku Python macierz będzie listą wierszy (też reprezentowanych przez listy).<br />
<br />
Dla naszego przykładu:<br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [-3,-4]<br />
<br />
def z(c,x): # Iloczyn skalarny<br />
<br />
return sum([c1*x1 for c1,x1 in zip(c,x)])<br />
<br />
Zdefiniujmy przykładową funkcję celu:<br />
<br />
z = 3*x1+4*x2 → max<br />
<br />
Wartości funkcji celu w poszczególnych wierzchołkach (zob. zamalowany obszar na rysunku) będą wynosić:<br />
<br />
x1=20, x2=60 (wyliczone powyżej): z=300<br />
<br />
x1=0, x2=20: z=20*4=80<br />
<br />
x1=0, x2=50: z=50*4=200<br />
<br />
maksymalna wartość funkcji celu występuje więc w punkcie (20,60) i wynosi 300<br />
<br />
=== Metoda eliminacji Jordana-Gaussa ===<br />
Metoda eliminacji Jordana-Gaussa polega na redukcji wszystkich poza jedną niewiadomą każdego wiersza. Operacje wykonujemy na „macierzy uzupełnionej”, w której ostatnia kolumna zawiera wartość równania (wyraz wolny). Przekształcanie polega na mnożeniu wiersza macierzy przez skalar oraz dodawaniu wierszy pomnożonych przez skalar. Takie ‘operacje elementarne’ oczywiście nie zmieniają wartości rozwiązania.<br />
<br />
Operacje elementarne:<br />
<br />
def mnoz_wiersz(S,wiersz,skalar):<br />
<br />
for i,x in enumerate(S[wiersz]):<br />
<br />
S[wiersz][i]=x*skalar<br />
<br />
def dodaj_wiersz(S,wiersz1,wiersz2,skalar):<br />
<br />
for i,x in enumerate(S[wiersz2]):<br />
<br />
S[wiersz1][i]=S[wiersz1][i]+x*skalar<br />
<br />
Na naszym przykładzie:<br />
<br />
S = [<br />
<br />
[-1, 2, 100],<br />
<br />
[1, -0.5, - 10],<br />
<br />
]<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
Wynik:<br />
<br />
S=[ [0, 1.5, 90], [1, -0.5, -10]]<br />
<br />
Teraz eliminacja elementów <>0 w kolumnie 1:<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
Najpierw podzieliliśmy wiersz 0 przez drugi jego element (by uzyskać w tym elemencie 1), a następnie odjęliśmy od wiersza drugiego wiersz pierwszy pomnożony przez drugi jego element (by uzyskać w nim 0):<br />
<br />
S=[ [0.0, 1.0, 60.0], [1.0, 0.0, 20.0] ]<br />
<br />
Ostania kolumna zawiera rozwiązanie!<br />
<br />
== Postać standardowa problemu ==<br />
Każde zagadnienie programowania liniowego daje się sprowadzić do postaci standardowej[[Algorytm Simplex#sdfootnote2sym|<sup>2</sup>]]: znaleźć minimum (lub maksimum) funkcji celu z, które równocześnie spełnia zadane ograniczenia (A*x=b).<br />
<br />
1. Gdy poszukujemy maksimum a nie minimum funkcji z:<br />
<br />
wektor c zastępujemy wektorem −c oraz otrzymaną minimalną wartość funkcji mnożymy przez −1.<br />
<br />
2. Nierówność ai1 * x1 + ai2 * x2 + . . . + ain * xn <= bi<br />
<br />
można sprowadzić do równania poprzez wprowadzenie dodatkowej zmiennej xn+1:<br />
<br />
ai1 * x1 + ai2 * x2 + . . . + ain * xn + xn+1 = bi<br />
<br />
Podobnie w przypadku, gdy w miejsce znaku mniejszości<br />
<br />
mamy znak większości. Musimy wprowadzić tyle dodatkowych zmiennych, ile mamy nierówności!<br />
<br />
Zmienne te nazywamy „zmiennymi luzu”, albo „swobodnymi” (ile dzieli wynik od ekstremum).<br />
<br />
3. Gdy zmienne x nie spełniają ograniczenia (xi>0), korzystamy z faktu, że każda liczba rzeczywista może być przedstawiona jako różnica liczb nieujemnych. Wprowadzamy nowe zmienne xi’ i xi’’ i zamieniamy wystąpienia xi na różnicę xi’-xi’’.<br />
<br />
4. Gdy zmienna xi musi być większa od pewnej wartości di:<br />
<br />
xi ≥ di<br />
<br />
- wprowadzamy zmienną xi’, taką, że xi′ = xi − di<br />
<br />
Podobnie w przypadku mniejszości (w miejsce większości): xi′ = di − xi<br />
<br />
5. Dla ujednolicenia przyjmujemy, że mamy do czynienia wyłącznie z mniejszością nieostrą (<=). Gdy wśród warunków jest użyty znak większości – zamieniamy go na mniejszość mnożąc obie strony przez -1<br />
<br />
6. Gdy mamy warunek równości – zamieniamy go na dwa warunki nierówności nieostrej (dotyczy to także =0).<br />
<br />
Przedstawmy zagadnienie z wcześniej rozważanego przykładu w postaci wektorowej:<br />
<br />
(1) x1>=2*x2 – 100 == -x1+2*x2 <= 100 == -1*x1 + 2*x2 <= 100<br />
<br />
(2) x1<=0.5*x2 – 10 == x1 - 0.5*x2 <= - 10 == 1*x1 - 0.5*x2 = - 10<br />
<br />
A*[x] = [b]<br />
<br />
z = <c * x><br />
<br />
A = [ [-1,2], [1,-0.5], ]<br />
<br />
b = [100, -10]<br />
<br />
c = [3,4]<br />
<br />
W postaci standardowej:<br />
<br />
(1) -1*x1 + 2*x2 <= 100 == -1*x1 + 2*x2 + 1 * x3 = 100<br />
<br />
(2) 1*x1 - 0.5*x2 = - 10 == 1*x1 - 0.5*x2 + 1 * x4 = - 10<br />
<br />
czyli:<br />
<br />
-1*x1 + 2*x2 + 1*x3 + 0*x4= 100<br />
<br />
1*x1 - 0.5*x2 + 0*x3 + 1*x4 = - 10<br />
<br />
x1>=0, x2>=0,x3>=0>,x4>=0<br />
<br />
z = x1+x2 →max<br />
<br />
A=[ [-1,2,1,0],<br />
<br />
[1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4]<br />
<br />
Możemy przejrzeć wszystkie wierzchołki i (jak poprzednio) znaleźć rozwiązanie dla (x1=20,x2=60,x3=0,x4=0)<br />
<br />
== '''Podstawy''' ==<br />
Aby zrozumieć algorytm Simplex, rozwiązujący zagadnienia programowania liniowego – musimy wprowadzić kilka prostych definicji i spostrzeżeń (lematów). '''Wiele z opisów i implementacji algorytmu simplex – jest trudnych do zrozumienia, gdyż brakuje takich prostych objaśnień. Albo też – wręcz przeciwnie – objaśnienia są obszerne i z wykorzystaniem bardziej ogólnych definicji matematycznych (formalnie wprowadzone zbiory wypukłe i ekstrema).'''<br />
<br />
(1). Podzbiór zdefiniowany przez ograniczenia nazywamy dopuszczalnym. Każdy element tego zbioru nazywa się rozwiązaniem dopuszczalnym.<br />
<br />
(2). Rozwiązanie dopuszczalne x, dla którego funkcja celu f(x) osiąga minimum (maksimum) nazywamy rozwiązaniem optymalnym.<br />
<br />
(3). Ograniczenia definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”.<br />
<br />
(4). W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń (zapisanych w postaci równań). Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi.<br />
<br />
(5). Dwa wierzchołki są sąsiadami, jeśli różnią się wartością jednej zmiennej. Taka zmienna może służyć do poszukiwania lepszych rozwiązań (posuwając się od wierzchołka do jego sąsiada poprzez zmianę wartości tej zmiennej). Wtedy nazywamy ją „uwolnioną”.<br />
<br />
(6). Jeśli funkcja celu osiąga minimum (lub maksimum), to musi ona osiągać to ekstremum w wierzchołku wielościanu. Ponieważ funkcja celu jest zależnością liniową, mając dowolne rozwiązanie poza wierzchołkiem – możemy odpowiednio zwiększać lub zmniejszać wartość zmiennych, powodując zmianę wartości funkcji celu na bardziej zbliżoną do optymalnej. Takiej możliwości nie ma tylko w wierzchołku.<br />
<br />
'''''Bardziej ścisłe wprowadzenie tych pojęć: <nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''''<br />
<br />
'''Algorytm opisany przez tego samego autora: ''<nowiki>http://smurf.mimuw.edu.pl/node/1122</nowiki>'''''<br />
<br />
== '''Idea rozwiązania''' ==<br />
Algorytm simplex w największym skrócie: zamiast przeglądać wszystkie wierzchołki wielościanu, wybierz jeden i posuwaj się wzdłuż krawędzi do sąsiadów – póki możesz poprawić w ten sposób wartość funkcji celu.<br />
<br />
'''1. Nierówności możemy zamienić na równania – odpowiednio dodając (<) lub odejmując (>) dodatkową („sztuczną”) zmienną. Taki zbiór równań jest liniowo niezależny (żadne z nich nie wynika z pozostałych). Na naszym przykładzie:'''<br />
<br />
'''x1*4 + x2*2 - x3 = 250'''<br />
<br />
'''x1*3 + x2*6 - x4 = 300'''<br />
<br />
'''x1*12 + x2*15 → max'''<br />
<br />
'''x1, x2, x3, x4 >= 0'''<br />
<br />
2. Ten układ równań ma trywialne rozwiązanie przy założeniu, że x1=x2=0. Otrzymamy dokładnie jedno rozwiązanie: x3=-250 i x4=-300. Zgodnie z definicją takie rozwiązanie będzie wierzchołkiem wielościanu wielowymiarowego zdefiniowanego przez równania liniowe ograniczeń. Zmienne niezerowe nazwiemy bazą, a ich zbiór – zbiorem bazowym.<br />
<br />
3. Algorytm Simplex polega na przeglądaniu sąsiednich wierzchołków wielościanu ograniczeń w poszukiwaniu rozwiązania lepszego (dającego lepszy wynik funkcji celu). Gdy taki znajdziemy – dokonujemy przesunięcia do następnego wierzchołka i znów przeszukujemy sąsiednie.<br />
<br />
Ten skrótowy opis zostanie uzupełniony i wyjaśniony poniżej.<br />
<br />
== '''Algorytm Simplex''' ==<br />
Istnieje kilka wariantów algorytmu Simplex. W tym tekście opiszemy najczęściej spotykany – oparty o rozwiązania bazowe, z wykorzystaniem zmiennych luzu (swobodnych).<br />
<br />
Jeśli mamy:<br />
<br />
'''A''' - macierz ograniczeń o wymiarach ('''m''','''n''');<br />
<br />
'''b''' – wektor wyrazów wolnych o wymiarze '''m''';<br />
<br />
'''c''' – wektor definiujący funkcję celu o wymiarze '''n''';<br />
<br />
'''x''' – wektor '''n''' zmiennych decyzyjnych (rozszerzony o zmienne swobodne/luzu), przyjmujących wartości nieujemne.<br />
<br />
Bazą nazywamy macierz (oznaczaną jako '''B''') składającą się '''m''' liniowo niezależnych kolumn macierzy '''A'''. Kolumny wchodzące w skład B nazywamy kolumnami bazowymi (pozostałe kolumny macierzy '''A''' nazywa się kolumnami niebazowymi). Zmienne związane z kolumnami bazowymi nazywamy zmiennymi bazowymi zaś nazywamy pozostałe niebazowymi. Rozwiązanie bazowe uzyskujemy, ustawiając wartość 0 (zero) dla wszystkich zmiennych niebazowych.<br />
<br />
Jeżeli układ równań Ax<sup>T</sup>=b<sup>T</sup> posiada rozwiązania oraz (n>m), to posiada skończoną liczbę rozwiązań bazowych – jest ich co najwyżej:<br />
<br />
'''K'''<br />
<br />
'''ażdemu rozwiązaniu bazowemu odpowiada wierzchołek wielokąta ograniczeń'''. Dowód znajdziesz na stronie: '''<nowiki>http://smurf.mimuw.edu.pl/node/1121</nowiki>'''<br />
<br />
Przeglądanie wierzchołków wielomianu sprowadza się więc do zmiany rozwiązania bazowego poprzez „wymianę” zmiennych bazowych. Jedna zmienna wchodzi do bazy, a inna z niej wychodzi. Taka wymiana następuje wyłącznie wtedy, gdy dzięki niej udaje się zwiększyć wartość funkcji celu.<br />
<br />
Pierwsze rozwiązanie bazowe możemy znaleźć dzięki wykorzystaniu „zmiennych swobodnych” (luzu). Zakładamy, że tylko one będą różne od zera. Ponieważ w każdym ograniczeniu mamy inną zmienną swobodną (odpowiedni współczynnik a[i]==1) – przy wyzerowaniu pozostałych zmiennych, przyjmą one odpowiednie wartości z '''b.''' W naszym przykładzie:<br />
<br />
A=[ [-1,2,1,0], [1,-0.5,0,1]]<br />
<br />
b=[100,-10]<br />
<br />
c=[3,4,0,0]<br />
<br />
Mamy zatem<br />
<br />
x1=x2=0<br />
<br />
x3 = 100<br />
<br />
x4=-10<br />
<br />
z=0<br />
<br />
Zauważmy, że dzięki wykorzystaniu zmiennych swobodnych, punkt zerowy w pierwotnym układzie współrzędnych (x1,x2) stał się rozwiązaniem dopuszczalnym.<br />
<br />
Jeśli początek układu współrzędnych jest rozwiązaniem dopuszczalnym, to jest także rozwiązaniem optymalnym wtedy i tylko wtedy, gdy wszystkie elementy [c] są ujemne (przy założeniu, że funkcja celu ma być maksymalizowana). Uzasadnienie jest proste: jeśli jakiś element [c] (c[i]) jest większy od zera, to możemy zwiększyć wartość funkcji celu, zwiększając odpowiednią zmienną x[i].<br />
<br />
Ponieważ algorytm z wykorzystaniem rozwiązania bazowego jest równoważny z algorytmem „geometrycznym” – ta reguła nadal obowiązuje. W przekształceniach dążymy do tego, by wszystkie elementy c były nieujemne.<br />
<br />
Do przekształceń wykorzystujemy metodę eliminacji Jordana-Gaussa. W tym celu tworzy się tablicę Simplex – dodając do '''A''' kolumnę '''b''' oraz wiersz '''c''' (uzupełniony zerem do rozmiaru n+1).<br />
<br />
Tablica Simplex:<br />
<br />
A | b<br />
<br />
<nowiki>------</nowiki><br />
<br />
c | 0<br />
<br />
W naszym przykładzie pierwsze rozwiązanie bazowe byłoby optymalne, gdyby lista '''c''' zawierała tylko ujemne elementy. Tak oczywiście nie jest (mamy [3,4]). Wybieramy kolumnę i o największej wartości dodatniej (max('''c[i]''') i wprowadzamy ją do bazy – eliminując współczynniki w tej kolumnie (sprowadzone do zera) – poza jednym – przy nowej zmiennej bazowej.<br />
<br />
W wyniku przekształcenia jedna ze zmiennych bazowych x[j] zostanie usunięta z bazy (współczynnik c[j] zostanie wyzerowany, a inna x[i] znajdzie się w bazie (współczynnik a[i] otrzyma wartość 1).<br />
<br />
Taką transformację możemy wykonać w następujący sposób:<br />
<br />
1) dzielimy wybrany wiersz '''w''' przez wartość komórki tego wiersza z wybranej kolumny ('''i)''' (A[w][i]) – w ten sposób współczynnik a[i] otrzyma wartość 1);<br />
<br />
2) odejmujemy ten wiersz od pozostałych po pomnożeniu przez wartość komórki wybranej kolumny zmienianego wiersza (dla wiersza '''u''' będzie to A[u][i]).<br />
<br />
Ten sposób przekształcenia gwarantuje, że wcześniej wybrane do bazy kolumny nie zostaną zaburzone – chyba, że zawierają 1 w wybranym aktualnie wierszu.<br />
<br />
Przekształcamy w ten sposób tablicę simplex tak długo, aż wszystkie elementy c[i] będą nie większe od zera, albo nie uda się znaleźć wierzchołka dającego wzrost funkcji celu (wtedy przyjmujemy, że zadanie nie ma rozwiązania).<br />
<br />
Na naszym przykładzie (ostatni wiersz zawiera funkcję celu):<br />
<br />
S=[<br />
<br />
[-1, 2, 1, 0, 100],<br />
<br />
[1, -0.5, 0, 1, - 10],<br />
<br />
[-3,-4,0,0,0]<br />
<br />
]<br />
<br />
Redukcję tabeli przedstawimy wykorzystując napisany powyżej program eliminacji Jordana-Gaussa:<br />
<br />
1. W kolumnie 0 mamy wartość już 1 w wierszu 1 (nie musimy wykonywać działania 1)). Pozostałe elementy redukujemy do zera dodając wiersz :<br />
<br />
dodaj_wiersz(S,0,1,-S[0][0])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][0])<br />
<br />
2. W kolumnie 1 sprowadzamy do 1 element wiersza 0, dzieląc go przez jego wartość (S[0][1]=1.5).<br />
<br />
Podobnie jak poprzednio odejmujemy wiersz zerowy od pozostałych, mnożąc go przez element eliminowany (z kolumny 1):<br />
<br />
mnoz_wiersz(S,0,1/S[0][1])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][1])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][1])<br />
<br />
Wynik naszych działań:<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
Ostatnia kolumna zawiera wynik – wartości zmiennych x oraz funkcji celu:<br />
<br />
0.00, 1.00, 0.67, 0.67, 60.00<br />
<br />
1.00, 0.00, 0.33, 1.33, 20.00<br />
<br />
0.00, 0.00, -3.67, -6.67, -300.00<br />
<br />
Trzeba jeszcze ustalić sposób wyboru wiersza i kolumny do wprowadzenia do bazy. Zgodnie z tak zwaną „regułą Blanda” (<nowiki>https://www.mimuw.edu.pl/~oskar/lecture_13.pdf</nowiki>), można przyjąć, przy wyborze kolumny wybieramy pierwszą z lewej o dodatnim współczynniku c, a następnie wiersz, dla którego najmniejszy jest iloraz wyrazu wolnego (b[i]) przez element z wybranej kolumny (dla kolumny k będzie to najmniejsza spośród b[i]/a[k][i] (oczywiście pod warunkiem, że mianownik jest dodatni).<br />
<br />
Rozważmy inny przykład:<br />
<br />
2x1-x2<=4<br />
<br />
x1+2x2<=9<br />
<br />
-x1+x2<=3<br />
<br />
z=2x1+5x2→max<br />
<br />
r<br />
<br />
ysunek dzięki <nowiki>https://www.matemaks.pl/program-do-rysowania-wykresow-funkcji.html</nowiki><br />
<br />
A = [[2, -1], [1, 2],[-1,1]]<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2,5]<br />
<br />
S = [[2, -1,1,0,0,4], [1, 2,0,1,0,9],[-1,1,0,0,1,3],[2,5,0,0,0,0]]<br />
<br />
print('tablica Simplex:')<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 0 kolumna 0:')<br />
<br />
mnoz_wiersz(S,0,1/S[0][0])<br />
<br />
dodaj_wiersz(S,1,0,-S[1][0])<br />
<br />
dodaj_wiersz(S,2,0,-S[2][0])<br />
<br />
dodaj_wiersz(S,3,0,-S[3][0])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 1 kolumna 1:')<br />
<br />
mnoz_wiersz(S,1,1/S[1][1])<br />
<br />
dodaj_wiersz(S,0,1,-S[0][1])<br />
<br />
dodaj_wiersz(S,2,1,-S[2][1])<br />
<br />
dodaj_wiersz(S,3,1,-S[3][1])<br />
<br />
druk_tabeli(S)<br />
<br />
print('wybrany wiersz 2 kolumna 2:')<br />
<br />
mnoz_wiersz(S, 2, 1/S[2][2])<br />
<br />
dodaj_wiersz(S, 0, 2, -S[0][2])<br />
<br />
dodaj_wiersz(S, 1, 2, -S[1][2])<br />
<br />
dodaj_wiersz(S, 3, 2, -S[3][2])<br />
<br />
druk_tabeli(S)<br />
<br />
rozwiązanie:<br />
<br />
tablica Simplex:<br />
<br />
2.00, -1.00, 1.00, 0.00, 0.00, 4.00<br />
<br />
1.00, 2.00, 0.00, 1.00, 0.00, 9.00<br />
<br />
-1.00, 1.00, 0.00, 0.00, 1.00, 3.00<br />
<br />
2.00, 5.00, 0.00, 0.00, 0.00, 0.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 0 kolumna 0:<br />
<br />
1.00, -0.50, 0.50, 0.00, 0.00, 2.00<br />
<br />
0.00, 2.50, -0.50, 1.00, 0.00, 7.00<br />
<br />
0.00, 0.50, 0.50, 0.00, 1.00, 5.00<br />
<br />
0.00, 6.00, -1.00, 0.00, 0.00, -4.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 1 kolumna 1:<br />
<br />
1.00, 0.00, 0.40, 0.20, 0.00, 3.40<br />
<br />
0.00, 1.00, -0.20, 0.40, 0.00, 2.80<br />
<br />
0.00, 0.00, 0.60, -0.20, 1.00, 3.60<br />
<br />
0.00, 0.00, 0.20, -2.40, 0.00, -20.80<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
wybrany wiersz 2 kolumna 2:<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
<nowiki>--------------</nowiki><br />
<br />
x1=1,x2=4<br />
<br />
z = 22<br />
<br />
Ten sam problem można rozwiązać przy pomocy arkusza Excel:<br />
<br />
== Implementacja ==<br />
Istnieje wiele opisów algorytmu i jego implementacji. Na przykład zwięzła implementacja w Pythonie: <nowiki>https://github.com/j2kun/</nowiki> opisana w tekście: <nowiki>https://jeremykun.com/2014/12/01/linear-programming-and-the-simplex-algorithm/</nowiki>.<br />
<br />
W jego analizie przyda się słowniczek:<br />
<br />
Zmienne decyzyjne - decision variables<br />
<br />
Funkcja celu - objective function<br />
<br />
Ograniczenia - constraints<br />
<br />
Zmienne agraniczeń - variable bounds<br />
<br />
zmienne swobodne (zmienna swobodna, zmienna luzu) - slack variables<br />
<br />
sąsiad – neighbor<br />
<br />
iloczyn skalarny - dot product<br />
<br />
analiza wrażliwości (sensitivity analysis)<br />
<br />
rozwiązanie (solution)<br />
<br />
rozwiązanie wierzchołkowe (cornerpoint solution)<br />
<br />
dopuszczalne rozwiązanie wierzchołkowe (feasible cornerpoint solution)<br />
<br />
sąsiadujące rozwiązania wierzchołkowe (adjacent cornerpoint solutions)<br />
<br />
stopnie swobody (degrees of freedom, df)<br />
<br />
test minimalnej proporcji (minimum ratio test)<br />
<br />
Główna procedura simplex(c, A, b):<br />
<br />
# Utwórz tabelę Simplex.<br />
# Znajdź dodatni indeks ostatniego wiersza i zwiększ odpowiednią zmienną (dodając ją do bazy) na tyle, aby inna zmienna znalazła się w bazie zerowej (usuwając ją z bazy).<br />
# Powtarzaj krok 2, aż ostatni wiersz będzie niedodatni.<br />
# Wypisz ostatnią kolumnę.<br />
<br />
def simplex(c, A, b):<br />
<br />
tableau = initialTableau(c, A, b)<br />
<br />
while canImprove(tableau):<br />
<br />
pivot = findPivotIndex(tableau)<br />
<br />
pivotAbout(tableau, pivot)<br />
<br />
return tableau, objectiveValue(tableau)<br />
<br />
Funkcja <code>initialTableau</code> tylko tworzy tabelę Simplex. Dodaje do wierszy A odpowiedni wyraz wolny z b. W ostatnim wierszu wstawia wektor c uzupełniony zerem.<br />
<br />
def initialTableau(c, A, b):<br />
<br />
tableau = [row[:] + [x] for row, x in zip(A, b)]<br />
<br />
tableau.append([ci for ci in c] + [0])<br />
<br />
return tableau<br />
<br />
Funkcja <code>canImprove()</code> sprawdza, czy w ostatnim wierszu znajduje się nieujemny wpis:<br />
<br />
def canImprove(tableau):<br />
<br />
lastRow = tableau[-1]<br />
<br />
return any(x > 0 for x in lastRow[:-1])<br />
<br />
Funkcja findPivotIndex() szuka dodatniego elementu w ostatnim wierszu (zawierającym c), a następnie wiersza w wybranej kolumnie o minimalnym ilorazie:<br />
<br />
def findPivotIndex(tableau):<br />
<br />
''# wybór elementu ostatniego wiersza, dla którego x>0''<br />
<br />
column_choices = [(i,x) for (i,x) in enumerate(tableau[-1][:-1]) if x > 0]<br />
<br />
column = min(column_choices, key=lambda a: a[1])[0]<br />
<br />
''# sprawdzenie, czy rozwiązanie nie ograniczone (unbounded)''<br />
<br />
if all(row[column] <= 0 for row in tableau):<br />
<br />
raise Exception('Linear program is unbounded.')<br />
<br />
''# sprawdzenie braku zdegenerowania: więcej niż jeden minimalny iloraz''<br />
<br />
quotients = [(i, r[-1] / r[column])<br />
<br />
for i,r in enumerate(tableau[:-1]) if r[column] > 0]<br />
<br />
if moreThanOneMin(quotients):<br />
<br />
raise Exception('Linear program is degenerate.')<br />
<br />
''# wybór indeksu wiersza o minimalnym ilorazie''<br />
<br />
row = min(quotients, key=lambda x: x[1])[0]<br />
<br />
return row, column<br />
<br />
Funkcja dla pierwszej tabeli zwraca parę (row=1, column=0).<br />
<br />
Następnie dokonywana jest zamiana – przy użyciu funkcji pivotAbout. Jej implementacja:<br />
<br />
def pivotAbout(tableau, pivot):<br />
<br />
i,j = pivot<br />
<br />
pivotDenom = tableau[i][j]<br />
<br />
tableau[i] = [x / pivotDenom for x in tableau[i]]<br />
<br />
for k,row in enumerate(tableau):<br />
<br />
if k != i:<br />
<br />
pivotRowMultiple = [y * tableau[k][j] for y in tableau[i]]<br />
<br />
tableau[k] = [x - y for x,y in zip(tableau[k], pivotRowMultiple)]<br />
<br />
Główny program dla naszego przykładu:<br />
<br />
if __name__ == "__main__":<br />
<br />
b = [4, 9, 3]<br />
<br />
c = [2, 5]<br />
<br />
A = [[2, -1], [1, 2], [-1, 1]]<br />
<br />
''# add slack variables by hand''<br />
<br />
A[0] += [1, 0, 0]<br />
<br />
A[1] += [0, 1, 0]<br />
<br />
A[2] += [0, 0, 1]<br />
<br />
c += [0, 0, 0]<br />
<br />
t, v = simplex(c, A, b)<br />
<br />
print("wynik:")<br />
<br />
print("tabela simplex=")<br />
<br />
for w in t:<br />
<br />
print(', '.join('{:0.2f}'.format(x) for x in w))<br />
<br />
print("wartość funkcji celu=")<br />
<br />
print(v)<br />
<br />
Wynik:<br />
<br />
tabela simplex=<br />
<br />
1.00, 0.00, 0.00, 0.33, -0.67, 1.00<br />
<br />
0.00, 1.00, 0.00, 0.33, 0.33, 4.00<br />
<br />
0.00, 0.00, 1.00, -0.33, 1.67, 6.00<br />
<br />
0.00, 0.00, 0.00, -2.33, -0.33, -22.00<br />
<br />
wartość funkcji celu=<br />
<br />
22.0<br />
<br />
[[Algorytm Simplex#sdfootnote1anc|1]]<nowiki>https://www.snopes.com/fact-check/the-unsolvable-math-problem/</nowiki><br />
<br />
[[Algorytm Simplex#sdfootnote2anc|2]]Justyna Kosakowska i Piotr Malicki, „Badania operacyjne - programowanie liniowe”</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Algorytmy&diff=127Algorytmy2022-09-25T06:49:36Z<p>Admin: Utworzono nową stronę "* Algorytm Simplex"</p>
<hr />
<div>* [[Algorytm Simplex]]</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Podstawy_informatyki&diff=126Podstawy informatyki2022-09-25T06:48:55Z<p>Admin: </p>
<hr />
<div><strong>PODSTAWY INFORMATYKI</strong><br />
<br />
<br />
== Część I: Podstawowe pojęcia ==<br />
* Moduł 1.1 [[Algorytm – program – system]]<br />
* Moduł 1.2 [[Uczymy się myśleć abstrakcyjnie]]<br />
* Moduł 1.3 [[Filozoficznie o programach komputerowych]] (dla humanistów i pasjonatów)<br />
* Moduł 1.4 [[Procesor i język maszynowy - wprowadzenie]] (dla inżynierów i techników)<br />
* Moduł 1.5 [[Logika i instrukcje warunkowe]]<br />
<br />
== Część II: Algorytmika ==<br />
* Moduł 2.1 [[Programy a algorytmy]]<br />
* Moduł 2.2 [[Implementacja algorytmów]]<br />
* Moduł 2.3 [[Elementy językoznawstwa dla programistów]] (poziom zaawansowany)<br />
* Moduł 2.4 [[Algorytmy]] (wybrane / najważniejsze algorytmy)<br />
<br />
== Część III: Podstawy programowania ==<br />
* Moduł 3.1. [[Różnorodność struktur programów]]<br />
<br />
== Część IV: Matematyka obiektowa ==<br />
* Moduł 4.1 [[Matematyka obiektowa]]<br />
<br />
== Ważne strony ==<br />
* [//leanpub.com/pyprog leanpub.com/pyprog] - Podręcznik programowania w Pythonie<br />
* [//elearning.otwartaedukacja.pl/ elearning.otwartaedukacja.pl] - '''E-learning'''<br />
<br />
<br />
== Używane programy edukacyjne ==<br />
* [//otwartaedukacja.pl/programowanie/bl/code/ otwartaedukacja.pl/programowanie/bl/code] - układanie programów z bloczków<br />
* [//otwartaedukacja.pl/programowanie/schematy/ otwartaedukacja.pl/programowanie/schematy] - rysowanie schematów blokowych<br />
-</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Matematyka_obiektowa&diff=125Matematyka obiektowa2022-09-25T06:18:38Z<p>Admin: Publikacja artykułu</p>
<hr />
<div>Często słyszymy, że podstawą informatyki jest matematyka. Tak – ale nie jest to taka matematyka, jaką męczą dzieci w szkole. W przeciwieństwie do matematyki, informatyka w całej swej historii dąży do jak najprostszego i zrozumiałego opisu tworzonych systemów. Nie ma też mowy o jakichkolwiek niedopowiedzeniach. Ma być jasno i precyzyjnie. Dlatego kreowany przez programistów świat wirtualny jest łatwiejszy do zrozumienia niż świat matematycznych abstrakcji.<br />
<br />
Może więc należałoby sytuację odwrócić, traktując informatykę jako klucz do zrozumienia matematyki?<br />
<br />
=== Czy matematyka jest trudna? ===<br />
Niektóre teorie czy twierdzenia matematyczne są rzeczywiście bardzo trudne. Jednak na podstawowym poziomie matematyka powinna być bez większych problemów przyswajana przez każdego rozgarniętego człowieka. Dlaczego tak się nie dzieje? Jedną z przyczyn jest przyjęcie przez matematyków zasady „nieoglądowości” – czyli braku odwołań do pojęć jakich używamy w odniesieniu do postrzeganych rzeczy.<br />
<br />
Jeszcze w XVII wieku powszechnie uważano, że nasz ogląd świata jest źródłem pojęć z których budujemy sądy matematyczne1. Oczyszczanie matematyki z odniesień do rzeczywistości i naszych wyobrażeń wiązało się z dążeniem do precyzji i absolutnej pewności. Proces ten został domknięty przez Davida Hilberta2, który w celu wykazania niesprzeczności matematyki postulował jej aksjomatyzację – czyli przyjęcie, że każda teoria wynika logicznie z przyjętego zbioru aksjomatów3. Ostatecznie zwyciężył pogląd, że język matematyki jest całkowicie abstrakcyjny4. Nawet liczby naturalne definiuje się obecnie w oparciu o abstrakcyjną teorię mnogości.<br />
<br />
<br />
Ta sytuacja ma ogromne znaczenie w nauczaniu matematyki. Nauka matematyki to poznawanie świata abstrakcji, co stanowi poważną barierę dla wielu jej adeptów. Na dodatek archaiczna maniera matematyków każe im używać języka naszpikowanego trudnymi do zapamięta symbolami jednoliterowymi (kto dzisiaj zna alfabet grecki?).<br />
<br />
=== Matematyka z informatyką ===<br />
Matematycy posługiwali się odniesieniami do rzeczywistego świata, które okazały się zbędne na pewnym etapie rozwoju tej nauki. Do zobrazowania tej sytuacji można przywołać za Wittgensteinem metaforę drabiny. Matematycy wspinali się po jej szczeblach (z których każdy był bardziej abstrakcyjny), aż na poziom całkowitej abstrakcji. Po odrzuceniu drabiny mamy czystą matematykę. Tylko dlaczego osobom studiującym matematykę odmawia się użycia tej „drabiny”?<br />
<br />
Jest to tym bardziej dziwne, że matematycy w swych publikacjach wcale nie są tak pryncypialni. Weźmy na przykład elementarny tekst na temat „rachunku zdań”: <nowiki>http://wazniak.mimuw.edu.pl/index.php?title=Logika_i_teoria_mnogo%C5%9Bci/Wyk%C5%82ad_2:_Rachunek_zda%C5%84</nowiki>. Próżno w nim szukać na przykład definicji używanego pojęcia „zmienna zdaniowa”. Intuicyjnie rozumiemy, że chodzi o symbol reprezentujący zdanie.<br />
<br />
Takie podejście ma zasadniczą wadę: autor zakłada, że czytelnik potrafi trafnie uchwycić znaczenie wprowadzonych pojęć (intuicyjnie, lub poprzez studiowanie innych publikacji). To może być założeniem błędnym.<br />
<br />
Połączenie nauki matematyki i programowania sprawia natomiast, że możemy zakładać zrozumienie odwołań do pojęć z dziedziny informatyki. Takie powiązanie matematyki z informatyką nie wiąże się z zagrożeniem, któremu miało zapobiec „oczyszczenie” matematyki z „obrazowości”. Komputery są deterministyczne, a zasada ich działanie daje się opisać przy pomocy elementarnej logiki. Nie ma więc mowy o tym, by powyższy związek był źródłem błędów.<br />
<br />
=== Uniwersalność matematyki ===<br />
Powyżej wspomniano o dwóch różnicach między informatyką i matematyką:<br />
<br />
1) silny związek informatyki ze światem rzeczywistym wobec dążenia matematyki do abstrakcji;<br />
<br />
2) język informatyki ma być możliwie najbardziej zrozumiały, czego nie oczekujemy od języka matematyki;<br />
<br />
Gdyby różnice między informatyką i matematyką sprowadzały się do takich „drobiazgów” – nie byłoby powodu traktować tych dziedzin jako odrębne (i pewnie z czasem nastąpiłoby „ujednolicenie”).<br />
<br />
Istnieją jednak różnice o wiele poważniejsze, które można uznać za fundamentalne.<br />
<br />
Porównajmy dwa objaśnienia algorytmu Simplex: matematyczne i informatyczne5. Jednym z kluczowych pojęć jest w tym algorytmie wierzchołek wielościanu wielowymiarowego.<br />
<br />
Matematyczna definicja wierzchołka (punktu ekstremalnego zbioru wypukłego)6:<br />
<br />
''Punkt e ∈ K jest punktem ekstremalnym zbioru wypukłego K, gdy równość''<br />
<br />
''e = 𝜆𝐱 + (1 − 𝜆) y dla pewnych x,y ∈ K oraz 𝜆 ∈ [0,1] implikuje, że e = x lub e = y .''<br />
<br />
W tej definicji chodzi o to, że jeśli mamy jakiś odcinek (x,y) zawarty w zbiorze wypukłym, to wierzchołkiem może być jedynie jego początek lub koniec. Po tym objaśnieniu - chyba definicja staje się zrozumiała7. Tyle, że w kontekście algorytmu Simplex mało użyteczna.<br />
<br />
Porównajmy z definicją wierzchołka sformułowaną przez informatyka:<br />
<br />
''Ograniczenia [równania liniowe wielu zmiennych] definiują wielościan w przestrzeni n wymiarowej (gdzie n to ilość zmiennych). Wielościan ten nazywamy „wielościanem ograniczeń”. W wielościanie ograniczeń wierzchołek to jedyny punkt wspólny (rozwiązanie dopuszczalne) dla kilku (więcej niż 1) ograniczeń. Inaczej mówiąc wierzchołek to punkt wspólny dla kilku krawędzi. .''<br />
<br />
Najważniejszą różnicą między tymi definicjami nie jest użycie jednoliterowych symboli.<br />
<br />
Definicja matematyczna w sposób dość typowy używa implikacji do zawężenia zbioru możliwości.<br />
<br />
Taka definicja jest bardziej uniwersalna, niż opis informatyka (‘jak to jest zrobione i co z tego wynika’). To wspaniale! Dzięki takiemu dążeniu do uniwersalności, wszystkie twierdzenia mogą znaleźć szersze zastosowanie! Tyle, że informatyka nie interesuje ogólne zastosowanie definicji, ale zastosowanie jej w objaśnieniu algorytmu który chce zaimplementować lub zastosować! Jego definicja zawiera własności wierzchołka, które po przyjęciu ogólniejszej definicji trzeba by dopiero udowodnić!<br />
<br />
Czy definicja informatyka jest mniej precyzyjna? Taki zarzut staje się bezprzedmiotowy, jeśli definicja zostanie wprost przełożona na działający poprawnie program. Świat komputera z takim programem jest lokalnym „uniwersum”, które możemy objaśniać poprzez zastosowania (świat realny) lub … matematykę! Informatyk może traktować matematykę tak jak elektronikę: są niezbędne, ale rzadko zachodzi potrzeba zgłębiania ich tajników.<br />
<br />
=== Matematyka obiektowa ===<br />
Współczesny świat budują inżynierowie, dla których – jak się słusznie uważa – matematyka jest podstawą. W szczególności dotyczy to informatyków. Matematyka we współczesnej formie stanowi jedną z barier w kształceniu odpowiedniej ilości programistów. Z drugiej strony – świat kreowany przez programistów jest trudno dostępny dla przeciętnego użytkownika informatycznych produktów. Tu także może pomóc podniesienie ogólnego poziomu znajomości matematyki z uwzględnieniem jej związków z informatyką.<br />
<br />
Nadzieję na zmianę tej sytuacji daje podjęcie powszechnej edukacji w zakresie programowania. Niestety wygląda na to, że zmieniono ten z założenia szlachetny przedmiot w naukę programu Scratch. Ten absurd jest już tak ugruntowany, że nawet trudno liczyć na zmianę.<br />
<br />
Z powyższej refleksji zrodziła się idea stworzenia „matematyki obiektowej”.<br />
<br />
Dlaczego „matematyka obiektowa”? Po co tworzyć nowe terminy, skoro istnieje „matematyka dyskretna”? Termin „matematyka dyskretna” określa zakres (dziedzinę) matematyki związanej z informatyką8. Matematyka obiektowa wprowadza język i system pojęć pomocnych w opisaniu i zrozumieniu tej dziedziny wiedzy.<br />
<br />
Abstrakcyjna idea obiektów jest łatwą do zrozumienia (przez analogie ze światem realnych obiektów). Współczesne języki programowania w większości mają charakter obiektowy. Można więc w nich tworzyć obiekty, które objaśniają matematyczne pojęcia i twierdzenia.<br />
<br />
Obiekty matematyczne są opisywane poprzez definicje związków i działań w nich zachodzących. By zrozumieć ten opis, nierzadko trzeba zgłębić bardziej elementarne teorie i zapamiętać stosowane oznaczenia. Tymczasem obiekty w programowaniu są opisywane w sposób umożliwiający ich natychmiastowe użycie. Do ich zrozumienia często wystarczą przykłady użycia.<br />
<br />
Zmiana terminologii wiąże się więc ze zmianą podejścia: zastępujemy teorię (jak to jest zbudowane) przez praktykę (jak tego użyć). O ile w odniesieniu do elementarnych zagadnień takie podejście jest tylko jednym z możliwych9, to w przypadku zaawansowanych teorii pragmatyzm staje się często koniecznością (gdy chcemy z nich korzystać, ale nie mamy czasu na ich studiowanie).<br />
<br />
=== Semantyka matematyki (refleksja filozoficzna) ===<br />
Podejście obiektowe może być skuteczne zwłaszcza w matematyce dyskretnej. Czy w ten sposób można opisać całą matematykę?<br />
<br />
Najpierw należałoby wyjaśnić – co znaczy „opisać”. Możemy na przykład zrobić zdjęcie dowolnego tekstu czy rysunku i po zeskanowaniu wgrać do komputera. Drugą skrajnością są systemy / programy komputerowe, w których zaimplementowano reguły matematycznej teorii. Interesujące jest jedynie pytanie o tą drugą możliwość. Czyli pytanie - czy można matematykę zredukować do informatyki? Całą matematykę? Odpowiedź na tak postawione pytanie wiąże się z semantyką matematyki.<br />
<br />
Jeśli język matematyki jest całkowicie abstrakcyjny, to znaczenie jego zdań możemy ustalić wyłącznie przez odwołanie się do innych zdań matematyki – w tym aksjomatów.<br />
<br />
Semantyka referencyjna z odwołaniem do rzeczywistości (np. liczba jako uogólnienie równolicznych zbiorów przedmiotów) groziłaby pozbawieniem matematyki absolutnej pewności.<br />
<br />
Takich problemów nie ma, gdy odwołujemy się do rzeczywistości wirtualnej – czyli tworów informatycznych, które dają się zredukować do zdań matematyki.<br />
<br />
Gdyby udałoby się zachować jednoznaczne przyporządkowanie konstrukcji matematycznych abstrakcjom (obiektom) informatycznym – można by takie przyporządkowanie uznać za semantykę (referencyjną) języka matematyki. Czy to wykonalne? Konieczne byłaby możliwość zapisania w pamięci komputera odpowiednika dowolnych obiektów matematycznych.<br />
<br />
W komputerze można zapisać dowolne obiekty. Jednak może być ich tylko skończona ilość. Nigdy nie będą to więc wszystkie możliwe konstrukcje matematyczne (wynika to z twierdzenia Goedla). Dlatego matematyka nigdy nie zostanie zredukowana do informatyki.<br />
<br />
Ten wynik ma ważne konsekwencje semantyczne, filozoficzne i technologiczne.<br />
<br />
1. Mamy tu wyjaśnienie dlaczego logicyzm10 nie jest możliwy.<br />
<br />
2. Możemy w systemie komputerowym zapisać symbol nieskończoności. Jednak ten symbol nie będzie się odnosił do niczego, co istnieje w systemie komputerowym. Nawet gdy stworzymy obiekty pozwalające na operowanie nieskończonością. Z punktu widzenia semantyki to tylko definiowanie nieznanego przez nieznane. Ściśle rzecz biorąc – w poszukiwaniu znaczenia symboli w komputerze możemy dojść do definicji maszyny iteracyjnej11, albo do „czegoś z zewnątrz”12.<br />
<br />
3. Konieczność odwołań do „czegoś z zewnątrz” (istnieje coś więcej) to mocny argument przeciw komputacjonizmowi13.<br />
<br />
=== Podsumowanie ===<br />
Matematyka obiektowa absolutnie nie ma być „nową” matematyką, ale nowym jej przedstawieniem – łatwiejszym do przyswojenia. Łączy „oglądowość” z ideą abstrakcji, zastępując odniesienia do rzeczywistości, odniesieniami do świata wirtualnego, opisywanego w języku informatyki. Matematyka postrzegana jako teoretyczne objaśnienie elementów świata maszyn cyfrowych wydaje się łatwiejsza do zrozumienia niż matematyka jako czysto abstrakcyjny system.<br />
<br />
Dodatkowo, dzięki komputerom abstrakcyjne obiekty informatyki stają się częścią naszej rzeczywistości. Wzmacnia to efekt „oglądowości” (wyjaśniając pojęcia matematyczne można się odwoływać do komputerowych kreacji).<br />
<br />
Obiektowy język informatyki powinien ułatwić nauczanie matematyki - zwłaszcza gdy wzorem krajów skandynawskich zastosujemy kształcenie poprzez udział w zespołach rozwiązujących interdyscyplinarne problemy.<br />
<br />
''Jerzy Wawro, 2022''<br />
<br />
<br />
Przypisy<br />
<br />
1Zob. Jerzy Dadaczyński „''Filozofia matematyki Immanuela. Kanta jako punkt odniesienia filozofii matematyki stowarzyszonych z klasycznymi kierunkami badań podstaw matematyki''” <nowiki>[https://bazhum.muzhp.pl/media/files/Slaskie_Studia_Historyczno_Teologiczne/Slaskie_Studia_Historyczno_Teologiczne-r1999-t32/Slaskie_Studia_Historyczno_Teologiczne-r1999-t32-s22-36/Slaskie_Studia_Historyczno_Teologiczne-r1999-t32-s22-36.pdf]</nowiki>: ''Wymóg nieogladowości dowodów, zawarty we współczesnej metodologii matematyki, który zadomowił się tam ostatecznie od czasów Hilberta, wydaje się oczywisty i niepodważalny. Dziwne może nawet wydać się przypuszczenie, że kiedykolwiek można było wypowiedzieć twierdzenie przeciwne. Był jednak taki okres w dziejach metodologii matematyki − a precyzyjniej: w dziejach filozofii matematyki − kiedy twierdzono, że dowodząc tez matematycznych, nie tylko można, ale wręcz koniecznie trzeba odwoływać się do pewnych form oglądowości, do pewnego rodzaju przedstawień naocznych. Twórcą tego poglądu był Immanuel Kant''.<br />
<br />
2https://encyklopedia.pwn.pl/haslo/Hilbert-David;3911678.html<br />
<br />
3Cel Hilberta (matematyka z wykazaną zupełnością i niesprzecznością) nie jest osiągalny.<br />
<br />
4Jak zauważa Jerzy Daczyński (dz.cyt.): „''współczesne stanowisko można by za pomocą terminologii Kantowskiej oddać następująco: matematyka jest wiedzą czysto pojęciową, w żadnym dowodzie nie można się odwoływać do jakichkolwiek wyobrażeń (empirycznych czy apriorycznych)''”. Czyli zdania matematyki nie są – jak uważał Kant – sądami syntetycznymi apriori, tylko sądami analitycznymi!<br />
<br />
5Marek Mika, „Teoretyczne podstawy programowania liniowego” (<nowiki>http://www.cs.put.poznan.pl/mmika/Teoretyczne%20podstawy%20programowania%20liniowego.pdf</nowiki> ).<br />
<br />
6Definicja przytoczona przez Wikipedię pochodzi z John B. Conway: „''A course in functional analysis''”.<br />
<br />
7Wyjaśnienie wypukłości oraz przytoczonej definicji odcinka znajdziesz na blogu <nowiki>https://byc-matematykiem.pl/tajniki-interpolacji-czesc-1/</nowiki><br />
<br />
8Matematyka dyskretna to nauka o strukturach matematycznych zawierających skończoną liczbę elementów. [Ryan T. White, Archana Tikayat Ray „Practical Discrete Mathematics”]<br />
<br />
9Alternatywne podejście: „Need for Equipping Student Teachers with Language of Mathematics” „''Znaczenie programu nauczania w budowaniu języka matematyki, który umożliwia uczącym się konstruowanie i przekazywanie wiedzy matematycznej, nie zostało docenione, mimo że od lat dyskutuje się o wyzwaniach pedagogicznych, przed którymi stają uczniowie w nauce matematyki. Nauka języka matematyki jest nie tylko cenna sama w sobie, ale także przydatna w zrozumieniu innych dziedzin wiedzy, zwłaszcza nauk ścisłych. Uważa się, że posługiwanie się narzędziami języka matematyki jest nawet pomocne w nauce języków potocznych, zwłaszcza w nauce gramatyki, rytmiki i wersyfikacji. Oczywiste jest, że rozumienie języka matematyki i jego specjalnych terminów tak płynnie, jak to możliwe, oprócz innych korzyści, uwalnia procesy poznawcze w uczącym się, aby móc podejmować bardziej przydatne czynności, w tym rozwiązywać problem. Dlatego ważne jest, aby programy kształcenia nauczycieli uwzględniały w nim elementy składowe lub elementy matematyki w taki sposób, aby struktura języka matematyki była zrozumiała dla uczniów. W artykule omówiono znaczenie języka matematyki, jego strukturę i znaczenie w kształceniu matematycznym. Sugeruje ponadto sposoby przekazywania nowicjuszom zrozumienia języka matematyki. Mając na uwadze znaczenie języka matematyki w nauczaniu uczenia się, w niniejszym opracowaniu rozważono również strategie, które można zastosować, aby wyposażyć przyszłych nauczycieli w umiejętności i kompetencje niezbędne do radzenia sobie z językiem matematyki”.''<br />
<br />
10„W najprostszej postaci aksjomat nieskończoności powiada, że dla każdej liczby naturalnej istnieje jej następnik, zaś aksjomat wyboru postuluje, że dla każdej rodziny zbiorów parami rozłącznych istnieje jej selektor. Nie są to aksjomaty logiczne (postulują one istnienie jakichś obiektów, czego aksjomaty logiki nie robią)”. <nowiki>https://open.uj.edu.pl/mod/book/view.php?id=20&chapterid=112</nowiki><br />
<br />
11Maszyna iteracyjna to teoretyczny konstrukt Zdzisława Pawlaka. Można ją traktować jako alternatywę dla Maszyny Turinga. Składa się z pamięci (elementu o wielu stanach) i funkcji przejścia – wyliczającej na podstawie stanu pamięci w jakim stanie znajdzie się ona w chwili następnej.<br />
<br />
12Ten wynik jest zgodny z poglądami Cantora: <nowiki>https://bazhum.muzhp.pl/media/files/Humanistyka_i_Przyrodoznawstwo/Humanistyka_i_Przyrodoznawstwo-r2004-t10/Humanistyka_i_Przyrodoznawstwo-r2004-t10-s51-68/Humanistyka_i_Przyrodoznawstwo-r2004-t10-s51-68.pdf</nowiki><br />
<br />
13http://www.filozoficznie.pl/4/40_M_Milkowski_Analiza_tezy_komputacjonizmu.pdf</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Elementy_j%C4%99zykoznawstwa_dla_programist%C3%B3w&diff=124Elementy językoznawstwa dla programistów2022-09-25T06:00:35Z<p>Admin: Admin przeniósł stronę Elementy językozawstwa dla programistów na Elementy językoznawstwa dla programistów, bez pozostawienia przekierowania pod starym tytułem: literówka w tytule</p>
<hr />
<div>{|<br />
|-<br />
| |Moduł: Elementy językozawstwa dla programistów <br />
|-<br />
| |Poziom: Zaawanowany<br />
|-<br />
| |Profil: Dla profesjonalistów<br />
|-<br />
|}<br />
<br />
<br />
Każda wypowiedź ma swoją strukturę, którą określamy terminem „[https://pl.wikipedia.org/wiki/Syntaktyka_(językoznawstwo syntaktyka]” lub składnia, oraz swoje znaczenie określane terminem „[https://pl.wikipedia.org/wiki/Semantyka_(językoznawstwo) semantyka]”. Obydwie te dziedziny są przedmiotem zainteresowania informatyki – ale ich znaczenie jest zupełnie różne. Semantyka to przedmiot badania sztucznej inteligencji (komunikacja w języku naturalnym, przetwarzanie wiedzy) oraz filozofii informatyki. Badania syntaktyki zostały natomiast wykorzystywane w rozwoju języków programowania.<br />
<br />
[[Plik:j_gr2.png]]<br />
<br />
Analizy językoznawców wykazały, że zdania dowolnego języka daje się opisać w postaci reguł budowania złożonych wypowiedzi z prostszych struktur. Proces generacji zdań nazywa się też procesem „wywodu”. <br />
<br />
Przykład:<br />
<br />
[[Plik:j_gr3.png]]<br />
<br />
Powstała struktura ma kształt odwróconego drzewa. Dlatego nazywa się ją „drzewem wywodu”.<br />
<br />
<br />
== Gramatyka struktur frazowych ==<br />
Językoznawca [https://pl.wikipedia.org/wiki/Noam_Chomsky Noam Chomsky] stworzył teorię zwaną gramatyką generatywną (lub gramatyką struktur frazowych) opisującą ten proces generacji (dla zdań w formie podstawowej). Informatycy podążyli dalej w tym kierunku tworząc sztuczne języki i automaty je analizujące (translatory). Podstawą była formalizacja teorii gramatyk, którą w zarysie przedstawiono poniżej.<br />
<br />
Gramatyka składa się z: * zbioru symboli terminalnych T (symboli wchodzących w skład wygenerowanych zdań); <br />
* zbioru symboli nieterminalnych N (zbiór symboli pomocniczych służących do przeprowadzenia generacji, oznacza się je często przez ujęcie w nawiasy ostre <...> <nowiki>= zob. </nowiki>[https://pl.wikipedia.org/wiki/Notacja Notacja][https://pl.wikipedia.org/wiki/Notacja_BNF BNF]); <br />
* symbolu początkowego S (wyróżniony symbol nieterminalny od którego rozpoczyna się wywód); <br />
* reguł wywodu pozwalających na zastępowanie symboli nieterminalnych przez ciągi symboli terminalnych i nieterminalnych aż do otrzymania samych symboli terminalnych; <br />
<br />
<br />
<br />
<u>'''Przykład:'''</u><br />
<br />
Dla zdania na powyższym obrazku można zaproponować gramatykę:<br />
<br />
<nowiki><br />
T = { Jan, Zosia, trzyma, ma, czapka, pióro } <br />
N = { <zdanie>, <fraza rzeczownika>, <fraza czasownika>, <rzeczownik>, <czasownik> } <br />
S = <zdanie> <br />
<br />
reguły wywodu ( ::= oznacza operację zastępowania): <br />
<br />
(1) <zdanie> ::= <fraza rzeczownika><fraza czasownika> <br />
(2) <fraza rzeczownika> ::= <rzeczownik> <br />
(3) <fraza czasownika> ::= <czasownik><fraza rzeczownika> <br />
(4) <rzeczownik> ::= Jan | Zosia | czapka | pióro (5) <czasownik> ::= trzyma | ma <br />
</nowiki><br />
<br />
Znak '|' oznacza alternatywę - np. można użyć reguły ''<czasownik> ::= trzyma'' lub ''<czasownik> ::= ma''<br />
<br />
Wywód przykładowego zdania ( w nawiasach podano numery użytych reguł ): <br />
<br />
<br />
S '''-(1)-> '''<fraza rzeczownika> <fraza czasownika> '''-(2)-> '''<rzeczownik><fraza czasownika> '''-(4)-> '''Zosia <fraza czasownika> '''-(3)->''' Zosia <czasownik> <fraza rzeczownika> '''-(5)->''' Zosia ma <fraza rzeczownika> '''-(2)->''' Zosia ma <rzeczownik> '''-(4)-> '''Zosia ma pióro <br />
<br />
<br />
Powyższy wywód można przedstawić w postaci drzewo wywodu, pokazanego na powyższym rysunku. Przy analizie drzewo wywodu nazywane jest też drzewem rozkładu (w jaki sposób zdanie rozkładamy na jego reprezentację). Drzewo to służy następnie wygenerowaniu kodu programu - wykonywanego przez komputer.<br />
<br />
Liście tego drzewa stanowią symbole terminalne. Każde poddrzewo drzewa wywodu nazywa się frazą. Ze względu na typ użytych reguł wywodu, gramatyki dzieli się na: <br />
* <u>regularne</u>: wszystkie reguły są w postaci A ::= aB, lub A ::= a, gdzie A, B - oznaczają symbole nieterminalne, a - symbol terminalny; <br />
* <u>bezkontekstowe</u>: daje się sprowadzić do zbioru takich reguł, że po lewej stronie każdej reguły wywodu znajduje się pojedynczy symbol nieterminalny (zob. [https://pl.wikipedia.org/wiki/Postać_normalna_Greibach postać normalna Greibach])<nowiki>; </nowiki><br />
* <u>kontekstowe</u>: reguły wywodu mogą być dowolnej postaci; <br />
<br />
<br />
<br />
Mniej formalnie można powiedzieć, że gramatyka bezkontekstowa to taka, że przy analizie wypowiedzi można na podstawie wczytanych symboli dokładnie ustalić którą regułę wywodu należy zastosować. <br />
<br />
Zależnie od gramatyki jaka jest konieczna do wygenerowania zdań języka mówimy o językach regularnych, bezkontekstowych i kontekstowych. <br />
<br />
Gramatyki regularne opisują między innymi budowę poszczególnych elementów używanych w językach programowania komputerów (identyfikatory, liczby, słowa kluczowe). Instrukcje języków takich jak Pascal pochodzą z języków bezkontekstowych. W praktyce analiza języków programowania odbywa się dwustopniowo. Najpierw tzw. skaner wydziela z wejściowego łańcucha znaków 'tokeny', czyli wspomniane wcześniej proste elementy znaczeniowe. Później 'parser' analizuje ciąg tokenów tworząc z nich instrukcje języka. Skaner jest zazwyczaj automatem implementującym gramatykę regularną.<br />
<br />
== Języki regularne. Automaty. ==<br />
<br />
Tokeny (liczby, napisy, słowa kluczowe), na które skaner dzieli przetwarzany ciąg znaków mają strukturę, którą można opisać gramatyką języków regularnych. Najbardziej naturalną metodą zapisywania konstrukcji języka regularnego są wyrażenia regularne. Użycie znaku * w tym wyrażeniu oznacza powtórzenie >=0 ilość razy poprzedzającego go symbolu.<br />
<br />
Przykład: <br />
<br />
<br />
{| style="margin:auto;"<br />
|-<br />
| style="background-color:#e6e6e6;border:0.05;" | wyrażenie&nbsp;<br />
| style="background-color:#e6e6e6;border:0.05pt;" | przykłady użycia&nbsp;<br />
|-<br />
| style="border:0.05pt;" | xy*z&nbsp;<br />
| style="border:0.05pt;;" | &nbsp;xyyz, xz, xyyyz<br />
|-<br />
| style="border:0.05pt;" | (xy)*z*&nbsp;<br />
| style="border:0.05pt;" | xyxyzzzz, xyzzzz&nbsp;<br />
|-<br />
|}<br />
<br />
<br />
Analizę języków regularnych wygodnie jest opisywać (a niekiedy także implementować) jako działanie automatów skończenie-stanowych. Automat skończenie-stanowy to zbiór stanów połączonych ze sobą przy pomocy etykietowanych symbolami łuków (lub innych połączeń). Wyróżniany jest jeden stan jako stan początkowy i zbiór stanów końcowych. <br />
<br />
Zadaniem automatu jest analiza ciągu znaków. Jego działanie polega na przechodzeniu od stanu do stanu począwszy od stanu początkowego. Przejście jest możliwe, o ile analizowany symbol (znak) jest identyczny z definicją (etykietą) przejścia. Po przejściu pobierany jest do analizy następny symbol (znak). Jeśli po przetworzeniu całego ciągu znaków automat znajdzie się w stanie końcowym, ciąg należy do języka regularnego (jest akceptowalny przez automat), a stan końcowy wskazuje na to, co ciąg ten oznacza. <br />
<br />
'''Przykład: '''<br />
<br />
[[Plik:j_gr1.png]]<br />
<br />
Automat akceptujący ciąg symboli: a, ab*, lub ab*c oznaczenia:* okrąg oznacza stan początkowy <br />
* prostokąty z okrągłymi rogami (niebieskie) - oznaczają stany końcowe <br />
* prostokąty(pomarańczowe) - pozostałe stany <br />
<br />
<br />
<br />
Uzupełnieniem tego niniejszego są programy z repozytorium [https://github.com/galicea/eduprog https://github.com/galicea/eduprog]. W podkatalogu lang można znaleźć program '''autogram''', który tworzy automat na podstawie wyrażeń regularnych. Wywołanie dla powyższego przykładu: <br />
<br />
'''autogram -a -i "a(&b&)@'''c"<br />
<br />
<br />
W wyniku analizy otrzymujemy tabelkę przejść:<br />
<br />
<br />
<br />
{| style="margin:auto;"<br />
| style="background-color:#e6e6e6;border:0.05;" | | a | b | c<br />
|-<br />
| style="padding:2pt;border:0.05;" | 1 | 2| 0| 0<br />
|-<br />
| style="padding:2pt;border:0.05;"| 2 | 0| 2| 3<br />
|-<br />
| style="padding:2pt;border:0.05;"| 3 | 0| 0| 0<br />
|}<br />
<br />
<br />
W wierszach są zawarte stany automatu, a w kolumnach symbole wyrażenia. Kolumny opisują do którego stanu automat przejdzie po wczytaniu symbolu. Na przykład w stanie 2 symbol '''b '''powoduje pozostanie w tym samym stanie, a symbol '''c - '''przejście do końcowego stanu 3 (gdzie już nic nie można przyjąć).<br />
<br />
== Gramatyki bezkontekstowe ==<br />
<br />
Aby utworzyć drzewo wywodu dla dowolnego zdania zbudowanego w oparciu o gramatykę należałoby po kolei próbować zastosować wszystkie produkcje (poddrzewa), wracając w razie niepowodzenia do wcześniejszego stadium analizy. Ten sposób analizy (analiza z powrotami) jest jednak bardzo nieefektywny. W praktyce na gramatyki bezkontekstowe nakłada się dodatkowe ograniczenia pozwalające jednoznacznie wskazać którą produkcję należy wybrać na podstawie: * dotychczasowego przebiegu analizy (stanu w którym znajduje się analizator (automat)); <br />
* k symboli na wejściu (w praktyce prawie zawsze k=1); <br />
<br />
<br />
<br />
Analiza lewostronna (wywód lewostronny) polega na tym, że czytamy kolejne symbole i na tej podstawie decydujemy jaką regułę zastosować. Potrzebna do tego gramatyka jest określana mianem [https://pl.wikipedia.org/wiki/Parser_LL LL(1)] – dla podkreślenia, że chodzi o 1 symbol z lewej strony drzewa wywodu. Taką gramatykę zastosowano w języku Pascal. Drugą metodą analizy jest analiza prawostronna. Polega ona na tym, że wczytujemy kolejne symbole aż do chwili, gdy skompletujemy wszystkie symbole potrzebne do zastosowania reguły wywodu. Decyduje o tym zawsze ostatni wczytany symbol – czyli symbol z prawej strony drzewa wywodu. Stąd określenie [https://pl.wikipedia.org/wiki/Parser_LR LR(1)]. <br />
<br />
== Gramatyki LL(1) ==<br />
<br />
Gramatyka LL(1) ma tą własność, że każdą produkcję można zidentyfikować na podstawie pierwszego z lewej symbolu po prawej jej stronie. Gramatyki tego typu są najczęściej stosowane przy 'ręcznym' konstruowaniu analizatora. Stosuje się przy tym analizę rekurencyjną. Polega ona na tym, że dla każdej produkcji tworzy się procedurę ją analizującą. Procedury te identyfikują i wywołują odpowiednie procedury dla zanalizowania podfrazy. Dokładny opis tej metody analizy można znaleźć w podręczniku N.Wirtha [2]. <br />
<br />
Poniżej prosty przykład kalkulatora wyrażeń w języku Python, który zawiera analizator LL(1). W przykładzie założono, że liczby są dodatnie jednocyfrowe, a dostępne działania to tylko mnożenie i dodawanie. Dzięki temu skaner (next_token) to tylko pobieranie kolejnego znaku (znak dolara oznacza koniec wejścia a wykrzyknik błąd). Proszę zauważyć, że wystarczy zawsze sprawdzić jaki jest kolejny token, by zdecydować o następnym kroku analizy. Ta stosunkowo prosta zasada sprawia, że analizatory LL(1) można zaimplementować ‘ręcznie’ - bez programów wspierających – takich jak [https://pl.wikipedia.org/wiki/Yacc Yacc] czy [https://www.gnu.org/software/bison/ Bison].<br />
<br />
<syntaxhighlight lang="python" line="1" ><br />
class calculator():<br />
source=[]<br />
digits = ('0','1','2','3','4','5','6','7','8','9')<br />
result=0<br />
token='!'<br />
<br />
def next_token(self):<br />
if len(self.source)==0:<br />
self.token='$'<br />
else:<br />
self.token=self.source[0]<br />
del self.source[0]<br />
<br />
def factor(self): # czynnik<br />
self.result=0<br />
if self.token=='(':<br />
self.next_token()<br />
self.expr()<br />
if self.token != ')':<br />
self.token='!'<br />
else:<br />
self.next_token()<br />
elif self.token in self.digits:<br />
self.result=int(self.token)<br />
self.next_token()<br />
<br />
def term(self): # skladnik<br />
self.factor()<br />
mem=self.result<br />
while self.token=='*':<br />
self.next_token()<br />
self.factor()<br />
mem=mem*self.result<br />
self.result=mem<br />
<br />
def expr(self):<br />
self.result=0<br />
self.term()<br />
mem=self.result<br />
while (self.token=='+'):<br />
self.next_token()<br />
self.term()<br />
mem=mem+self.result<br />
self.result=mem<br />
<br />
def calc(self,expression):<br />
self.source=list(expression)<br />
self.next_token()<br />
self.expr()<br />
if self.token=='$':<br />
return self.result<br />
else:<br />
return None<br />
<br />
</syntaxhighlight><br />
<br />
Przykładowe użycie kalkulatora:<br />
<br />
<syntaxhighlight lang="python" line="1" ><br />
c=calculator()<br />
res=c.calc('4*(2+3)')<br />
if res != None:<br />
print(res)<br />
else:<br />
print('error')<br />
</syntaxhighlight><br />
<br />
'''Gramatyki LR(1) '''<br />
<br />
W przeciwieństwie do poprzedniej, tą gramatykę stosuje się najczęściej przy użyciu generatorów przy pomocy których konstruuje się analizator. Pouczającym może być analiza takiego generatora. W repozytorium [https://github.com/galicea/eduprog https://github.com/galicea/eduprog], w podkatalogu lang znajduje się moduł u_makerl1 i program autogram wykorzystujący ten moduł generatora. Oprogramowanie jest napisane w języku Pascal (z polskimi komentarzami). Może więc być łatwiejsze w analizie (zwłaszcza, że poniżej podano szczegółowe objaśnienie algorytmu), niż rozbudowane generatory wspomniane wcześniej. <br />
<br />
=== Metoda analizy ===<br />
<br />
Analizator jest automatem ze stosem. Oznacza to, że zawiera on pamięć w postaci stosu do której może dopisywać dane dotyczące aktualnego stanu (wkładanie na stos). Możliwe jest także odczytywanie danych w kolejności odwrotnej do tej w jakiej były zapisywane (zdejmowanie ze stosu). Automat pobiera kolejne symbole, wkłada je na stos i zmienia swój stan. Bieżący stan automatu jest zapisywany na stosie wraz z symbolem. Stan automatu opisuje całą zawartość stosu. Jeśli stan ten wskazuje, że na stosie jest pełna fraza - następuje redukcja. Polega ona na zdjęciu ze stosu symboli składających się na tą frazę i zastąpieniu ich symbolem nieterminalnym będący lewą stroną produkcji dającej taką frazę. <br />
<br />
Dzięki pamiętaniu stanu na stosie - po redukcji można ustalić nowy stan automatu. Stan zapisany na wierzchołku stosu opisuje bowiem całą jego zawartość i możemy ustalić jaki stan powstanie po dodaniu nowego symbolu. <br />
<br />
Analiza kończy się poprawnie, gdy pojawi się symbol sygnalizujący koniec danych, a na stosie znajduje się symbol początkowy gramatyki. <br />
<br />
Gramatyka dla takiej metody analizy musi spełniać jeden warunek: prawe części żadnych dwóch produkcji nie mogą być jednakowe (trzeba wiedzieć w oparciu o którą produkcję dokonać analizy). <br />
<br />
Ponieważ w trakcie analizy badamy zawsze jeden - ostatni z prawej symbol wywodu - metoda ta, oraz gramatyka noszą nazwę LR(1). <br />
<br />
=== Algorytm tworzenia automatu LR(1) ===<br />
<br />
1/ Ułożyć gramatykę LR(1) języka. Ponumerować wszystkie produkcje. <br />
<br />
2/ Spisać wszystkie możliwe stany automatu. Jeśli dowolną produkcję można przedstawić w postaci X::=PS, to P jest jednym z możliwych stanów automatu. <br />
<br />
3/ Utworzyć funkcję zmiany stanu stosu przy akceptacji tokenów. Rozróżniamy dwa rodzaje operacji: przesunięcie i redukcja. Przesunięcie polega na dodaniu tokenu na stos. Po przesunięciu pobierany jest następny token. Redukcja polega na zdjęciu ze stosu pełnej frazy.<br />
<br />
<br />
'''PRZESUNIĘCIE:''' <br />
<br />
1) Jeśli istnieją stany stosu PQ i Qt, to dla tokenu t istnieje przejście od stanu PQ do stanu Qt; (oznacza to przejście do analizy podfrazy będącej bardziej z prawej strony).<br />
<br />
2) Jeśli nie zachodzi przypadek 1 - badamy zamiast t wszystkie symbole z których t można wyprowadzić lewostronnie. Oznacza to że jeśli istnieją stany PQ i z QR, oraz z R można wyprowadzić lewostronnie t, to dla tokenu t istnieje przejście od stanu PQ do stanu t;<br />
<br />
'''REDUKCJA: '''<br />
<br />
Dla każdego stanu stosu PQ szukamy najdłuższego łańcucha Q spełniającego warunki: - istnieje produkcja (reguła gramatyczna) r, dla której Q stanowi prawą stronę; - istnieje stan Pl(r), gdzie l(r) oznacza lewą stronę produkcji r; Redukcja r jest wykonywana w sytuacji, gdy przy stanie PQ pojawi się token, dl którego nie można dokonać przesunięcia.# Utworzyć funkcję przejścia do nowego stanu przy redukcji. Jeśli po dołączeniu do stanu ze szczytu stosu lewej strony produkcji r otrzymamy poprawny stan - jest to stan do którego następuje przejście automatu. Jeśli taki stan nie istnieje - następuje próba zanalizowania nowej frazy. Ustalany jest nowy stan opisujący lewą stronę użytej produkcji.<br />
<br />
4/ Zbudować automat działający wg. zasady:<br />
<br />
<syntaxhighlight lang="pascal"><br />
repeat <br />
PobierzNastępnySymbol; <br />
if symbol=znacznikKońcaDanych i na stosie znajduje się symbol początkowy then <br />
koniec <br />
else if dla danego tokenu, oraz aktualnego stanu stosu <br />
istnieje przejście zgodne z funkcja przejścia (pkt. 3) then <br />
włóż symbol na stos z zaznaczeniem nowego stanu <br />
else if istnieje produkcja której prawa strona jest zawarta aktualnie na stosie then <br />
wykonaj redukcję, zmieniając stan na wskazany przez funkcję przejścia zbudowaną w pkt. 4 <br />
else <br />
wystapił błąd <br />
until błąd lub koniec;<br />
</syntaxhighlight><br />
<br />
<br />
Szczegółowy opis gramatyk LR(1) można znaleźć w pracy [1].<br />
<br />
== Przykład ==<br />
<br />
Programem autogram, który zawiera opisany powyżej generator stworzono automat analizujący proste wyrażenia arytmetyczne:<br />
<br />
gramatyka (plik gram.lr1): <br />
<br />
<nowiki><br />
gramatyka (plik gram.lr1): stany: <br />
1: <Z> ::= <W> 1 : <W> <br />
2: <W> ::= <W> + <A> 2 : <W>+ <br />
3: <W> ::= <W> - <A> 3 : <W>+<A> <br />
4: <W> ::= <A> 4 : <W>- <br />
5: <A> ::= <A> * <A> 5 : <W>-<A> <br />
6: <A> ::= <A> / <A> 6 : <A> <br />
7: <A> ::= <B> 7 : <A>* <br />
8: <B> ::= + <C> 8 : <A>*<A> <br />
9: <B> ::= - <C> 9 : <A>/ <br />
10: <B> ::= <C> 10 : <A>/<A> <br />
11: <C> ::= ( <W> ) 11 : <B> <br />
12 : <C> ::= NUM 12 : +<br />
13 : +<C> <br />
14 : - <br />
15 : -<C> <br />
16 : <C> <br />
17 : ( <br />
18 : (<W> <br />
19 : (<W>) <br />
20 : NUM <br />
</nowiki><br />
<br />
<br />
Fragmenty tablic sterujących działaniem automatu:<br />
<nowiki><br />
analiza: <br />
| tokeny <br />
stan: | + - * / ( NUM EOIN <br />
------+-------------------------------------------<br />
0 | 12 14 17 20 <br />
1 | 2 4 <br />
2 | 12 14 17 20 <br />
3 | -2 -2 7 9 -2 -2 -2 <br />
<br />
liczbami dodatnimi oznaczono nowe stany przy przesunięciu, a ujemnymi numery produkcji użytych do redukcji. <br />
EOI = znacznik końca danych <br />
nowe stany po dokonaniu redukcji: <br />
numer | stan <br />
produkcji | 1 2 3 ...... 16 17 18 <br />
----------+--------------------------------------<br />
2 | 1 1 1 1 18 1 <br />
</nowiki><br />
<br />
Zauważ że generator tworzy pewną nadmiarowość. Wynik jego działania można poprawić usuwając dane dotyczące stanów przez które automat nie powinien przechodzić (na przykład w stanie 3 nie może pojawić się symbol '('). Ten automat wykonuje działania tak długo jak to jest możliwe, zamiast zatrzymywać się przy pierwszej nieprawidłowości. <br />
<br />
Na podstawie tego automatu stworzono moduł kalkulatora KALK_LR1.PAS. Dla porównania analogiczny kalkulator zbudowano w oparciu o gramatykę LL(1): KALK_LL1.PAS<br />
<br />
== Bibliografia ==<br />
<br />
# W.M. Waite, G. Goos ''"Konstrukcja kompilatorów"'' <br />
# N. Wirth ''"Algorytmy+struktury danych = programy". ''</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Podstawy_informatyki&diff=123Podstawy informatyki2022-09-25T05:58:01Z<p>Admin: </p>
<hr />
<div><strong>PODSTAWY INFORMATYKI</strong><br />
<br />
<br />
== Część I: Podstawowe pojęcia ==<br />
* Moduł 1.1 [[Algorytm – program – system]]<br />
* Moduł 1.2 [[Uczymy się myśleć abstrakcyjnie]]<br />
* Moduł 1.3 [[Filozoficznie o programach komputerowych]] (dla humanistów i pasjonatów)<br />
* Moduł 1.4 [[Procesor i język maszynowy - wprowadzenie]] (dla inżynierów i techników)<br />
* Moduł 1.5 [[Logika i instrukcje warunkowe]]<br />
<br />
== Część II: Algorytmika ==<br />
* Moduł 2.1 [[Programy a algorytmy]]<br />
* Moduł 2.2 [[Implementacja algorytmów]]<br />
* Moduł 2.3 [[Elementy językoznawstwa dla programistów]] (poziom zaawansowany)<br />
<br />
== Część III: Podstawy programowania ==<br />
* Moduł 3.1. [[Różnorodność struktur programów]]<br />
<br />
== Część IV: Matematyka obiektowa ==<br />
* Moduł 4.1 [[Matematyka obiektowa]]<br />
<br />
== Ważne strony ==<br />
* [//leanpub.com/pyprog leanpub.com/pyprog] - Podręcznik programowania w Pythonie<br />
* [//elearning.otwartaedukacja.pl/ elearning.otwartaedukacja.pl] - '''E-learning'''<br />
<br />
<br />
== Używane programy edukacyjne ==<br />
* [//otwartaedukacja.pl/programowanie/bl/code/ otwartaedukacja.pl/programowanie/bl/code] - układanie programów z bloczków<br />
* [//otwartaedukacja.pl/programowanie/schematy/ otwartaedukacja.pl/programowanie/schematy] - rysowanie schematów blokowych<br />
-</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Strona_g%C5%82%C3%B3wna&diff=122Strona główna2022-09-25T05:52:14Z<p>Admin: </p>
<hr />
<div>'''INFORMATYKA'''<br />
<br />
1. [[Podstawy informatyki]].<br />
<br />
<br />
<br />
-----<br />
<br />
Do tworzenia stron wykorzystano projekt MediaWiki - który na pewno jest wszystkim znany z Wikipedii (zob. [//www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ/pl MediaWiki FAQ]).</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Strona_g%C5%82%C3%B3wna&diff=121Strona główna2022-09-25T05:51:45Z<p>Admin: </p>
<hr />
<div>'''Podstawy informatyki.'''<br />
<br />
1. [[Podstawy informatyki]].<br />
<br />
<br />
<br />
-----<br />
<br />
Do tworzenia stron wykorzystano projekt MediaWiki - który na pewno jest wszystkim znany z Wikipedii (zob. [//www.mediawiki.org/wiki/Special:MyLanguage/Manual:FAQ/pl MediaWiki FAQ]).</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Podstawy_informatyki&diff=120Podstawy informatyki2022-09-25T05:51:14Z<p>Admin: Admin przeniósł stronę Podstawy programowania na Podstawy informatyki, bez pozostawienia przekierowania pod starym tytułem</p>
<hr />
<div><strong>PODSTAWY INFORMATYKI</strong><br />
<br />
<br />
== Część I: Podstawowe pojęcia ==<br />
* Moduł 1.1 [[Algorytm – program – system]]<br />
* Moduł 1.2 [[Uczymy się myśleć abstrakcyjnie]]<br />
* Moduł 1.3 [[Filozoficznie o programach komputerowych]] (dla humanistów i pasjonatów)<br />
* Moduł 1.4 [[Procesor i język maszynowy - wprowadzenie]] (dla inżynierów i techników)<br />
* Moduł 1.5 [[Logika i instrukcje warunkowe]]<br />
<br />
== Część II: Algorytmy i języki programowania ==<br />
* Moduł 2.1 [[Programy a algorytmy]]<br />
* Moduł 2.2 [[Implementacja algorytmów]]<br />
* Moduł 2.3 [[Elementy językozawstwa dla programistów]] (poziom zaawansowany)<br />
<br />
== Część III: Systematyka ==<br />
* Moduł 3.1. [[Różnorodność struktur programów]]<br />
<br />
== Część IV: Projekty ==<br />
* Moduł 4.1 [[Projekt "Ściąga"]] (poziom gimnazjum)<br />
<br />
== Ważne strony ==<br />
* [//leanpub.com/pyprog leanpub.com/pyprog] - Podręcznik programowania w Pythonie<br />
* [//python.otwartaedukacja.pl/ python.otwartaedukacja.pl] - przykłady z podręcznika<br />
* [//bryk.otwartaedukacja.pl bryk.otwartaedukacja.pl] - program "ściąga"....<br />
<br />
* [//elearning.otwartaedukacja.pl/ elearning.otwartaedukacja.pl] - '''E-learning'''<br />
<br />
<br />
== Używane programy edukacyjne ==<br />
* [//otwartaedukacja.pl/programowanie/hanoi/ otwartaedukacja.pl/programowanie/hanoi/] - programowanie łamigłówki Wieże Hanoi<br />
* [//otwartaedukacja.pl/programowanie/bl/code/ otwartaedukacja.pl/programowanie/bl/code] - układanie programów z bloczków<br />
* [//otwartaedukacja.pl/programowanie/schematy/ otwartaedukacja.pl/programowanie/schematy] - rysowanie schematów blokowych<br />
-</div>Adminhttps://wiki.otwartaedukacja.pl/index.php?title=Podstawy_informatyki&diff=119Podstawy informatyki2022-09-25T05:50:29Z<p>Admin: </p>
<hr />
<div><strong>PODSTAWY INFORMATYKI</strong><br />
<br />
<br />
== Część I: Podstawowe pojęcia ==<br />
* Moduł 1.1 [[Algorytm – program – system]]<br />
* Moduł 1.2 [[Uczymy się myśleć abstrakcyjnie]]<br />
* Moduł 1.3 [[Filozoficznie o programach komputerowych]] (dla humanistów i pasjonatów)<br />
* Moduł 1.4 [[Procesor i język maszynowy - wprowadzenie]] (dla inżynierów i techników)<br />
* Moduł 1.5 [[Logika i instrukcje warunkowe]]<br />
<br />
== Część II: Algorytmy i języki programowania ==<br />
* Moduł 2.1 [[Programy a algorytmy]]<br />
* Moduł 2.2 [[Implementacja algorytmów]]<br />
* Moduł 2.3 [[Elementy językozawstwa dla programistów]] (poziom zaawansowany)<br />
<br />
== Część III: Systematyka ==<br />
* Moduł 3.1. [[Różnorodność struktur programów]]<br />
<br />
== Część IV: Projekty ==<br />
* Moduł 4.1 [[Projekt "Ściąga"]] (poziom gimnazjum)<br />
<br />
== Ważne strony ==<br />
* [//leanpub.com/pyprog leanpub.com/pyprog] - Podręcznik programowania w Pythonie<br />
* [//python.otwartaedukacja.pl/ python.otwartaedukacja.pl] - przykłady z podręcznika<br />
* [//bryk.otwartaedukacja.pl bryk.otwartaedukacja.pl] - program "ściąga"....<br />
<br />
* [//elearning.otwartaedukacja.pl/ elearning.otwartaedukacja.pl] - '''E-learning'''<br />
<br />
<br />
== Używane programy edukacyjne ==<br />
* [//otwartaedukacja.pl/programowanie/hanoi/ otwartaedukacja.pl/programowanie/hanoi/] - programowanie łamigłówki Wieże Hanoi<br />
* [//otwartaedukacja.pl/programowanie/bl/code/ otwartaedukacja.pl/programowanie/bl/code] - układanie programów z bloczków<br />
* [//otwartaedukacja.pl/programowanie/schematy/ otwartaedukacja.pl/programowanie/schematy] - rysowanie schematów blokowych<br />
-</div>Admin