Dyskusja:Algorytm Euklidesa

message: kod do Pythona podany na stronie przy wartosciach ujemnych zawiesza program
moj kod tego nie robi 
def lala(a,b):
    while 1:
        if a==b:
            return a
        elif a > b:
            a, b=b, a-b
        elif a < b:
            a, b=b, b-a
replies: text: i źle nie robi że sie dla ujemnych zawiesza ;) albowiem jest napisane: (...) liczb naturalnych (...) :] jak kto chce stosowac do liczb mniej naturalnych niech sobie "zmodułuje" ;) rownie dobrze ktoś by mógł zgłosic watpliwość, że nie dziala dla ułamków :) --severson 12:27, 28 paź 2004 (CEST)
xd
thread_title: Untitled

message: W "innym przykładzie w Pascalu" brakuje pętli! Mik 06:56, 20 sty 2006 (CET)
function nwd(a,b:integer):integer;
begin
a:=abs(a);
b:=abs(b);
while((a>0)and(b>0)) do 
if(a>b) then a:=a mod b
else b:=b mod a;
if a=0 then nwd:=b
else nwd:=a;
end;
thread_title:  Inny przykład w Pascalu 

message: Jakoś specjalnie nie miałem nigdy potrzeby, więc się nie wyznaję na funkcjach w SQL, ale o ile wiem, to w oficjalnym standardzie nie ma czegoś takiego jak funkcje. Czyżby chodziło tam o coś używanego w PostgreSQL - to znaczy PLSQL? --Nux zostaw notkę 19:00, 4 cze 2006 (CEST)
thread_title:  Implementacja w SQL 

message: co prawda nie ma za wiele czasu i dlatego sam tego nie poprawie, ale w rozszerzonym algorytmie euklidesa rozwiazaniem sa liczby calkowite, nie naturalne, poniewaz NWD(a,b) jest jednoczesnie mniejszy od a i mniejszy od b, a co za tym idzie od dowolnej sumy xa+yb, gdy x,y naleza do liczb naturalnych (oczywiscie zakladajac ze a i b sa nieujemne - tak jak jest w komentarzu do kodu w javascript)
dodatkowo zapraszam na 
http://www.algorytm.org/index.php?option=com_content&task=view&id=166&Itemid=28
thread_title:  liczby calkowite, nie naturalne 

message: Można skorzystać z podwójnego przeczenia bitowego zamiast Math.floor 
Przykładowo
~~6.8
~~3.345
thread_title:  Javascript i zaokrąglanie w dół. 

message: Program rozszerzonego algorytmu w Turbo Pascalu . Zmienną d mozna wykorzystac 
na przyklad do liczenia ilosci iteracji potrzebnych do wykoanania algorytmu . 
Jest NAPRAWDE szybki !!! - 3 lub 4 razy wystarczaja !!!
 ******************************************************************
program Euklides ;
{ Program dziala na zasadzie rozszerzonego algorytmu Euklidesa }
uses dos;
var
    a,b,c,d,p,q,r,s,a0,b0,qout,new_r,new_s:        longint;
begin
  writeln ( ' Program rozszerzonego algorytmu Euklidesa ');
  writeln (' Program oblicza P takie ze P*A = 1 MOD B ');
  writeln ( ' podaj A ' );
  readln (a) ;
  writeln ( ' podaj B - ABY DZIALALO MUSI TO BYC LICZBA PIERWSZA  ');
  readln (b);
  a0 := a;
  b0 := b ;
  p := 1 ;
  q := 0 ;
  r := 0 ;
  s := 1 ;
  while b <> 0 do
   begin
    qout:=trunc( a/b );
    c := a - qout*b;
    a := b;
    b := c;
    new_r := p - qout * r ;
    new_s := q - qout * s ;
    p := r ;
    q := s ;
    r := new_r ;
    s := new_s ;
    d:=1;
   end;
   if p<0 then p:=p+b0;
   { Obliczenia prowadzimy w zakresie b0 - dlatego ta operacja }
   writeln ( ' Program wydaje dwie liczby takie ze ');
   writeln ( ' P * A = 1 MOD B ');
   writeln ( ' P=  ', p , '  dodatkowa zmienna q=' , q );
   writeln ( ' Aby zakonczyc nacisnij ENTER ' ) ;
   readln ;
end.
 *********************************************************************
Rozpatrzmy jak to dziala :
Prosty przyklad liczby 4 i 11 . Wynikiem jest oczywiscie 3 , poniewaz 3*4=12
a 12 mod 11 daje 1 . Mamy wiec liczbe 3 ktora spelnia warunek
   3*4 mod 11 = 1
Jak ja otrzymac ?
Mamy rozszerzony algorytm Euklidesa .
    Czesc algorytmu dziala tak jak standardowy algorytm
    i - numer iteracji
