atarionline.pl Action! (+ benchmarks comparision) - Forum Atarum

    Jeśli chcesz wziąć udział w dyskusjach na forum - zaloguj się. Jeżeli nie masz loginu - poproś o członkostwo.

    • :
    • :

    Vanilla 1.1.4 jest produktem Lussumo. Więcej informacji: Dokumentacja, Forum.

      • 1: CommentAuthorurborg
      • CommentTime24 Feb 2020 18:02
       
      @zbyti
      Zoptymalizowałem lekko ten program w basicu :)
      • 2: CommentAuthorzbyti
      • CommentTime24 Feb 2020 18:02 zmieniony
       
      @urborg nieźle! :]

      A wrzucisz jeszcze wyniki dla Turbo-BASIC XL w wersji skompilowanej i bez kompilacji?

      Wtedy podbiję tabelkę :]
      • 3: CommentAuthorxxl
      • CommentTime24 Feb 2020 19:02
       
      no ale skoro optymalizowac to zamiast:

      f.i=1to8191:flag$(i,i)="T":n.i

      prosze zapisac:

      flag$="T":flag$(8191)=flag$:flag$(2)=flag$

      zdaje sie od zawsze ten trik dziala...
      • 4: CommentAuthorzbyti
      • CommentTime24 Feb 2020 19:02 zmieniony
       
      @xxl zaraz to przetestuję.

      Na razie w Turbo-BASIC XL mam takie wyniki jak na obrazkach. Drugi listing to kod na wzór tego co zrobiłem w Quick nie mając tam tablic.

      Umiem kod skompilować w TB ale nie potrafię za pomocą tego co pobrałem z netu użyć linkera. Wiec wyniki dla wersji nieskompilowanej.

      Skoro idziemy na szybkość to do tabelki pójdzie dla BASIC i TB kod z POKE&PEEK.

      Jak ktoś umie to linkować to kod na dyskietce w załączniku.
      • 5: CommentAuthorzbyti
      • CommentTime24 Feb 2020 20:02 zmieniony
       
      Czysty BASIC po przejściu z dwuymiarowej tablicy na Poke&Peek. Chyba taką innowację miał na myśli autor wspomnianego art. że napisał że można szybciej.

      Sądzę, że któraś z osób śledzących ten wątek potrafi jeszcze szybciej w samym BASIC-u.

      CC65           YoshPlus:   41844 iterations in 100 ticks
      Mad Pascal YoshPlus: 35572 iterations in 100 ticks
      Action! YoshPlus: 33239 iterations in 100 ticks
      Quick 2.2 YoshPlus: 21320 iterations in 100 ticks
      Quick 1.6 YoshPlus: 16242 iterations in 100 ticks
      PL65 YoshPlus: 4708 iterations in 100 ticks
      FastBasic FBI YoshPlus: 2427 iterations in 100 ticks
      fig-Forth 1.1 YoshPlus: 715 iterations in 100 ticks
      CLSN Pascal YoshPlus: 487 iterations in 100 ticks

      CC65 Chessboard: 76 iterations in 150 ticks
      Mad Pascal Chessboard: 40 iterations in 150 ticks
      Action! Chessboard: 35 iterations in 150 ticks
      Quick 2.2 Chessboard: 27 iterations in 150 ticks
      Quick 1.6 Chessboard: 16 iterations in 150 ticks
      PL65 Chessboard: 12 iterations in 150 ticks

      MADS (opt) SIEVE: 440 ticks in 10 iterations
      CC65 (opt) SIEVE: 602 ticks in 10 iterations
      Mad Pascal (opt) SIEVE: 644 ticks in 10 iterations
      Mad Pascal SIEVE: 739 ticks in 10 iterations
      Action! SIEVE: 1003 ticks in 10 iterations
      Quick 1.6 SIEVE: 2022 ticks in 10 iterations
      Quick 2.2 SIEVE: 2199 ticks in 10 iterations
      PL65 SIEVE: 3853 ticks in 10 iterations
      FastBasic FBI SIEVE: 6312 ticks in 10 iterations
      fig-Forth 1.1 SIEVE: 8482 ticks in 10 iterations
      Turbo-BASIC XL SIEVE: 64000 ticks in 10 iterations
      BASIC SIEVE: 170700 ticks in 10 iterations
      • 6: CommentAuthorzbyti
      • CommentTime24 Feb 2020 20:02 zmieniony
       
      OK. Udało mi się użyć linkera do Turbo-BASIC XL. Trochę się naszukałem "czegoś" co działa "po ludzku" ;)

      No to ostateczne wyniki. Każdy inny to już jak ktoś przeprowadzi własne testy.

      Wyniki dla TB tak jak dla BASIC jeden przebieg x10.

      Skończyłem zabawę :]

      EDIT:
      Zszedłem w BASIC do około godziny na 10 powtórzeń dla SIEVE co jest zgodne z tym co napisali w swoim manualu twórcy Qick 2.0. Na okładce Lightspeed C jest dla BASIC 31 min co bardziej wygląda (co do minuty) na nieskompilowaną wersję SIEVE w TB z użyciem DIM a nie POKE&PEEK.

      CC65           YoshPlus:   41844 iterations in 100 ticks
      Mad Pascal YoshPlus: 35572 iterations in 100 ticks
      Action! YoshPlus: 33239 iterations in 100 ticks
      Quick 2.2 YoshPlus: 21320 iterations in 100 ticks
      Quick 1.6 YoshPlus: 16242 iterations in 100 ticks
      PL65 YoshPlus: 4708 iterations in 100 ticks
      FastBasic FBI YoshPlus: 2427 iterations in 100 ticks
      fig-Forth 1.1 YoshPlus: 715 iterations in 100 ticks
      CLSN Pascal YoshPlus: 487 iterations in 100 ticks

      CC65 Chessboard: 76 iterations in 150 ticks
      Mad Pascal Chessboard: 40 iterations in 150 ticks
      Action! Chessboard: 35 iterations in 150 ticks
      Quick 2.2 Chessboard: 27 iterations in 150 ticks
      Quick 1.6 Chessboard: 16 iterations in 150 ticks
      PL65 Chessboard: 12 iterations in 150 ticks

      MADS (opt) SIEVE: 440 ticks in 10 iterations
      CC65 (opt) SIEVE: 602 ticks in 10 iterations
      Mad Pascal (opt) SIEVE: 644 ticks in 10 iterations
      Mad Pascal SIEVE: 739 ticks in 10 iterations
      Action! SIEVE: 1003 ticks in 10 iterations
      Quick 1.6 SIEVE: 2022 ticks in 10 iterations
      Quick 2.2 SIEVE: 2199 ticks in 10 iterations
      PL65 SIEVE: 3853 ticks in 10 iterations
      FastBasic FBI SIEVE: 6312 ticks in 10 iterations
      fig-Forth 1.1 SIEVE: 8482 ticks in 10 iterations
      Turbo-BASIC XL [C] SIEVE: 16710 ticks in 10 iterations
      Turbo-BASIC XL SIEVE: 64000 ticks in 10 iterations
      BASIC SIEVE: 170700 ticks in 10 iterations
      • 7: CommentAuthorurborg
      • CommentTime24 Feb 2020 21:02
       
      @zbyti

      Turbobasicem chętnie bym się pobawił w optymalizację ale dziś nie mam czasu i jutro pewnie też nie dam rady. Zdaje się że w turbo basic możnaby przyśpieszyc kod pozbywając się wszystkich instrukcji goto i zastępując je skokami do procedur.
      • 8: CommentAuthorzbyti
      • CommentTime24 Feb 2020 21:02 zmieniony
       
      @urborg to już niech zostanie tak jak jest :]

      Poniżej tabelka do "interpretacji" :D
      • 9: CommentAuthormono
      • CommentTime24 Feb 2020 21:02
       

      zbyti:

      ale dlaczego bez X zaburza pracę programu i daje zły wynik w zliczonych liczbach pierwszy?

      Trudno powiedzieć. Podeślij plik to zobaczymy co on robi. Może w SDX jest jakiś bambol.
      • 10: CommentAuthorzbyti
      • CommentTime24 Feb 2020 21:02
       
      @mono w złączniku
      • 11: CommentAuthorzbyti
      • CommentTime25 Feb 2020 00:02 zmieniony
       
      Nie testowałem ale według informacji z okładki Lightspeed C to SIEVE w 10 iteracjach i przy wyłączonym ekranie miał:

      Lightspeed C  4:49 min 14450 ticks
      Deep Blue C 9:00 min 27000 ticks
      BASIC 31:00 min 93000 ticks

      Tylko to chyba robi różnicę czy PAL czy NTSC? Nie podano. Ja na ticks przeliczyłem * 50.

      Wyłączony ekran daje (z doświadczenia w Action!) około 25% mocy więcej dla CPU.

      Ciekawe jaki magik napisał to w BASIC tak by jechało tylko 31 min?! Nawet przy wyłączonym ekranie...
      • 12: CommentAuthorzbyti
      • CommentTime25 Feb 2020 01:02 zmieniony
       
      Atalan ->link<-
      RTCLOCK@20:byte

      const SQRT_COUNT = 91

      top:0..8191
      sieve:array(top) of 0..1
      k,j,prime:top
      start,time:byte

      "Computing primes..."

      for k
      sieve(k) = 1

      RTCLOCK = 0

      for i:2..SQRT_COUNT where sieve(i) = 1
      j = i * 2
      while j<=8191
      sieve(j) = 0
      j = j + i

      time = RTCLOCK

      "Time used: [time] ticks"
      "Press Q to quit, any other key for list"

      CH = none
      until CH <> none

      for k where sieve(k) = 1 until CH = Q
      "[k]"

      CH = none

      ; Sieve of Erastosthenes
      ; Demo program for ATALAN programming language
      ;(c) 2010 Rudla Kudla
      ;
      ;This version uses bit array so it can find primes up to $ffff.

      use atari
      out rtclock1@20:byte
      out rtclock2@19:byte

      ;Maximum possible prime number.

      const max_prime = $ffff

      const bmax = max_prime/8
      count:0..max_prime

      const
      mask:array(0..7) = 1,2,4,8,16,32,64,128
      maskx:array(0..7) = %1111'1110,%1111'1101,%1111'1011,%1111'0111,%1110'1111,%1101'1111,%1011'1111,%0111'1111

      flags:array(bmax)

      rtclock1 = 0
      rtclock2 = 0

      for i:0..bmax flags(i)=$aa

      for i:3..sqrt max_prime step 2 where (flags(i/8) bitand mask(i mod 8) <> 0)
      for k:i*i..max_prime step 2*i
      flags(k/8) = flags(k/8) bitand maskx(k mod 8)

      count = 1
      for k:3..max_prime step 2 where (flags(k/8) bitand mask(k mod 8) <> 0)
      inc count

      t = rtclock2 * 256 + rtclock1

      "[count] prime numbers in [t] ticks"

      No to mamy nowego pretendenta ;) Chyba algorytm jest tutaj sprytniejszy, po nocy nie będę analizował ;)

      EDIT:
      Jak opanuję podstawy języka to przepiszę na "nasz" i wrzucę do zestawienia :]
      • 13: CommentAuthorilmenit
      • CommentTime25 Feb 2020 01:02
       
      Trzeba by przepisać na ten sam algo...
      • 14: CommentAuthorzbyti
      • CommentTime25 Feb 2020 01:02 zmieniony
       
      @ilmenit mówisz o Atalan? Dopiero się o nim dowiedziałem, jak go ogarnę to przepiszę ;) Powyższy kod jest z dolączonych przykładów.

      Ogarniałem te z listy na stronie ->link<- a tam nie widnieje w spisie, albo coś przeoczyłem.

      No to wyedytuję post i słowo "mistrz" zamienię na "pretendent" ;)
      • 15: CommentAuthorilmenit
      • CommentTime25 Feb 2020 02:02
       
      Haha :D Zbyti, dla mnie to jeden z najciekawszych wątków od dawna!
      • 16: CommentAuthorzbyti
      • CommentTime25 Feb 2020 02:02 zmieniony
       
      @ilmenit cieszę się bo myślałem, że nudzę starych wyjadaczy swoją amatorszczyzną ;) Dla mnie to sposób by się "oswoić" z Atari :]
      • 17: CommentAuthorzbyti
      • CommentTime25 Feb 2020 10:02 zmieniony
       
      Wersja SIEVE dla TBA z przerzuceniem wartości do zmiennych jest wolniejsza od tej z liczbami zabitymi na sztywno w interpretatorze o 16 ticks ale skompilowana już szybsza o 38 ticks dla jednego przebiegu.
      • 18: CommentAuthorzbyti
      • CommentTime25 Feb 2020 11:02 zmieniony
       
      To jeszcze paczuszka, z większością źródeł używanych w testach jaką wrzuciłem na atariage.

      Użyte zostały oficjalne, najnowsze wydania języków na dzień 20.02.2020.
      • 19: CommentAuthorzbyti
      • CommentTime25 Feb 2020 13:02 zmieniony
       
      O dziwo wynik, na C64 w jednym przebiegu jest praktycznie ten sam co na A8 (zakładam, że wrzucenie zmiennych na początek zrobiło podobny narzut interpreterowi jak na A8).
      • 20: CommentAuthorzbyti
      • CommentTime25 Feb 2020 14:02 zmieniony
       
      Niezła dopałka BASIC V2 na C64 to MOSpeed.

      Do obadania ->link<- i tutaj ->link<- puszczone skryptem mospeed.sh z paczki bez żadnych dodatkowych flag.

      10 rem * c64 sieve
      11 a=4096*2:c=8190:b=a+c
      12 poke 161,0:poke 162,0:count=0
      13 for i=a to b:poke i,1:next i
      14 for i=a to b
      15 if peek(i)=0 then 20
      16 ia=i-a:prime=ia+ia+3:k=ia+prime
      17 if k>c then 19
      18 poke k+a,0:k=k+prime:goto 17
      19 count=count+1
      20 next i
      21 print peek(162)+256*peek(161);" jiffies"
      22 print count;" primes"


      • 21: CommentAuthorzbyti
      • CommentTime25 Feb 2020 17:02 zmieniony
       
      Jak widzę @jhusak napisał w Atlanie grę 10 lat temu. Normalnie Leonardo, tak jak o nim mówią ;)

      Atlan dla linuxsiarzy ->link<-

      Niestety nie działa "z pudełka" :(

      Building esieve.atl...

      atari.atl(320) Syntax error: Expected instruction or string

      rule proc %A:rasterProc =
      ^

      Coś jest dokumentnie zdygane w tej wersji z GitHuba. Nie pobawię się widzę... Gość co wystawił te repo, nawrzucał zmiana dla C64 ale dla Atari coś spier...
      • 22: CommentAuthorzbyti
      • CommentTime25 Feb 2020 21:02 zmieniony
       
      Rzuciłem okiem na art. ->link<- i odnalazł się kolejny szybki BASIC, ADVAN zakończył test z wynikiem na poziomie zbliżonym do FastBasic.

      A ponoć jeszcze jest ADVAN OPTIMIZER który ma być 120x szybszy od zwykłego BASIC'a. Plasował by się wtedy zaraz za Action w naszej tabelce.

      Advan BASIC was already pretty fast. Now it's the fastest BASIC in Atari history. In our Sieve Benchmark, the Advan Optimizing Compiler is about four times faster than the MMG Compiler, six times faster than regular Advan, 20 times faster than compiled Turbo-BASIC XL and 120 times faster than uncompiled Atari BASIC. In fact, it's more than half the speed of ACTION!- that's getting real close to pure assembly language.


      Na screenach wersja regular. Algorytm chyba lekko sprawniejszy, ale nie mam siły już tego przepisywać na inne BASIC-i ;)
      • 23:
         
        CommentAuthorjhusak
      • CommentTime25 Feb 2020 21:02
       
      O co chodzi z tym Leonardem?

      Z atalanem - jest problem, bo całe repo było na svn, czyli cała historia poszła w ....
      Nie wiem, czy jest to do odzyskania.

      Natomiast po swojej stronie mam kilka "snapshotów", coś ponad 10 z różnych stadiów.

      Problem zaczął się, gdy Rudli wybuchł przyjęty model (wzorce generowanego kodu w zależności od typów parametrów) przy wprowadzaniu 3-bajtowych liczb.

      Rozmawiałem z Rudlą nt. przyjętego rozwiązania (nie używał narzędzi typu bison, byacc), napisał, że "chce mieć wszystko pod kontrolą" - jak widać kontrola mu się i tak rozjechała tak, że się znudził (czy jakoś tak) projektem.
      • 24: CommentAuthorzbyti
      • CommentTime25 Feb 2020 21:02 zmieniony
       
      @jhusak no za Leonarda mają Cie Kaz & TDC ;) Ale nie tego z TBBT :D

      Dzięki za obszerniejsze info o Atalanie, strasznie się napaliłem ale nijak nie mogę tego uruchomić na A8 jako target :(

      -------------

      A teraz ADVAN OPTIMIZER w akcji! Gdyby zrobić 10 iteracji to wynik po przeliczeniu odpowiada temu z Action! i wynosi 1050 ticks!

      CC65           YoshPlus:   41844 iterations in 100 ticks
      Mad Pascal YoshPlus: 35572 iterations in 100 ticks
      Action! YoshPlus: 33239 iterations in 100 ticks
      Quick 2.2 YoshPlus: 21320 iterations in 100 ticks
      Quick 1.6 YoshPlus: 16242 iterations in 100 ticks
      PL65 YoshPlus: 4708 iterations in 100 ticks
      FastBasic FBI YoshPlus: 2427 iterations in 100 ticks
      fig-Forth 1.1 YoshPlus: 715 iterations in 100 ticks
      CLSN Pascal YoshPlus: 487 iterations in 100 ticks

      CC65 Chessboard: 76 iterations in 150 ticks
      Mad Pascal Chessboard: 40 iterations in 150 ticks
      Action! Chessboard: 35 iterations in 150 ticks
      Quick 2.2 Chessboard: 27 iterations in 150 ticks
      Quick 1.6 Chessboard: 16 iterations in 150 ticks
      PL65 Chessboard: 12 iterations in 150 ticks

      MADS (opt) SIEVE: 440 ticks in 10 iterations
      CC65 (opt) SIEVE: 602 ticks in 10 iterations
      Mad Pascal (opt) SIEVE: 644 ticks in 10 iterations
      Mad Pascal SIEVE: 739 ticks in 10 iterations
      Action! SIEVE: 1003 ticks in 10 iterations
      Advan BASIC (opt) SIEVE: 1050 ticks in 10 iterations
      Quick 1.6 SIEVE: 2022 ticks in 10 iterations
      Quick 2.2 SIEVE: 2199 ticks in 10 iterations
      PL65 SIEVE: 3853 ticks in 10 iterations
      FastBasic FBI SIEVE: 6312 ticks in 10 iterations
      Advan BASIC SIEVE: 6800 ticks in 10 iterations
      fig-Forth 1.1 SIEVE: 8482 ticks in 10 iterations
      Turbo-BASIC XL [C] SIEVE: 16710 ticks in 10 iterations
      Turbo-BASIC XL SIEVE: 64000 ticks in 10 iterations
      BASIC SIEVE: 170700 ticks in 10 iterations
      • 25:
         
        CommentAuthorjhusak
      • CommentTime25 Feb 2020 22:02 zmieniony
       
      A z tym esieve.atl skompilowałem starutką wersją v29 i wyszło 38 ticks na 1 obrót, co daje ~380 ticks na 10. I tak jest świetnie.
      Z tego wynika, że najprawdopodobniej podejście Rudli jest najlepsze do generowania kodu na 6502.
      Jest taka strona ->link<- pokazująca i opisująca różne rozwiązania kompilatorów wyżej czy niżejpoziomowych.
      • 26: CommentAuthorzbyti
      • CommentTime25 Feb 2020 22:02 zmieniony
       
      @jhusak ale tam jest inny algorytm, jakbyś go przerobił na ten używany przez nas to było by to lepsze do porównania.

      Jest wyżej paczka z kodami to możesz sobaczyć sieve w kilu językach, jeżeli miałbyś czas i chęć przenieść na Atalane.

      Wiem, że tyle wychodzi bo sobie asm skompilowałem ;) Chciałem przerobić ale nie mam jak :[
      • 27:
         
        CommentAuthorjhusak
      • CommentTime25 Feb 2020 22:02
       
      Spróbuję w wolnej chwili przerobić, tylko muszę sobie przypomnieć :)
      • 28: CommentAuthorzbyti
      • CommentTime25 Feb 2020 23:02 zmieniony
       
      No i algorytm panów od Advan Basic jest bardzo szybką opcją :] Turbo BASIC XL nieskompilowany przyspieszył o ~30% :] Za to skompilowana zwolniła :D

      Nie odmówię sobie jednak i w wolnej chwili po przepisuję ten benchmark :] Ale tabelki już nie podbijam.

      Teraz widzę, że FastBasic używa tego samego algorytmu co Advan Basic więc i tak tabelka do przepisania ;)
      • 29: CommentAuthorilmenit
      • CommentTime25 Feb 2020 23:02
       
      Problem zaczął się, gdy Rudli wybuchł przyjęty model (wzorce generowanego kodu w zależności od typów parametrów) przy wprowadzaniu 3-bajtowych liczb.

      Możesz napisać coś więcej? Podejście w Atalanie do generacji kodu było całkiem ciekawe (choć nie nowe, artykuł o podobnym sposobie z 1968 roku ->link<- ;) ).
      Kiedyś nawet myślałem, żeby do tego projektu dołączyć i zrobić superoptimizer dla 6502 na styl ->link<- . Teraz widzę, że nie byłem jedyny i już są projekty takie dla 6502 np. ->link<-
      • 30: CommentAuthorzbyti
      • CommentTime25 Feb 2020 23:02 zmieniony
       
      Podbijam prośbę @ilmenit :]

      --------------------------------------------------

      Atari Basic na nowym algo :]
      • 31: CommentAuthorzbyti
      • CommentTime26 Feb 2020 00:02 zmieniony
       
      Sprawa okazuje się odwrotna, tylko dla Atari Basic, Turbo Basic XL (nawet usprawniając kod przepisany z ANALOGU) miałem inną implementację niż reszta paczki.

      Action! Pascal i inne mają taką jak Advan Basic czy FastBasic także co było do poprawienia to już poprawiłem, więc uzupełnię tabelkę od razu :]
      • 32: CommentAuthorzbyti
      • CommentTime26 Feb 2020 00:02 zmieniony
       
      CC65           YoshPlus:   41844 iterations in 100 ticks
      Mad Pascal YoshPlus: 35572 iterations in 100 ticks
      Action! YoshPlus: 33239 iterations in 100 ticks
      Quick 2.2 YoshPlus: 21320 iterations in 100 ticks
      Quick 1.6 YoshPlus: 16242 iterations in 100 ticks
      PL65 YoshPlus: 4708 iterations in 100 ticks
      FastBasic FBI YoshPlus: 2427 iterations in 100 ticks
      fig-Forth 1.1 YoshPlus: 715 iterations in 100 ticks
      CLSN Pascal YoshPlus: 487 iterations in 100 ticks

      CC65 Chessboard: 76 iterations in 150 ticks
      Mad Pascal Chessboard: 40 iterations in 150 ticks
      Action! Chessboard: 35 iterations in 150 ticks
      Quick 2.2 Chessboard: 27 iterations in 150 ticks
      Quick 1.6 Chessboard: 16 iterations in 150 ticks
      PL65 Chessboard: 12 iterations in 150 ticks

      MADS (opt) SIEVE: 440 ticks in 10 iterations
      CC65 (opt) SIEVE: 602 ticks in 10 iterations
      Mad Pascal (opt) SIEVE: 644 ticks in 10 iterations
      Mad Pascal SIEVE: 739 ticks in 10 iterations
      Action! SIEVE: 1003 ticks in 10 iterations
      Advan BASIC (opt) SIEVE: 1050 ticks in 10 iterations
      Quick 1.6 SIEVE: 2022 ticks in 10 iterations
      Quick 2.2 SIEVE: 2199 ticks in 10 iterations
      PL65 SIEVE: 3853 ticks in 10 iterations
      FastBasic FBI SIEVE: 6312 ticks in 10 iterations
      Advan BASIC SIEVE: 6800 ticks in 10 iterations
      fig-Forth 1.1 SIEVE: 8482 ticks in 10 iterations
      Turbo-BASIC XL [C] SIEVE: 16880 ticks in 10 iterations
      Turbo-BASIC XL SIEVE: 46060 ticks in 10 iterations
      BASIC SIEVE: 133960 ticks in 10 iterations
      • 33: CommentAuthorilmenit
      • CommentTime26 Feb 2020 00:02 zmieniony
       
      @zbyti - może warto by zmienić "MADS" na "Asm (MADS) (opt)"?
      • 34: CommentAuthorzbyti
      • CommentTime26 Feb 2020 00:02 zmieniony
       
      @ilmenit zrobię tak jeżeli dostanę wyniki z innego assamblera. Na ten moment nie mam go od czego odróżniać :]

      Znalazłem właśnie fajną stronkę ->link<- szkoda, że nie zaszukałem wcześniej :]

      -----------------------------------------------------------

      Tymczasem, by sobie jednak porównać z Atalanem wklepię to:

      DIM n AS Integer, k AS Integer, limit AS Integer

      INPUT "Enter number to search to: "; limit
      DIM flags(limit) AS Integer

      FOR n = 2 TO SQR(limit)
      IF flags(n) = 0 THEN
      FOR k = n*n TO limit STEP n
      flags(k) = 1
      NEXT k
      END IF
      NEXT n

      ' Display the primes
      FOR n = 2 TO limit
      IF flags(n) = 0 THEN PRINT n; ", ";
      NEXT n
      • 35: CommentAuthorilmenit
      • CommentTime26 Feb 2020 02:02 zmieniony
       
      @zbyti - wyniki zależnie od asemblera różnić się nie będą. To w końcu kod maszynowy.

      A oto i Millfork 0.3.14, który wychodzi na prowadzenie ;)

      Chessboard nie zmienia tryby graficznego, bo nie widziałem jak to prosto w tym języku napisać (wsparcie dla Atari OS jest tam aktualnie minimalne), ale nie powinno to wpływać znacząco na wynik.

      Zaskakująco słabo wypadł test Sieve. Napiszę do autora języka, czy można jakoś zoptymalizować ten kod pozostawiając algorytm.

      Rezultaty:
      Yoshplus - 41921
      Chessboard - 79
      Sieve (opt) - 701
      Sieve (non-opt) - 791
      • 36: CommentAuthorzbyti
      • CommentTime26 Feb 2020 03:02 zmieniony
       
      @ilmenit jutro to wrzucę w tabelę. Wyniki naprawdę zachęcające!

      Każdy assembler ta taki sam kod maszynowy? Chyba to czasem się różni, makra te sprawy, ale faktycznie jakby nie używać ficzerów to wszędzie powinno być tak samo.

      Zaimplementowałem ten kod z esieve.atl.

      Przy tym samym algorytmie Mad Pascal z optymalizacją w jednym przebiegu jest 3 ticks wolniejszy od Atalana.

      Zaimplementowałem dla pewności jeszcze w Advan Basic (bez optymalizacji i z optymalizacją). Mad Pascal jest z opt.

      Ergo. Jeżeli Atalan chce się znaleźć w naszej tabelce ktoś musi napisać SIEVE po naszemu. Albo my korygujemy.

      // Eratosthenes Sieve Benchmark

      uses crt;

      {$define FAST}

      const
      size = 8191;
      sqr_count = 91;

      var
      flags: array [0..size] of boolean;
      rtClock: byte absolute $14;

      {$ifdef FAST}
      n: word absolute $e0;
      k: word absolute $e2;
      count: word absolute $e6;
      {$else}
      n, k, count: word;
      {$endif}

      begin
      writeln('Mad Pascal');
      writeln('Eratosthenes Sieve Benchmark');

      rtClock := 0;
      fillchar(flags, sizeof(flags), true);
      for n := 2 to sqr_count do begin
      if flags[n] then begin
      k := n shl 1;
      while k <= size do begin
      flags[k] := false;
      Inc(k,n);
      end;
      end;
      end;
      writeln(rtClock, ' ticks');

      count :=0;
      for n := 2 to size do begin
      if flags[n] then Inc(count);
      end;

      writeln(count, ' primes');
      repeat until keypressed;
      end.
      • 37: CommentAuthorzbyti
      • CommentTime26 Feb 2020 04:02 zmieniony
       
      Tak dla porządku:

      There are 1229 prime numbers between 1 and 10,000. They are given here below ->link<-

      2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127, 131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193, 197, 199, 211, 223, 227, 229, 233, 239, 241, 251, 257, 263, 269, 271, 277, 281, 283, 293, 307, 311, 313, 317, 331, 337, 347, 349, 353, 359, 367, 373, 379, 383, 389, 397, 401, 409, 419, 421, 431, 433, 439, 443, 449, 457, 461, 463, 467, 479, 487, 491, 499, 503, 509, 521, 523, 541, 547, 557, 563, 569, 571, 577, 587, 593, 599, 601, 607, 613, 617, 619, 631, 641, 643, 647, 653, 659, 661, 673, 677, 683, 691, 701, 709, 719, 727, 733, 739, 743, 751, 757, 761, 769, 773, 787, 797, 809, 811, 821, 823, 827, 829, 839, 853, 857, 859, 863, 877, 881, 883, 887, 907, 911, 919, 929, 937, 941, 947, 953, 967, 971, 977, 983, 991, 997, 1009, 1013, 1019, 1021, 1031, 1033, 1039, 1049, 1051, 1061, 1063, 1069, 1087, 1091, 1093, 1097, 1103, 1109, 1117, 1123, 1129, 1151, 1153, 1163, 1171, 1181, 1187, 1193, 1201, 1213, 1217, 1223, 1229, 1231, 1237, 1249, 1259, 1277, 1279, 1283, 1289, 1291, 1297, 1301, 1303, 1307, 1319, 1321, 1327, 1361, 1367, 1373, 1381, 1399, 1409, 1423, 1427, 1429, 1433, 1439, 1447, 1451, 1453, 1459, 1471, 1481, 1483, 1487, 1489, 1493, 1499, 1511, 1523, 1531, 1543, 1549, 1553, 1559, 1567, 1571, 1579, 1583, 1597, 1601, 1607, 1609, 1613, 1619, 1621, 1627, 1637, 1657, 1663, 1667, 1669, 1693, 1697, 1699, 1709, 1721, 1723, 1733, 1741, 1747, 1753, 1759, 1777, 1783, 1787, 1789, 1801, 1811, 1823, 1831, 1847, 1861, 1867, 1871, 1873, 1877, 1879, 1889, 1901, 1907, 1913, 1931, 1933, 1949, 1951, 1973, 1979, 1987, 1993, 1997, 1999, 2003, 2011, 2017, 2027, 2029, 2039, 2053, 2063, 2069, 2081, 2083, 2087, 2089, 2099, 2111, 2113, 2129, 2131, 2137, 2141, 2143, 2153, 2161, 2179, 2203, 2207, 2213, 2221, 2237, 2239, 2243, 2251, 2267, 2269, 2273, 2281, 2287, 2293, 2297, 2309, 2311, 2333, 2339, 2341, 2347, 2351, 2357, 2371, 2377, 2381, 2383, 2389, 2393, 2399, 2411, 2417, 2423, 2437, 2441, 2447, 2459, 2467, 2473, 2477, 2503, 2521, 2531, 2539, 2543, 2549, 2551, 2557, 2579, 2591, 2593, 2609, 2617, 2621, 2633, 2647, 2657, 2659, 2663, 2671, 2677, 2683, 2687, 2689, 2693, 2699, 2707, 2711, 2713, 2719, 2729, 2731, 2741, 2749, 2753, 2767, 2777, 2789, 2791, 2797, 2801, 2803, 2819, 2833, 2837, 2843, 2851, 2857, 2861, 2879, 2887, 2897, 2903, 2909, 2917, 2927, 2939, 2953, 2957, 2963, 2969, 2971, 2999, 3001, 3011, 3019, 3023, 3037, 3041, 3049, 3061, 3067, 3079, 3083, 3089, 3109, 3119, 3121, 3137, 3163, 3167, 3169, 3181, 3187, 3191, 3203, 3209, 3217, 3221, 3229, 3251, 3253, 3257, 3259, 3271, 3299, 3301, 3307, 3313, 3319, 3323, 3329, 3331, 3343, 3347, 3359, 3361, 3371, 3373, 3389, 3391, 3407, 3413, 3433, 3449, 3457, 3461, 3463, 3467, 3469, 3491, 3499, 3511, 3517, 3527, 3529, 3533, 3539, 3541, 3547, 3557, 3559, 3571, 3581, 3583, 3593, 3607, 3613, 3617, 3623, 3631, 3637, 3643, 3659, 3671, 3673, 3677, 3691, 3697, 3701, 3709, 3719, 3727, 3733, 3739, 3761, 3767, 3769, 3779, 3793, 3797, 3803, 3821, 3823, 3833, 3847, 3851, 3853, 3863, 3877, 3881, 3889, 3907, 3911, 3917, 3919, 3923, 3929, 3931, 3943, 3947, 3967, 3989, 4001, 4003, 4007, 4013, 4019, 4021, 4027, 4049, 4051, 4057, 4073, 4079, 4091, 4093, 4099, 4111, 4127, 4129, 4133, 4139, 4153, 4157, 4159, 4177, 4201, 4211, 4217, 4219, 4229, 4231, 4241, 4243, 4253, 4259, 4261, 4271, 4273, 4283, 4289, 4297, 4327, 4337, 4339, 4349, 4357, 4363, 4373, 4391, 4397, 4409, 4421, 4423, 4441, 4447, 4451, 4457, 4463, 4481, 4483, 4493, 4507, 4513, 4517, 4519, 4523, 4547, 4549, 4561, 4567, 4583, 4591, 4597, 4603, 4621, 4637, 4639, 4643, 4649, 4651, 4657, 4663, 4673, 4679, 4691, 4703, 4721, 4723, 4729, 4733, 4751, 4759, 4783, 4787, 4789, 4793, 4799, 4801, 4813, 4817, 4831, 4861, 4871, 4877, 4889, 4903, 4909, 4919, 4931, 4933, 4937, 4943, 4951, 4957, 4967, 4969, 4973, 4987, 4993, 4999, 5003, 5009, 5011, 5021, 5023, 5039, 5051, 5059, 5077, 5081, 5087, 5099, 5101, 5107, 5113, 5119, 5147, 5153, 5167, 5171, 5179, 5189, 5197, 5209, 5227, 5231, 5233, 5237, 5261, 5273, 5279, 5281, 5297, 5303, 5309, 5323, 5333, 5347, 5351, 5381, 5387, 5393, 5399, 5407, 5413, 5417, 5419, 5431, 5437, 5441, 5443, 5449, 5471, 5477, 5479, 5483, 5501, 5503, 5507, 5519, 5521, 5527, 5531, 5557, 5563, 5569, 5573, 5581, 5591, 5623, 5639, 5641, 5647, 5651, 5653, 5657, 5659, 5669, 5683, 5689, 5693, 5701, 5711, 5717, 5737, 5741, 5743, 5749, 5779, 5783, 5791, 5801, 5807, 5813, 5821, 5827, 5839, 5843, 5849, 5851, 5857, 5861, 5867, 5869, 5879, 5881, 5897, 5903, 5923, 5927, 5939, 5953, 5981, 5987, 6007, 6011, 6029, 6037, 6043, 6047, 6053, 6067, 6073, 6079, 6089, 6091, 6101, 6113, 6121, 6131, 6133, 6143, 6151, 6163, 6173, 6197, 6199, 6203, 6211, 6217, 6221, 6229, 6247, 6257, 6263, 6269, 6271, 6277, 6287, 6299, 6301, 6311, 6317, 6323, 6329, 6337, 6343, 6353, 6359, 6361, 6367, 6373, 6379, 6389, 6397, 6421, 6427, 6449, 6451, 6469, 6473, 6481, 6491, 6521, 6529, 6547, 6551, 6553, 6563, 6569, 6571, 6577, 6581, 6599, 6607, 6619, 6637, 6653, 6659, 6661, 6673, 6679, 6689, 6691, 6701, 6703, 6709, 6719, 6733, 6737, 6761, 6763, 6779, 6781, 6791, 6793, 6803, 6823, 6827, 6829, 6833, 6841, 6857, 6863, 6869, 6871, 6883, 6899, 6907, 6911, 6917, 6947, 6949, 6959, 6961, 6967, 6971, 6977, 6983, 6991, 6997, 7001, 7013, 7019, 7027, 7039, 7043, 7057, 7069, 7079, 7103, 7109, 7121, 7127, 7129, 7151, 7159, 7177, 7187, 7193, 7207, 7211, 7213, 7219, 7229, 7237, 7243, 7247, 7253, 7283, 7297, 7307, 7309, 7321, 7331, 7333, 7349, 7351, 7369, 7393, 7411, 7417, 7433, 7451, 7457, 7459, 7477, 7481, 7487, 7489, 7499, 7507, 7517, 7523, 7529, 7537, 7541, 7547, 7549, 7559, 7561, 7573, 7577, 7583, 7589, 7591, 7603, 7607, 7621, 7639, 7643, 7649, 7669, 7673, 7681, 7687, 7691, 7699, 7703, 7717, 7723, 7727, 7741, 7753, 7757, 7759, 7789, 7793, 7817, 7823, 7829, 7841, 7853, 7867, 7873, 7877, 7879, 7883, 7901, 7907, 7919, 7927, 7933, 7937, 7949, 7951, 7963, 7993, 8009, 8011, 8017, 8039, 8053, 8059, 8069, 8081, 8087, 8089, 8093, 8101, 8111, 8117, 8123, 8147, 8161, 8167, 8171, 8179, 8191, 8209, 8219, 8221, 8231, 8233, 8237, 8243, 8263, 8269, 8273, 8287, 8291, 8293, 8297, 8311, 8317, 8329, 8353, 8363, 8369, 8377, 8387, 8389, 8419, 8423, 8429, 8431, 8443, 8447, 8461, 8467, 8501, 8513, 8521, 8527, 8537, 8539, 8543, 8563, 8573, 8581, 8597, 8599, 8609, 8623, 8627, 8629, 8641, 8647, 8663, 8669, 8677, 8681, 8689, 8693, 8699, 8707, 8713, 8719, 8731, 8737, 8741, 8747, 8753, 8761, 8779, 8783, 8803, 8807, 8819, 8821, 8831, 8837, 8839, 8849, 8861, 8863, 8867, 8887, 8893, 8923, 8929, 8933, 8941, 8951, 8963, 8969, 8971, 8999, 9001, 9007, 9011, 9013, 9029, 9041, 9043, 9049, 9059, 9067, 9091, 9103, 9109, 9127, 9133, 9137, 9151, 9157, 9161, 9173, 9181, 9187, 9199, 9203, 9209, 9221, 9227, 9239, 9241, 9257, 9277, 9281, 9283, 9293, 9311, 9319, 9323, 9337, 9341, 9343, 9349, 9371, 9377, 9391, 9397, 9403, 9413, 9419, 9421, 9431, 9433, 9437, 9439, 9461, 9463, 9467, 9473, 9479, 9491, 9497, 9511, 9521, 9533, 9539, 9547, 9551, 9587, 9601, 9613, 9619, 9623, 9629, 9631, 9643, 9649, 9661, 9677, 9679, 9689, 9697, 9719, 9721, 9733, 9739, 9743, 9749, 9767, 9769, 9781, 9787, 9791, 9803, 9811, 9817, 9829, 9833, 9839, 9851, 9857, 9859, 9871, 9883, 9887, 9901, 9907, 9923, 9929, 9931, 9941, 9949, 9967, 9973.

      Czyli powinniśmy znaleźć 1028 liczb pierwszych jeżeli ostatnią ma być 8191 :]

      To znaczy, że SIEVE z naszych testów źle liczy a ten z Atalan dobrze.

      Zastanawia mnie powszechność tej złej implementacji co oddaje 1899 liczb?
      • 38: CommentAuthorzbyti
      • CommentTime26 Feb 2020 09:02 zmieniony
       
      Millfork              YoshPlus:41921 iterations in 100 ticks
      CC65 YoshPlus:41844 iterations in 100 ticks
      Mad Pascal YoshPlus:35572 iterations in 100 ticks
      Action! YoshPlus:33239 iterations in 100 ticks
      Quick 2.2 YoshPlus:21320 iterations in 100 ticks
      Quick 1.6 YoshPlus:16242 iterations in 100 ticks
      PL65 YoshPlus: 4708 iterations in 100 ticks
      FastBasic FBI YoshPlus: 2427 iterations in 100 ticks
      fig-Forth 1.1 YoshPlus: 715 iterations in 100 ticks
      CLSN Pascal YoshPlus: 487 iterations in 100 ticks

      Millfork Chessboard: 79 iterations in 150 ticks
      CC65 Chessboard: 76 iterations in 150 ticks
      Mad Pascal Chessboard: 40 iterations in 150 ticks
      Action! Chessboard: 35 iterations in 150 ticks
      Quick 2.2 Chessboard: 27 iterations in 150 ticks
      Quick 1.6 Chessboard: 16 iterations in 150 ticks
      PL65 Chessboard: 12 iterations in 150 ticks

      MADS 2.1.0 (opt) SIEVE: 440 ticks in 10 iterations
      CC65 2.1.8 (opt) SIEVE: 602 ticks in 10 iterations
      Mad Pascal 1.6.4 (opt) SIEVE: 644 ticks in 10 iterations
      Millfork 0.3.14 (opt) SIEVE: 701 ticks in 10 iterations
      Mad Pascal 1.6.4 SIEVE: 739 ticks in 10 iterations
      Millfork 0.3.14 SIEVE: 791 ticks in 10 iterations
      Action! 3.7p SIEVE: 1003 ticks in 10 iterations
      Advan BASIC (opt) SIEVE: 1050 ticks in 10 iterations
      Quick 1.6 SIEVE: 2022 ticks in 10 iterations
      Quick 2.2 SIEVE: 2199 ticks in 10 iterations
      PL65 SIEVE: 3853 ticks in 10 iterations
      FastBasic 4.0 FBI SIEVE: 6312 ticks in 10 iterations
      Advan BASIC SIEVE: 6800 ticks in 10 iterations
      fig-Forth 1.1 SIEVE: 8482 ticks in 10 iterations
      Turbo-BASIC XL 1.5 [C] SIEVE: 16880 ticks in 10 iterations
      Turbo-BASIC XL 1.5 SIEVE: 46060 ticks in 10 iterations
      Atari BASIC SIEVE: 133960 ticks in 10 iterations
      • 39: CommentAuthorzbyti
      • CommentTime26 Feb 2020 10:02 zmieniony
       
      Ten algorytm na liczby pierwsze który używamy w teście jest zdecydowanie do dupy. Zbiera 956 liczb parzystych ;P czyli nie wyłapuje w tych 1899 wszystkich pierwszych a za to ma połowę parzystych :D

      To się powinno nazwyać Benchmark po prostu, bo sitem Eratosthenes na pewno nie jest.

      W wolnej chwili przepiszę w tych językach co się bawiłem na poprawny algorytm.

      Zadziwia, że w prasie i dołączonych demkach do niektórych języków programowania właśnie ten poniżej był wrzucany...

      // Fake Eratosthenes Sieve Benchmark

      uses crt, sysutils;

      {$define FAST}

      const
      size = 8191;
      iter_max = 1;

      var
      flags: array [0..size] of boolean;

      iter: byte;
      starttime: cardinal;

      {$ifdef FAST}
      i: word absolute $e0;
      k: word absolute $e2;
      prime: word absolute $e4;
      count: word absolute $e6;
      {$else}
      i, k, prime, count: word;
      {$endif}

      begin

      writeln(iter_max,' iterations');

      starttime := GetTickCount;
      fillchar(flags, sizeof(flags), true);

      i:=0; count := 0;

      while i <= size do begin

      if flags[i] then begin

      prime := i shl 1 + 3;
      k := prime + i;

      while (k <= size) do begin
      flags[k] := false;
      inc(k, prime);
      end;
      inc(count);
      end;

      inc(i);
      end;

      writeln(count, ' primes');
      writeln(GetTickCount - starttime, ' ticks');

      count := 0;
      for i := 3 to size do begin
      if flags[i] then begin
      if (i mod 2) = 0 then begin write(i,' '); inc(count) end;
      end;
      end;
      writeln('');
      writeln(count, ' even numbers count');

      repeat until keypressed;

      end.

      Tak z pamięci do których języków miałem SIEVE gotowe i to był ten Fake:

      1. FastBasic (dyskietka)
      2. Advan Basic (dyskietka)
      3. Action! (z atariwiki)
      4. PL65 (z manuala)
      5. FORTH (z atariwiki)
      6. MADS (ze źródłami)
      7. Mad Pascal (ze źródłami)
      8. Lightspeed C (dyskietka)

      Także dość powszechny jest ten zły algorytm :]
      • 40: CommentAuthortebe
      • CommentTime26 Feb 2020 11:02
       
      liczy się algorytm, skoro był ten sam to liczył to samo

      jedynie nie zgadza się nazwa algorytmu :)
      • 41: CommentAuthorzbyti
      • CommentTime26 Feb 2020 11:02 zmieniony
       
      @tebe ale to mamy takie kuriozum jak na okładce manuala do Lightspeed C :D

      Załączony przez nich na dyskietce benchmark SIEVE to ten nasz fejk, ale porównują go do wyniku BASIC'a który u nich wyrabia się w 31 min co oznacza, że ten algo do BASIC'a musieli już mieć poprawny. Przez co wyszło, że ich język nie jest aż tak szybki w porównaniu do BASIC'a jak w istocie jest ;)

      Ale nie kompilowałem nic pod Lithspeed C więc czy swój wynik podali poprawnie to też nie wiem. Ale na oko wygląda, że tak. Skoro sami napisali, ze są około 10x wolniejsi od Action!.

      Wygląda na to, że ktoś celowo lub nie skopał w zamierzchłych czasach tego SIEVE a wiele osób skopiowało tą niepoprawną implementację nie wnikając w uzyskany wynik :]

      Taka moja teoria.

      No chyba, że na jakiejś konfie w 1978 uznano skopanego SIEVE za standard do testowania wydajności z pełną świadomością jego wady :]
      • 42: CommentAuthorzbyti
      • CommentTime26 Feb 2020 12:02 zmieniony
       
      No to wprowadzam podział na FAKE i REAL
      • 43: CommentAuthortebe
      • CommentTime26 Feb 2020 12:02
       
      odkryłeś trupa w szafie ;)
      • 44:
         
        CommentAuthormav
      • CommentTime26 Feb 2020 12:02
       
      Podoba i jednocześnie niepokoi mnie stan zaangażowanego zbytiego ;)
      • 45: CommentAuthorzbyti
      • CommentTime26 Feb 2020 13:02
       
      @mav to jest nas dwóch :D
      • 46: CommentAuthortebe
      • CommentTime26 Feb 2020 14:02
       
      nie ma oficjalnie wydanej wersji MP 1.6.4, jest tylko 1.6.3

      wersja 1.6.4 nie uzyskuje wyniku 644 dla Fake Sieve
      • 47: CommentAuthorzbyti
      • CommentTime26 Feb 2020 14:02 zmieniony
       
      @tebe u mnie na atari800 Ubuntu osiąga 644 i jest to wynik powtarzalny po wystartowaniu emulatora.

      Mad Pascal Compiler version 1.6.4 [2020/02/02] for 6502

      Od dłuższego czasu mam tę wersję, nie wiedziałem, że jeszcze nie jest publiczna.

      Jak dodam pause to 649. Ale praktycznie nigdzie tego nie robię. Tylko w MadP Chessboard wołam pause jeszcze. Oszacowanie mnie interesuje, przy 10 iteracjach te 5 ramek nie zmienia wyniku w tabeli.

      Proszę podaj poprawne wyniki dla właściwej wersji to zmienię.
      • 48: CommentAuthortebe
      • CommentTime26 Feb 2020 15:02
       
      przedtem w tabelce był po prostu 'Mad Pascal', teraz pojawiła się wersja, bezpieczniej bez wersji
      • 49: CommentAuthorzbyti
      • CommentTime26 Feb 2020 15:02 zmieniony
       
      @tebe to już sam nie wiem, @ilmenit chyba chciałby z wersją.

      Ja chętnie wersję usunę bo mniej pisania ;)

      Podanie wersji pozwoli śledzić progress lub regres kompilatora.

      ----------------------------------------------

      Action! Real Sieve, jedna iteracja.

      BYTE ch=764      ; ESC = 28
      BYTE RTCLOCK2=20 ; sys timer
      BYTE RTCLOCK1=19
      BYTE ARRAY FLAGS(8191)

      PROC sieve()
      BYTE SQRCOUNT=[91]
      CARD N,K

      FOR N=0 TO 8191
      DO
      FLAGS(N)='T
      OD

      FOR N=2 TO SQRCOUNT
      DO
      IF FLAGS(N)='T THEN
      K=N*2
      WHILE K<=8191
      DO
      FLAGS(K)='F
      K==+N
      OD
      FI
      OD
      RETURN

      PROC main()
      CARD STOP,N
      CARD COUNT=[0]

      RTCLOCK1=0
      RTCLOCK2=0
      sieve()
      STOP=RTCLOCK1 * 256 + RTCLOCK2
      PRINTF("%E %U JIFFIES",STOP)

      FOR N=2 TO 8191
      DO
      IF FLAGS(N)='T THEN COUNT==+1 FI
      OD
      PRINTF("%E %U PRIMES",COUNT)

      WHILE ch=255 DO OD
      RETURN
      • 50: CommentAuthorzbyti
      • CommentTime26 Feb 2020 16:02 zmieniony
       
      Na AtariAge twórca FastBasic'a skomentował moje/nasze testy ->link<- :]

      Czyżby też się nie orientował, że SIEVE jakie dołącza do programu jest wadliwe?