--------------------------------------------------
Aleksandar Sarac
mail1:
Starija verzija procedure Anuliraj bi mogla da ostane, ako bi se napravile
promene u Puta i PolinomNaN.
Na primer, ovo je kod mene radilo:
 
PROCEDURE Puta(p1, p2: Polinom; VAR pr: Polinom);
VAR
  pomocni: Polinom;
BEGIN
  Anuliraj(pr);
  pomocni := NIL;
  IF (p1 <> NIL) AND (p2 <> NIL) THEN
 
Linija "pomocni := NIL;": bez nje je promenljiva "pomocni" imala neku
neobičnu vrednost s kojom se
procedura DisposePolinom bezveze prošetala memorijom, saplela se i oborila
program.
 
Ovakva procedura PolinomNaN mi je radila:
PROCEDURE PolinomNaN(p: Polinom; n: CARDINAL;
                     VAR rez: Polinom);
VAR
  i: CARDINAL;
  pom : Polinom;
BEGIN
  IF n = 0 THEN
    NEW(rez);
    rez^.k := 1.0;
    rez^.st := 0;
    rez^.veza := NIL;
(*  ELSIF n = 1 THEN
   Kopiraj( p, rez );*)
  ELSE
    (*rez := p;*)
    Kopiraj(p, rez); (* za n = 1 *)
    FOR i := 2 TO n DO
      Kopiraj(rez, pom);
      (*Puta(rez, p, rez)*)
      Puta(pom, p, rez);
      Anuliraj(pom)
    END
  END
END PolinomNaN;

mail2:
U proceduri Puta je deklarisana promenljiva pomocni, koja, izgleda, dobije
vrednost koja god se našla u memoriji u tom trenutku. Zatim se
pozove MonomPuta(p1, p2, pomocni); i na samom početku te procedure se
poziva Anuliraj. Ako se u memoriji našlo nešto, pa pomocni nije NIL,
DisposePolinom pokuša da oslobodi memoriju s ko zna kakvim vrednostima
pokazivača i padne program. Mislim da je to problem jer procedura "proradi"
čim se na samom početku izvrši pomocni := NIL. Čini mi se da je glavni
problem to što kompajler dozvoljava upotrebu neinicijalizovanih promenljiva.
 
Isto, u proceduri Puta: poziva se MonomPuta(p1, p2, pomocni); u kojoj se
napravi novi polinom na koji pokazuje pomocni, pa se ubacuju monomi, ali se
ne oslobađa memorija.
 
REPEAT
  UbaciMonom(pomocni, pr);
  pomocni := pomocni^.veza
UNTIL pomocni = NIL;
 
Možda bi moglo, na primer, da se napiše procedura koja bi radila isto što
i pomocni := pomocni^.veza, ali bi i oslobađala memoriju:
 
PROCEDURE AnulirajPrvi(VAR p : Polinom);
VAR
  pom : Polinom;
BEGIN
  IF p # NIL THEN
    pom := p;
    p := p^.veza;
    DISPOSE(pom)
  END
END AnulirajPrvi;
 
pa bi kod ubacivanja monoma moglo da stoji:
 
REPEAT
  UbaciMonom(pomocni, pr);
  (*pomocni := pomocni^.veza*)
  AnulirajPrvi(pomocni)
UNTIL pomocni = NIL;

doni:
zapravo bolje ovo poslednje sa SaberiNa i DisposePolinom
--------------------------------------------------

doni:srediti polinome jos malo

doni: liste - dodati nesto gde se brise vise elemenata u istom
prolazu.

vlada:dodati teoremu o pitagorinim trojkama i mozda jos
neka objasnjenja

doni:ubaciti negde primer kako radi Compare za stringove

----------------------------
mils:mozda bi to dodatu funkciju SaberiNa
trebalo inkorporirati u zadatak 4.2 (jedan polinom manje sto se potrosnje
memorije tice i jedan Dispose manje sto se procesora tice).

----------------------------
da li dodati i druge slicne procedure osim SaberiNa?

doni:diskuijom zakljuceno da je ovo valjda i dosta, tj da je dovoljno
za demonstraciju.
---------------------------
StekTip i RedOpslTip umesto Stack i Queue

doni:uradjeno
----------------------------
Polinomi - redosled parametara jos malo unormaliti? kopija je nekako kontra?
optimizacije u vezi oslobadjanja memorije - Anuliraj bi mogao zvati Dispose
za svaki slucaj. Saberi i slicno bi isto mogli biti izmenjeni.
Mozda cak da bude SaberiNa(sab:Polinom; VAR rez:Polinom) pa da 
sve bude u tom jednom, da se ne bi bacala memorija kad je sab(rez,sab,rez).

doni:uradjeno

----------------------
Radacha:
- na vise mesta imamo niz naredbi:
Read(ch);
Write(ch);
Sve Write-ove treba pobrisati da bi kod imao smisla na XDS Moduli.
 
- ponegde se javlja tip LONGCARD, pa se jos mixuje sa CARDINAL tako
sto se radi cast oblika LONGCARD(x), sto na XDS Moduli ne moze.
Valjalo bi sve LONGCARD-e izbaciti, posto su na XDS-u ionako isti
kao CARDINAL.

doni:ovo je sredjeno
------------------------
Igor Sarcevic - bug submit: (patched)
--------------
Pozivom *PolinomNaN( p, 1 , rez )* procedura vraca *rez* koji je pokazivac
na strukturu na koju pokazuje *p*
*
*
greshka se nalazi u 12. redu poshto u sluchaju da je n = 1 for petlja ne
izvrshi ni jednom pa se stim ni ne kopira p u rez
 
PROCEDURE PolinomNaN(p: Polinom; n: CARDINAL;
                     VAR rez: Polinom);
VAR
     i: CARDINAL;
BEGIN
     IF n = 0 THEN
            NEW(rez);
            rez^.k := 1.0;
            rez^.st := 0;
            rez^.veza := NIL;
     ELSE
            *rez := p;*
            FOR i := 2 TO n DO
                    Puta(rez, p, rez)
            END
     END;
END PolinomNaN;
 
 
jednostavan patch :
 
PROCEDURE PolinomNaN(p: Polinom; n: CARDINAL;
                     VAR rez: Polinom);
VAR
     i: CARDINAL;
BEGIN
     IF n = 0 THEN
            NEW(rez);
            rez^.k := 1.0;
            rez^.st := 0;
            rez^.veza := NIL;
*     ELSIF n = 1 THEN*
*            Kopiraj( rez, p );*
     ELSE
            rez := p;
            FOR i := 2 TO n DO
                    Puta(rez, p, rez)
            END
     END;
END PolinomNaN;
 
 
mozda u sushtini nema smisla stepenovati na stepen 1 , ali recimo u
izvodjenju procedure kompozicija ima ( inache pochne program da brljavi kao
meni na vezbama  )

doni:patchovano

-----------------------
Radacha2:

evo necega za PolinomL: u procedurama Unos i Deli posle poziva
procedure UbaciMonom treba ubaciti DISPOSE(novi), da ne curi memorija.
 
doni:patchovano
-----------------------