i,,,,a,,,,b,,,,qout - dodatkowa zmienna potrzebna nizej
0,,,,4,,,,11,,,0
1,,,,11,,,4,,,,2
2,,,,4,,,,3,,,,1
3,,,,3,,,,1,,,,3
4,,,,1,,,,0,,,,- tu algorytm sie zatrzymuje poniewaz b=0 .
W kolejnych iteracjach algorytmu
Obliczamy czesc calkowita a/b otrzymujac qout.
W miejsce a wpisujemy b.
W miejsce b wpisujemy wynik a mod b .
    Aby uzyskac wynik czyli liczbe 3 opisana jako p obliczamy :
   r = p - qout * r{poprzednie}
   Czyli otrzymujemy ( {} - oznacza  numer iteracji ) :
   r{1} = 1{p startowe} - 0{qout} * 0{r startowe} = 1
         p = 0 - przeniesione z r w tym wypadku startowego
   r{2} = 0 - 2 * 1 = -2
         p=1 - przeniesione z poprzedniego r , dlatego w algorytmie
         sa dwie zmienne r i NEW_R
   r{3} = 1 -   1 * -2 = 3
         p = -2
   r{4} = -2    -3*3 = -11
         p = 3
Tu algorytm sie zatrymuje i wydaje wynik jako 3 . Jesli wynik wyjdzie
ujemny po prosty dodajemy b do wyniku poniewaz wynik jest utrzymywany
" w kolko " w granicach b .
thread_title:  Rozszerzony Algorytm Euklidesa w Turbo Pascalu z opisem  

message: Moim zdaniem dowód prawdziwości twierdzenia jest delikatnie mówiąc nieprzekonywujący.
Proponuję dodać do niego (przerobioną wersję z angielskiej wiki):
Aby wykazać że NWD (a,b) = NWD (b, a\ mod\ b)
należy udowodnic, iż wspólny podzielnik liczb a i b jest również podzielnikiem liczby a\ mod\ b
Przyjmijmy:
d = NWD (a,b) \Rightarrow a=sd,\ b=td
r = a\ mod\ b \Rightarrow a=pb+r
gdzie s,t,p są liczbami całkowitymi.
Wtedy:
r=a-pb=sd-ptd=d(s-pt)
zatem d jest również podzielnikiem r
----
Potwierdzam - dowód jest niepełny. Można też udowodnić niezmiennik nieco inaczej (prościej?). Na bazie dowodu ze strony wm.staszic.waw.pl.
NWD(a,b) = NWD(b,a\mod b)
Dowód:
Szukamy liczby d takiej, że: d|a \wedge d|b. Zauważmy, że a\mod b=a-b\left[\frac{a}{b}\right]. Z założeń wynika: d|a-b\left[\frac{a}{b}\right]\Leftrightarrow d|a\mod b
...co kończy dowód: liczba d dzieląca a i b, dzieli także a \mod b. A ponieważ 0\leq a\mod b < a zatem NWD(a,b)=\begin{cases} a & \mbox{ dla }b=0 \\ NWD(b, a\mbox{ mod }b) & \mbox{ dla }b\ge1 \end{cases} ma sens, gdyż dla liczb całkowitych wymaga skończonej liczby kroków.
Oczywiście 'moja wersja' jest bardzo chaotyczna (co widać). Ale przydałoby się, by ktoś to przeredagował i zamieścił w artykule. Lub to, co napisano wyżej :)
A i oba dowody są identyczne. Tylko nieco inaczej pokazane ;)
thread_title:  dowód twierdzenia 

message: Artykuł w obecnej postaci przedstawia modyfikację algorytmu Euklidesa, określaną w innych źródłach jako "szybki algorytm Euklidesa" a nie oryginalny algorytm. Oryginalny algorytm Euklidesa jest dużo prostszy  i można go "streścić" zdaniem: "Od większej odejmuj mniejszą aż otrzymasz równe". Algorytm opiera się na spostrzeżeniu, że największy wspólny dzielnik dwóch liczb jest taki sam jak największy wspólny dzielnik ich różnicy i mniejszej z nich. NWD można znaleźć odejmując mniejszą liczbę od większej aż wynik będzie równy mniejszej z nich. Do następnych obliczeń brana jest mniejsza z nich i wynik odejmowania. Przykład dla liczb 12 i 9:
12 - 9 = 3, 
9  - 3 = 6, 
6  - 3 = 3.
Znaleziony NWD w tym przypadku to 3.
=co to ma byc
thread_title:  Artykuł w obecnej postaci nie opisuje algorytmu Euklidesa, lecz jego modyfikację 

message: chyba powinno zostać napisane słowo o algorytmie Euklidesa używanym w algebrze i stosowanym nie tylko do liczb naturalnych, jak wspomniano w artykule, ale także do dowolnego pierścienia euklidesowego. Zatem albo dodatkowy opis albo odnośnik do http://pl.wikipedia.org/wiki/Dziedzina_Euklidesa by się przydał
thread_title:  Wersja Algebraiczna 

message: Dowodzimy lemat NWD(a, b) = NWD(b, a mod b), czyli:
k|a i k|b <=> k|b i k|(a mod b).
Moim zdaniem powinniśmy udowodnić w prawo (=>) i w lewo (<=), a w artykule udowodnione jest tylko w prawo.
Jak myślicie?
thread_title:  Błąd w dowodzie lematu. 

message: Podane kody źródłowe nie są poprawne, bo zwracają czasami liczby ujemne, a według definicji, NWD jest liczbą naturalną. 17:50, 23 kwi 2017 (CEST)
thread_title:  Błędne kody źródłowe