CLU példaprogramok

Prím iteráció

A CLU egyik igen hasznos eszköze az iteráció. Itt két, prímszámokat szolgáltató iteráció példaprogramját láthatjuk, két különféle módon megoldva.

Prímiteráció I:     (CLU forrás I.)

% Pimszam iteracio I - Primsorozat

primes = iter ( from, to : int ) yields ( int )
  i : int := from
  d, d2d, d2 : int

  if i < 2 then % lehet 1 is
    i := 2
  end %if
  while i <= to do
    d, d2d, d2 := 2, 5, 4
    while d2 <= i cand i // d ~= 0 do
      d, d2d, d2 := d + 1, d2d + 2, d2 + d2d
    end %while
    if d2 > i then
      yield ( i )
    end %if
    i := i + 1
  end %while

end primes

• i // d    - i d-vel való osztásának maradéka
• ~=    - nem egyenlő
• cand     - "and then", "és ha igaz akkor", stb.
• d, d2d, d2 - közös értékadásban szerepelnek, itt pl. d2 a d2d az értékadás előtti értékével számítódik ki.

Az alábbi program a fenti iterációt hasznája az összes prímszám kiírásához:

start_up = proc ()
  po : stream := stream$primary_output()
  po!putl("Primszam iteracio Demo I - Primsorozat")
  for i : int in primes(1, 1000000) do
    po!putl(i!unparse)
  end
end start_up

• po    - a képernyő
• a for cikluson keresztül használhatók az iterációk
• i a for ciklus belső változója (kívűl nem is létezik)
• po!putl(...)  <---> stream$putl(po, ...)    - az új "cukorka"
• i!unparse <---> int$unparse(i)    - számot sztringgé alakít

Fordítása:

>clu2c primesi
>clulink -o primesi primesi.c
>primesi

Prímiteráció II:     (CLU forrás II)

% Pimszam iteracio II - Faktorizacio

all_primes = iter () yields ( int )
  own prime_table : array[int] := array[int]$[2]
  i,p : int

  for pe : int in prime_table!elements do
    yield (pe)
  end %for
  p := prime_table!top + 1
  while true do
    i := 1
    while i <= prime_table!high cand p // prime_table[i] ~= 0 do
      i := i + 1
    end %while
    if i > prime_table!high then
      prime_table!addh(p)
      yield (p)
    end %if
    p := p + 1
  end %while

end all_primes

• own     - statikus változódeklaráció, a hívások között megtartja az értékét
• pe a for ciklus belső változója (cikluson kívül nem is létezik)
• prime_table!elements     - az array típus beépített iterációja
• prime_table!top     - a legnagyobb indexű elem
• prime_table!high     - az index feső határa
• prime_table!addh(p)     - növeli az indextartományt és beírja p-t
• p // prime_table[i]    - p osztásának maradéka
• ~=    - nem egyenlő
• cand     - "and then", "és ha igaz akkor", stb.

Az alábbi program a fenti iterációt használja számok faktorizációs szorzatának kiszámításához. A már kiszámított prímeket eltárolja, így egymás után több faktorizációt hatékonyabban lehet számolni. (Ez a program matematikailag egy kicsit gyorsabb, mint az előző, de a futási időben ez nem mutatkozott meg - lassabb volt. Valószínűleg a nagy tárméret használata miatt.)

start_up = proc ()
  pi: stream := stream$primary_input()
  po: stream := stream$primary_output()
  s, pre : string
  n : int

  po!putl("Primszam iteracio Demo II - Factorizacio")
  while true do
    po!putl("Adjon meg egy szamot (RETURN kilepes): ")
    s := pi!getl
    if s!empty then break end
    n := int$parse(s)
      except when bad_format, overflow: 
        po!putl("Hibas szam!")
        continue
      end
    if n < 2 then
      po!putl("Rossz ertek! (< 2)")
      continue
    end %if
    pre := " = "
    for d : int in all_primes() do
      k : int := 0
      while n // d  = 0 do
        k := k + 1
        n := n / d
      end %while
      if k > 0 then
        po!putl(pre || d!unparse || " ^ " || k!unparse)
        if n < 2 then break end
        if pre = " = " then
          pre := " * "
        end %if
      end %if
    end %for
  end %while

end start_up

• pi, po     - billentyűzet, képernyő (consol)
• break, continue     - megszakítja, ujrakezdi a ciklust
• s!empty <---> string$empty(s) <---> s = ""
• d,k a for ciklus belső változója (cikluson kívül nem is léteznek)
• n // d    - n d-vel való osztásának maradéka
• n / d    - n egész osztása d-vel
• ~=    - nem egyenlő
• int$parse(s)    - sztringet számmá alakít (s nem int típusú, nem cukrozható)
• except when ...     - kivételkezelés
• d!unparse <---> int$unparse(d)    - számot sztringgé alakít

Fordítása:

>clu2c primesii
>clulink -o primesii primesii.c
>primesii