z=1
bis=100000000
counter=0

Type MyType
   Field prim
   
   Function Create:MyType(zzz)
      Local e:MyType=New MyType
      e.prim=zzz
      Return e
   End Function
End Type

Local PrimList:TList=New TList
PrimList.AddLast(MyType.Create(2))

memvar=GCMemAlloced()
time=MilliSecs()

For t=0 To bis
   
   zz=Sqr(z)
      
   For a:MyType=EachIn PrimList
      If (z Mod a.prim)=0
         PrimList.RemoveLast()
         Exit
      ElseIf a.prim>=zz
         counter=counter+1
         Print z 'An der Stelle ist z=PRIM
         Exit
      EndIf
   Next
   
   z=z+1
   PrimList.AddLast(MyType.Create(z))
   
Next

Print "Von 1 bis "+bis
Print "Menge der Primzahlen: "+counter
Print "Zeit : "+(MilliSecs()-time)/1000.0+" sek"
Print "Mem.Anfang: "+memvar+" bytes"
Print "Mem.Ende: "+GCMemAlloced()+" bytes"

While Not KeyHit(KEY_ESCAPE)
Wend

End

z=1
bis=100 ' bis=Bis zur welcher Zahl sollen Primzahlen berechnet werden
bis=bis/2 ' Wegen z=z+2

Type MyType
   Field prim
   
   Function Create:MyType(zzz)
      Local e:MyType=New MyType
      e.prim=zzz
      Return e
   End Function
End Type

Local PrimList:TList=New TList
PrimList.AddLast(MyType.Create(3)) ' Ist der Anfangswert der Liste

memvar=GCMemAlloced()
time=MilliSecs()

For t=0 To bis
   
   zz=Sqr(z)
      
   For a:MyType=EachIn PrimList
      If (z Mod a.prim)=0
         PrimList.RemoveLast()
         Exit
      ElseIf a.prim>=zz
         Print z 'An der Stelle ist z=PRIM
         Exit
      EndIf
   Next
   
   z=z+2
   PrimList.AddLast(MyType.Create(z))
   
Next

Print "Von 1 bis "+bis*2
Print "Menge der Primzahlen: "+(PrimList.Count()+1)
Print "Zeit : "+(MilliSecs()-time)/1000.0+" sek"
Print "Mem.Anfang: "+memvar+" bytes"
Print "Mem.Ende: "+GCMemAlloced()+" bytes"

While Not KeyHit(KEY_ESCAPE)
Wend

End

Const Anzahl = 100000000

Function Prim:Byte[](Zahl:Int = 10000,Ausgabe:Byte = True )
   Local PrimZahlen:Byte[Zahl]
   Local I:Int
   
   For I = 2 To Zahl
      PrimZahlen[I] = False
   Next
   
   Primzahlen[0] = True
   Primzahlen[1] = True
   
   I = 2
   
   While I*I <= Zahl
      If Primzahlen[I] = False Then
         Local J = (I*I)
         While J <=  Zahl
            Primzahlen[j] = True
            J:+i
         Wend
      EndIf
      I:+1
   Wend
   
   If Ausgabe = True Then
      For I = 0 To Zahl
         If Primzahlen[I] = False Then Print I
      Next
   EndIf
   
   Return Primzahlen
End Function


Local T:Int = MilliSecs()
   Prim(Anzahl,False)

Local TT:Int = MilliSecs()

Delay 2000

Local T2:Int = MilliSecs()

   'Prim(Anzahl) 'Auskommentiert da bei 100.000.000 etwas lange ;)
   
Local TT2:Int = MilliSecs()

Print "Range             : " + Anzahl
Print "Zeit ohne Ausgabe : " + (TT-T)
Print "Zeit mit Ausgabe  : " + (TT2-T2)

limit = 100000000
hFactor = Int(Sqr(limit))-1
Local isprim:Byte[limit]
n:Int=0

time=MilliSecs()

For i=5 To limit
   isprim[i]=False
Next

For i=1 To hFactor

   For j=1 To hFactor
      
      n=4*i*i+j*j
      If (n<=limit And ((n Mod 12=1) Or (n Mod 12=5)))
         isprim[n]=Not isprim[n]
      EndIf
               
      n=3*i*i+j*j
      If (n<=limit And (n Mod 12=7))
         isprim[n]=Not isprim[n]
      EndIf
         
      n=3*i*i-j*j
      If (n<=limit And (i>j) And (n Mod 12=11))
         isprim[n]=Not isprim[n]
      EndIf
      
   Next
   
Next

For i=5 To hFactor
   If isprim[i]=True
      j=i*i
      While j<limit
         isprim[j]=False
         j=j+i*i
      Wend
   EndIf
Next

time=MilliSecs()-time

isprim[1]=True
isprim[2]=True
isprim[3]=True

Rem
For i=1 To limit
   If isprim[i]=True Print i
Next
EndRem

Print "Zeit: "+time+" ms"

While Not KeyHit(KEY_ESCAPE)
Wend

limit=100000000

mem=GCMemAlloced()
Local test:Byte[limit]
mem=GCMemAlloced()-mem

Print "bytemem:"+mem

time=MilliSecs()
For i=0 To limit
   test[i]=False
Next
time=MilliSecs()-time

Print "bytespeed:"+time

Delay 5000

mem1=GCMemAlloced()
Local test1:Int[limit]
mem1=GCMemAlloced()-mem1

Print "intmem:"+mem1

time1=MilliSecs()
For i=0 To limit
   test1[i]=False
Next
time1=MilliSecs()-time1

Print "intspeed:"+time1