Det är väl svårt att generellt kan säga hur mycket snabbare C/C++ är än VB. Men jag håller på med ett program där den längsta uträkningen tar ca 2min(kass dator). Det är mest loopar som kollar igenom olika arrayer(endast en dimension) och jämför och plockar ut vissa värden och stoppar i andra arrayer och även ordnar om lite i ordningsföljden i vissa (programmet är inte minneskrävande). Så jag undrar hur lång tid det tar om det skulle vara skrivet med liknande kod i C/C++. Är det vissa operationer man ska undvika i VB?

Du kan ju publicera koden här så kan vi komma med förslag.

Det jag fundera mest på var hur stor skillnad det var mellan VB och C/C++. Alltså om det tar 2 min med en kod i VB. Tjänar man en sekund eller många sekunder(har försökt förklara ungefär vad den ska utför ovan men det kanske ändå svårt att uppskatta?). Jag vet att man tjänar mest på att skriva en bättre kod men om man har skrivit en optimal kod vad är skillnaden mellan VB och C/C++. Jag kan publicera koden men den är ganska lång och jag har inte skrivit några förklaringar för den är långtifrån klar och färdig optimerad. Men om det är till hjälp så kan jag lägga in den.

hej
Mina vänner , jag säger bara "Stand Alone" Delphi och C
Sven

> Det jag fundera mest på var hur stor skillnad det
> var mellan VB och C/C++.

Den är stor. VB är gjort för att man enkelt ska kunna rita upp windowsfönster och koppla ihop sakerna däri med lite kod. Det är inte på något sätt konstruerat för att vara snabbt. Tvärtom. Enkelheten gör att det blir slött.


> Alltså om det tar 2 min med en kod i VB.
> Tjänar man en sekund eller många sekunder

Den beskrivning du har gett tyder ju på att det inte är nåt komplicerat det rör sig om, så det kanske skulle ta 10-15 sekunder med ett C-program. Eller inte ens det. 10-15 sekunder är ju rätt lång tid. Men din beskrivning säger ju inte mycket, så det går egentligen inte att uttala sig om.

Om du kunde beskriva vad programmet gör (i detalj alltså) så kan jag nog lätt slänga ihop lite C-kod åt dig så får du testa.

Ursäkta har varit på resande fot. Här kommer koden. Jag håller på med ett stryktipsprogram och ska fixa ihop en kod som reducerar minimigaranti och U-rad. Har gjort den här koden utanför själva programmet och om jag får den att funka bra ska jag lägga in den i riktiga programmet så jag har inte varit så noga med allting. Koden hanterar bara 12 rättsgaranti, helgarderingar och funkar bäst om max-min är samma. Men den funkar ändå relativt bra så det är något att bygga vidare på. Man för alltså in antal helgarderingar som har U-rad(text1) och sätter in Max(text2) och Min(text3) antal rätt för U-raden och får ut vilka rader man ska använda. Just nu får man en msgbox som säger antal rader. Jag jämför resultat antal rader och även snabbheten mot ett program som är gjort i C++ (bäst på just den sortens reduceringar). Så det skulle vara kul att veta hur mycket jag skulle vinna på att byta till C/C++ ungefär? Har proggat lite C/C++ men inget grafiskt så jag funderade att skriva ett program i C som bara gör uträkningen om jag vinner en del på det. Föresten går det att skicka arrayer mellan ett program i C och ett program i VB? Det är tre textboxar(text1,text2,text3) och en knapp(command1) som jag använt. Koden blir olidligt seg om man tar t.ex. 9 helg. och max min 5-2 så där hjälper det inte byta språk. Har funderat på att ha några startrader som jag vet funkar så den inte behöver räkna allt. Så det kanske blir så jag får lösa det med en massa if satser även om jag inte vill. Som sagt ni ville ha koden så jag hoppas ni är bra på att läsa kod för det är inte värst mycket förklaringar ;)

<code>

Private Function SkapaOlikaRader(RadLangd As Byte, AntalTecken As Byte, MaxAntalRatt As Byte, MinAntalRatt As Byte) As String()
Dim x#, y#, dblAntalRader#, strStrang$, intAntalKryss%
Dim intRad(13) As Integer
ReDim Olikarader(AntalTecken ^ RadLangd) As String
dblAntalRader = 1
For x = 1 To (AntalTecken ^ RadLangd)
strStrang = ""
intAntalEttor = 0
For y = RadLangd To 1 Step -1
If intRad(y) = 2 Then
intRad(y) = 0
intRad(y - 1) = intRad(y - 1) + 1
End If
If intRad(y) = 1 Then intAntalEttor = intAntalEttor + 1
strStrang = intRad(y) & strStrang
Next
If intAntalEttor <= MaxAntalRatt And intAntalEttor >= MinAntalRatt Then
Olikarader(dblAntalRader) = strStrang
dblAntalRader = dblAntalRader + 1
End If
intRad(RadLangd) = intRad(RadLangd) + 1
Next
Olikarader(0) = dblAntalRader - 1
ReDim Preserve Olikarader(dblAntalRader - 1)
SkapaOlikaRader = Olikarader
End Function

Private Sub Command1_Click()
Dim Olikarader() As String
Dim Olikarader2() As String
Dim intTmpRader(500) As Integer, intRaderAttTabort() As Integer, strutvaldarader(100, 2) As String
Dim intUtvaldRad%, intAntalRattTecken%, intAntalRattRader%, intMaxAntalRattRader%, intPosition%
Dim x, y%, z%, q%, t%, u%, strTmpStr$, intAntalUtvaldaRader%, intForvaldaRader%
Dim intAntalRaderIverkligheten As Integer, IntAntalT%

Olikarader = SkapaOlikaRader(Int(Text1), 2, (Int(Text2) + 1), (Int(Text3) + 1))
Olikarader2 = SkapaOlikaRader(Int(Text1), 2, Int(Text2), Int(Text3))
intPosition = Olikarader2(0)
intForvaldaRader = 0

Do While intPosition > 0
intMaxAntalRattRader = 0
For x = Int(Olikarader(0)) To 1 Step -1
If Olikarader(x) <> "" Then
intAntalRattRader = 0
For y = intPosition To 1 Step -1
strTmpStr = Olikarader2(y)
intAntalRattTecken = 0
For z = 1 To Len(Olikarader(x))
If Mid(Olikarader(x), z, 1) = Mid(strTmpStr, z, 1) Then intAntalRattTecken = intAntalRattTecken + 1
Next z
If intAntalRattTecken >= (Int(Text1) - 1) Then
intAntalRattRader = intAntalRattRader + 1
intTmpRader(intAntalRattRader) = y
End If
Next y
For u = 1 To Len(Olikarader(x))
If Mid(Olikarader(x), u, 1) = "0" Then t = t + 1
Next
If (intAntalRattRader * 2 ^ (IntAntalT - t)) > intMaxAntalRattRader Then
IntAntalT = t
intUtvaldRad = x
intMaxAntalRattRader = intAntalRattRader
intRaderAttTabort = intTmpRader
Erase intTmpRader
End If
End If
t = 0

Next x
For q = 1 To intMaxAntalRattRader
strTmpStr = Olikarader2(intRaderAttTabort(q))
Olikarader2(intRaderAttTabort(q)) = Olikarader2(intPosition)
Olikarader2(intPosition) = strTmpStr
intPosition = intPosition - 1
Next
intAntalUtvaldaRader = intAntalUtvaldaRader + 1
strutvaldarader(intAntalUtvaldaRader, 0) = Olikarader(intUtvaldRad)
strutvaldarader(intAntalUtvaldaRader, 1) = intMaxAntalRattRader
For u = 1 To Len(Olikarader(intUtvaldRad)) ' Kollar hur många nollor beror på hur många rader det blir
If Mid(Olikarader(intUtvaldRad), u, 1) = "0" Then t = t + 1
Next
Olikarader(intUtvaldRad) = ""
If t = 0 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 1
If t = 1 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 1
If t = 2 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 2
If t = 3 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 4
If t = 4 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 8
If t = 5 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 16
If t = 6 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 32
If t = 7 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 64
If t = 8 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 128
If t = 9 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 256
If t = 10 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 512
If t = 1 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 2
If t = 2 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 4
If t = 3 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 8
If t = 4 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 16
If t = 5 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 32
If t = 6 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 64
If t = 7 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 128
If t = 8 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 256
If t = 9 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 512
If t = 10 And intMaxAntalRattRader <> 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 1024
t = 0
Loop
'Call printprint(olikarader2, strutvaldarader)
strTmpStr = "AntalBlock = " & intAntalUtvaldaRader & " AntalRader = " & intAntalRaderIverkligheten
MsgBox strTmpStr
intAntalRaderIverkligheten = 0
End Sub

</code>

Men som sagt vill jag bara ha en uppskattning hur mycket ett program med ett antal loopar och med några jämförelser och lite andra vanliga operationer som tar ca 2min på VB hur lång tid det tar om man använder samma sorts loopar och operationer i C. Ni får gärna kommentera något i koden om det ser skumt ut.

Hej
Den här typen av rad är inte speciellt bra
>If t = 2 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 2

Om t inte är två så det onödigt att kolla AND.
Du bör använd Select Case t och sedan IF.

I C löser det sig själv vid kompilering om IF är falskt så
kollas inte AND satsen.

mvh
Sven

Om du byter ut:

<code>
For var=1 to Max
...gör nåt...
Next
</code>

mot...

<code>
var=0
Do
var=var+1
...gör nåt...
Loop until var>=Max
</code>

...så går det i a f lite snabbare.

/ChristerGbg

Sven det har du rätt i ska tänka på det i andra sammanhang för dom raderna ska inte finnas när jag lägger in det i det riktiga programmet.
Christer varför är den snabbare? Någon enkel förklaring eller det bara är så?

Faktum är att christers inte är snabbare på något vis.
Skillnaden är minimal.

Det största problemet med koden är att du antagligen använder mycket ineffektiva metoder, ex.

If Mid(Olikarader(x), z, 1) = Mid(strTmpStr, z, 1) Then intAntalRattTecken = intAntalRattTecken + 1

är mycket otrevlig. Om inte annat - byt ut alla Mid mot Mid$ och liknande. Bör snabba upp avsevärt.

I C (C++ har inte mycket att ge i frågan) så kan du mycket väl få en bra mycket snabbare kod, eftersom jämförelserna är helt galna...

Dessutom tjänar du nog en del på att byta ut

If t = 1 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 1
If t = 2 And intMaxAntalRattRader = 1 Then intAntalRaderIverkligheten = intAntalRaderIverkligheten + 2

osv.

mot
If intMaxAntalRattRader = 1 Then
intAntalRaderIverkligheten = intAntalRaderIverkligheten + 2^t
End If


(Eventuellt med modifikationer, jag har inte kollat din kod så där jättenoga)
Om 2^t är för långsam kan du alltid använda en array som du gör innan:

Dim Potenser(0 To 10) As Long, i as long
For i=0 to 10
Potenser(i)=2^i
Next


...
intAntalRaderIverkligheten = intAntalRaderIverkligheten + Potenser(t)



/Niklas Jansson

Hej
En liten kommentar
>2^t
Är inget bra i Vb , vet ej hur det är i C

Om du behöver skriva 2^3 är det mycket bättre att skriva 2*2*2

mvh
Sven

Hej! Jag tittade lite på din kod. Eftersom jag inte kan nåt om stryktipssystem och då koden saknar kommentarer, har jag lite problem med att begripa vad det går ut på, men VB kan jag i.a.f. hyffsat. Detta är inte en fråga om VB vs VC++. Skriver du samma kod på **ungefär samma sätt** i VC++ kommer det vara ungefär lika segt. Kanske mågot snabbare. Så *problemet* ligger inte där.
Problemet är att du utför processorkrävande operationer (dimensionera nya Strings - alltså dimensionera nya minnesutrymmen) tiotusentals gånger (minst). Alltså ungefär som att du skulle skapa tiotusentals CString-objects i VC++.. (men ingen C++ programmerare i världen skulle väl ha löst problemet så ;)

Kom ihåg att när du anropar Mid() så "tittar" inte VB i din sträng på position N som man kanske hade hoppats... utan i stället dimensioneras internt en NY String som Mid() returnerar och sedan görs jämförelsen...
Dessutom returnerar Mid() inte en sträng utan en lite större datatyp: Variant..
Mid$() returnerar en String, men i ditt fall hjälper det kanske inte så mycket..
Kom ihåg 2: en tom String= 4 bytes i VB. Varje tecken + 2 bytes.
Antagligen skulle C-programmet bli så mycket snabbare eftersom där hade man jobbat med betydligt snabbare char[]-arrayer i stället där du kan "titta" in i strängen: myCharArray[5]=="0" t.ex..
Att bygga upp strängar kostar mycket i VB!
Jag rekommenderar denna artikel av F. Balena:
http://www.vb2themax.com/HtmlDoc.asp?Table=Articles&ID=30

Så använd bara strängar där du måste. Jag tror inte att du måste använda strängar i det här programmet alls...

Vad jag kunde se i koden skapas en stor matris med ettor och nollor..och du behöver 13 fack?
Detta kan du ju behandal som tal.. eftersom du egentligen bygger strängar som innehåller binära tal... ??

0001 = 1
0010 = 2
0011 = 3
0100 = 4
1 1111 1111 1111 = 8191
(13 st fack - alltså alla kombinationer finns i serien 0-8191)

Försök lösa det lite mer "lågnivå" så kommer det bli supersnabbt.
Detta är mycket viktigare än att flytta koden till C.

.Ola

En tanke till jag fick: Allt sammans kanske kan lösas men en fet ekvation? Forska lite i det... Jag är inget mattesnille så jag vet inte hur man skulle kunna göra.... Men det känns som att det finns en matematisk lösning på det som ditt program gör.. Om det går så blir programmet väldigt snabbt. Mitt tidigare förslag att du ska tänka i binära tal är ju iofs en slags matematisk lösning..
.Ola

En annan lösningsteknik skulle sannolikt underlätta samt snabba upp litegranna:

Istället för att jobba med en u-rad så borde du jobba med en r-rad, räkna ut en minimi-garanti för 10 rätt reducerat, då räcker det med 2 u-rätt (alla ettor i r-raden representeras av u-tecken) för att få en tolva...

Hur räknar man ut en r-rad då? Utgå från en befintlig r-rad (r 4-0-9 använder jag, den garanterar 12 rätt) och använd den som en fördefinierad rad, för att sedan beräkna större rader kombinerar du den med sig själv och reducerar bort från det resultat.

Tack framförallt till Ola och Nicklas som nämnde mitt huvudproblem. Jag kan inte C så bra så jag skulle säkert inte kunna utnyttja C:s alla fördelar och som jag nämnde förut så förstår jag att skriva bättre kod är det bästa.
Sven visst använde jag en Variabel tillsammans med ^ så det går kanske inte att göra på det sättet här men det är alltid bra att veta vad man ska undvika.

Trodde det bara fanns Mid men jag kollade upp i MSDN och det fanns Mid$ i indexet men det stod inget i beskrivning så tack för lektionen.

Ska testa om jag kan få den där binära lösningen att funka.


Ola ja nog har jag funderat lite på någon bättre lösning. Nog har jag läst en hel del matte i mina dar men jag har väl glömt det mesta. Så om det finns något snille som fixar en lösning så tackar jag och tar emot.
Kanske Trash?? Jag fattade inte direkt men ska kolla på det snart igen.


ps intAntalRaderIverkligheten raderna ska inte finnas med sen

Kollade lite mer på det nu men förstod inte så mycket mera. Det låter för enkelt för att lösa allt det jag tänkte tror jag?? Berätta gärna mer om något exempel.

Ett exempel som jag vill att mitt program ska lösa.
Jag vill ha 9 helgarderingar och 4 spikar och har satt ett utgångstecken för alla 9 garderingarna. Om jag får in min 6 och max 8 rätt av utgångstecknena vill jag vara garanterad minst 12 rätt.
(75 rader i det program jag använder ovan)

Och när det är klart ska det funka med alla möjligheter av min,max och antal hel,halv garderingar och även minimigaranti för 10,11,12 rätt

Hej
>1 1111 1111 1111 = 8191
(13 st fack - alltså alla kombinationer finns i serien 0-8191)

Den lösningen är förbaskat intressant,skall lägga lite
tankemöda på dit problem som en utmaning.

mvh
Sven

Testade byta mid till mid$ och det blev en hyfsad skillnad. Körde en uträkning som tog 55sek den tog 48sek efter förändringen.


Håller på att testa med den binära lösningen och testade Eqv och fick skumma resultat. Eller samma som MSDN får ;-)


10 Eqv 8 = -3 känns inte helt ok för mig. Kan någon förklara?

Jag vill hellre ha 10 Eqv 8 = 13 alltså 8+4+1 eller är jag helt ute och cyklar?

Hej
>Körde en uträkning som tog 55sek den tog 48sek

Bra, det skall bli kul att pressa den tiden.

DS

Sven det låter bra.

Någon som kan ta ut ettorna ur ett binärt tal

0110101=86
Alltså det är 4 ettor i det binära talet 86. Hur får man ut det på ett enkelt och snabbt sätt?
86=4

ett till exempel
10110=13
13=3

Jag kommer inte på ngt bättre sätt än det här:
<code>
'Cacha upp bit-positioner gör detta i början av ditt program!
Dim bin(12) As Long
For i = 0 To 12
bin(i) = 2 ^ i
Next i

'Ditt värde
x = 86

'Räkna antal binära ettor
Dim antalettor As Long
For i = 0 To 12
'En etta?
If (x And bin(i)) Then antalettor = antalettor + 1
'Har vi hittat alla möjliga ettor?
If bin(i) > x Then Exit For
Next i

</code>

Hej
>0110101=86
ett till exempel
10110=13

Liten korrigering 1 0 1 0 1 1 0 = 86
1 1 0 1 = 13
Man läser alltid från höger till vänster,det blir ju samma
resultat beträffand 4 och 3 men rätt skall vara rätt.

Något att bygga vidare på

Private Function BitConv(ByVal inByte As Byte) As String
'Med tack till Nettan på http://www.pellesoft.nu
Dim i As Long, lngTemp As Long, StrTemp As String
lngTemp = 128
For i = 8 To 1 Step -1
If inByte Mod lngTemp = inByte Then
StrTemp = StrTemp & "0"
Else
StrTemp = StrTemp & "1"
inByte = inByte - lngTemp
End If
lngTemp = lngTemp \ 2
Next 'i
MsgBox StrTemp
BitConv = StrTemp
End Function

Nu är det bara att räkna ettor i StrTemp
Mvh
Sven

Hej på er igen!
Om ni nu ska envisas med å bygga miljarders strängar gör det åtminstone lite mer optimalt :) Här kommer ett enkelt exempel på det!

Den långsamma koden i Command1 tar 4,2 sek att exekvera på min PC, den snabba koden i Command2 klarar samma uppgift på 0,012 sek (jag har en hyffsat snabb P4@2.2Ghz därav mängden iterationer :)
Alltså: 350 gånger snabbare!!! :) ja, detta är ett extremt korkat exempel - men bara för att visa skillnaden...

skapa ett nytt proj med en Command1 och en Command2 och klistra in denna kod:

<code>

Private Sub Command1_Click()

Dim i As Long
Dim oTmr As CStopWatch
Dim sTemp As String

Set oTmr = New CStopWatch
For i = 1 To 100000
'skapar nya strängar 100.000 ggr:
sTemp = sTemp & "A"
Next i

Me.Caption = "Tid: " & Round(oTmr.Elapsed / 1000, 4) & " sek"

End Sub

Private Sub Command2_Click()

Dim i As Long
Dim oTmr As CStopWatch
Dim sTemp As String

Set oTmr = New CStopWatch
sTemp = Space(100000)

For i = 1 To 100000
Mid(sTemp, i, 1) = "A"
'knuffar in ett A på varje position i den redan dimensionerade stora strängen.
Next i

Me.Caption = "Tid: " & Round(oTmr.Elapsed / 1000, 4) & " sek"

End Sub

</code>
'---------------------------

För att detta ska fungera behövs klassmodulen CStopWatch.
Jättebra att ha för att mäta tid i ms som det tar att exekvera kod:
Oblygt snott från Karl E. Peterson, Microsoft Developer MVP
http://www.mvps.org/vb/index2.html?samples.htm

Här kommer den:
<code>
Option Explicit
'
' Win32 API declarations.
'
Private Declare Function timeGetTime Lib "winmm.dll" () As Long
Private Declare Function timeGetDevCaps Lib "winmm.dll" (lpTimeCaps As TIMECAPS, ByVal uSize As Long) As Long
'
' API Structure definitions.
'
Private Type TIMECAPS
wPeriodMin As Long
wPeriodMax As Long
End Type
'
' Set aside storage for private member variables.
'
Private m_StartTime As Long
Private m_PeriodMin As Long
Private m_PeriodMax As Long

' ********************************************
' Initialize
' ********************************************
Private Sub Class_Initialize()
'
' Retrieve system timer resolution.
'
Dim tc As TIMECAPS
Call timeGetDevCaps(tc, Len(tc))
m_PeriodMin = tc.wPeriodMin
m_PeriodMax = tc.wPeriodMax
'
' Initialize starting time.
'
m_StartTime = timeGetTime()
End Sub

' ********************************************
' Public Properties
' ********************************************
Public Property Get Elapsed() As Long
'
' Read-Only: return elapsed time in milliseconds
' since stopwatch was reset.
'
Elapsed = timeGetTime() - m_StartTime
End Property

Public Property Get MinimumResolution() As Long
'
' Read-Only: return minimum number of milliseconds
' timer is capable of resolving.
'
MinimumResolution = m_PeriodMin
End Property

Public Property Get MaximumResolution() As Long
'
' Read-Only: return maximum number of milliseconds
' timer is capable of resolving.
'
MaximumResolution = m_PeriodMax
End Property

' ********************************************
' Public Methods
' ********************************************
Public Sub Reset()
'
' Reinitialize starting time.
'
m_StartTime = timeGetTime()
End Sub

</code>



(jag tycker fortfarande att man inte ska lösa programmet med att byga strängar.. ska fundera lite.. om jag orkar.. :)

Hej
Som vanligt "Mycket skrik, lite ull" sa käringen när hon klippte grisen.

Varför i hela fridens namn skall man skriva en StopWatch Class
för att mäta såna här enkla tidsförhållande.
API GetTickCount och Vb:s Timer function duger alldeles utmärkt.

Det där med SubClasser har tydligen blivit en modefluga som
skall användas i alla möjliga och omöjliga sammanhang.

Sedan bevisade resten inte något som har med Hermans prob att göra.

Som vanligt, många tror att ju fler programrader man skriver
ju mer "imponanspoäng" får man. Trasch har rett det där med Mid$

mvh
Sven

Äh, nu är du fånig Sven.. Det jag klistrade in om CStopWatch är inte nån kod jag skrivit själv ens - vilket framgick av mitt inlägg.
Vb's Timer är ingen höjdare det vet du väl? Multimediatimer är däremot det bästa sättet, därför tänkte jag det kunde vara ett bra tips!?!
Visst man kan använda GetTickCount men jag tycker denna var bättre - och enklare att använda när man har det inkapslat i en klass.
Att använda den är ju mycket enkelt och kräver bara ett par rader kod för varje gång.... Lägg till den i era projekt och ni har alltid en pålitlig multimedia-timer att mäta med.. (upplösning på 1 ms).

ps. du kanske mest skriver inlägg för att "imponera" eftersom du har det angrepssätet när du "angriper" mig, men jag skriver faktiskt inlägg för att hjälpa och tipsa andra programmerare... gillar du inte tipsen behöver du inte svara eller bry dig... tack!
ds.
.Ola

Hej
>Vb's Timer är ingen höjdare det vet du väl?

Jag menade inte Kontrollen Timer utan Function Timer

Denna pekpinne retade mig
>Om ni nu ska envisas med å bygga miljarders strängar gör det åtminstone lite mer optimalt :)

Tycker fortfarande som jag skrev 0 :-)
mvh
Sven

Så du tycker inte det är intressant att få 350ggr snabbare stränghantering? ;) Ja ja, jag ska lägga undan pekpinnen, jag menade inte så utan som bra tips bara! :)

Hej igen!
Har haft en del att göra men måste ju tacka för alla hjälp och visa att det har blivit förbättringar. Jag har nu skrivit ihop en binär lösning på problemet och det blev en hel del snabbare. En uträkning som tog 55 sek med koden ovan tar 2-3 sek med den nya.
Har även skrivit lite kommentarer vet inte om det hjälper er ;). Brukar vara väldigt dålig på den biten. Och som vanligt tar jag inte illa upp om ni kommenterar skum kod.

/DH

<code>

Option Explicit
Private Const BitMask_0 = &H1
Private Const BitMask_1 = &H2
Private Const BitMask_2 = &H4
Private Const BitMask_3 = &H8
Private Const BitMask_4 = &H10
Private Const BitMask_5 = &H20
Private Const BitMask_6 = &H40
Private Const BitMask_7 = &H80
Private Const BitMask_8 = &H100
Private Const BitMask_9 = &H200
Private Const BitMask_10 = &H400
Private Const BitMask_11 = &H800
Private Const BitMask_12 = &H1000
Private Const BitMask_13 = &H2000

Private Function SkapaOlikaRader(RadLangd As Integer, AntalTecken As Integer, MaxAntalRatt As Integer, MinAntalRatt As Integer) As Integer()
Dim x#, y#, dblAntalRader#, strStrang$, intAntalEttor%
ReDim Olikarader(AntalTecken ^ RadLangd) As Integer
dblAntalRader = 1
'Loopar igenom alla möjliga rader
For x = 1 To (AntalTecken ^ RadLangd)

'Räknar ut hur många ettor det är i raden
intAntalEttor = Abs(((x And BitMask_0) > 0) + ((x And BitMask_1) > 0) + ((x And BitMask_2) > 0) + ((x And BitMask_3) > 0) + ((x And BitMask_4) > 0) + ((x And BitMask_5) > 0) + ((x And BitMask_6) > 0) + ((x And BitMask_7) > 0) + ((x And BitMask_8) > 0) + ((x And BitMask_9) > 0) + ((x And BitMask_10) > 0) + ((x And BitMask_11) > 0) + ((x And BitMask_12) > 0) + ((x And BitMask_13) > 0))

'Jämför om det är rätt antal ettor
If intAntalEttor <= MaxAntalRatt And intAntalEttor >= MinAntalRatt Then
Olikarader(dblAntalRader) = x
dblAntalRader = dblAntalRader + 1
End If
Next
Olikarader(0) = dblAntalRader - 1
ReDim Preserve Olikarader(dblAntalRader - 1)
SkapaOlikaRader = Olikarader
End Function

Private Sub Command1_Click()
Dim Olikarader() As Integer
Dim Olikarader2() As Integer
Dim intTmpRader(500) As Integer, intRaderAttTabort() As Integer, strutvaldarader(500, 2) As String
Dim intUtvaldRad%, intAntalRattTecken%, intAntalRattRader%, intMaxAntalRattRader%, intPosition%
Dim x%, y%, z%, q%, t%, u%, strTmpStr$, intTempTal%, intAntalUtvaldaRader%
Dim intAntalRaderIverkligheten As Integer, IntAntalT%
Dim XOR_Tal As Integer
Dim intAntalHelGarderingar%, intMaxAntalRatt%, intMinAntalRatt%

'Detta snabbar upp när jag ska räkna ut antalraderiverkligheten
Dim Potenser(0 To 13) As Long, i As Long
For i = 0 To 13
Potenser(i) = 2 ^ i
Next

intAntalHelGarderingar = CInt(Text1)
intMaxAntalRatt = CInt(Text2)
intMinAntalRatt = CInt(Text3)
'Skapar två arrayer med olika rader. olikarader är dom rader är dom möjliga rader som jag ska använda
'i systemet och olikarader2 är alla möjliga kombinatitioner det kan bli
Olikarader = SkapaOlikaRader(intAntalHelGarderingar, 2, (intMaxAntalRatt + 1), (intMinAntalRatt + 1))
Olikarader2 = SkapaOlikaRader(intAntalHelGarderingar, 2, intMaxAntalRatt, intMinAntalRatt)
'Ställer in hur många rader det ska finnas att matchas mot
intPosition = Olikarader2(0)

Do While intPosition > 0
intMaxAntalRattRader = 0
For x = Int(Olikarader(0)) To 1 Step -1
If Olikarader(x) <> 0 Then
intAntalRattRader = 0
intTempTal = Olikarader(x)

For y = intPosition To 1 Step -1
'intAntalRattTecken är egentligen antal fel tecken :)
XOR_Tal = intTempTal Xor Olikarader2(y)
intAntalRattTecken = Abs(((XOR_Tal And BitMask_0) > 0) + ((XOR_Tal And BitMask_1) > 0) + ((XOR_Tal And BitMask_2) > 0) + ((XOR_Tal And BitMask_3) > 0) + ((XOR_Tal And BitMask_4) > 0) + ((XOR_Tal And BitMask_5) > 0) + ((XOR_Tal And BitMask_6) > 0) + ((XOR_Tal And BitMask_7) > 0) + ((XOR_Tal And BitMask_8) > 0) + ((XOR_Tal And BitMask_9) > 0) + ((XOR_Tal And BitMask_10) > 0) + ((XOR_Tal And BitMask_11) > 0) + ((XOR_Tal And BitMask_12) > 0) + ((XOR_Tal And BitMask_13) > 0))

'Avgör om det är rätt antal tecken. Inställt på 12rätts garanti nu
If intAntalRattTecken <= 1 Then
intAntalRattRader = intAntalRattRader + 1
intTmpRader(intAntalRattRader) = y
End If
Next y

'Räknar hur många nollor som finns i olikarader(x) =intTempTal
t = intAntalHelGarderingar + ((intTempTal And BitMask_0) > 0) + ((intTempTal And BitMask_1) > 0) + ((intTempTal And BitMask_2) > 0) + ((intTempTal And BitMask_3) > 0) + ((intTempTal And BitMask_4) > 0) + ((intTempTal And BitMask_5) > 0) + ((intTempTal And BitMask_6) > 0) + ((intTempTal And BitMask_7) > 0) + ((intTempTal And BitMask_8) > 0) + ((intTempTal And BitMask_9) > 0) + ((intTempTal And BitMask_10) > 0) + ((intTempTal And BitMask_11) > 0) + ((intTempTal And BitMask_12) > 0) + ((intTempTal And BitMask_13) > 0)

'Kollar vilken rad som tar bort flest rader i olikarader2() med minst antal verkliga rader
If (intAntalRattRader * 2 ^ (IntAntalT - t)) > intMaxAntalRattRader Then
IntAntalT = t
intUtvaldRad = x
intMaxAntalRattRader = intAntalRattRader
intRaderAttTabort = intTmpRader
Erase intTmpRader
End If
End If
t = 0

Next x
'Tar bort dom rader som den utvalda raden täcker
For q = 1 To intMaxAntalRattRader
intTempTal = Olikarader2(intRaderAttTabort(q))
Olikarader2(intRaderAttTabort(q)) = Olikarader2(intPosition)
Olikarader2(intPosition) = intTempTal
intPosition = intPosition - 1
Next q
intAntalUtvaldaRader = intAntalUtvaldaRader + 1
strutvaldarader(intAntalUtvaldaRader, 0) = Olikarader(intUtvaldRad)
strutvaldarader(intAntalUtvaldaRader, 1) = intMaxAntalRattRader

u = Olikarader(intUtvaldRad)
t = intAntalHelGarderingar + ((u And BitMask_0) > 0) + ((u And BitMask_1) > 0) + ((u And BitMask_2) > 0) + ((u And BitMask_3) > 0) + ((u And BitMask_4) > 0) + ((u And BitMask_5) > 0) + ((u And BitMask_6) > 0) + ((u And BitMask_7) > 0) + ((u And BitMask_8) > 0) + ((u And BitMask_9) > 0) + ((u And BitMask_10) > 0) + ((u And BitMask_11) > 0) + ((u And BitMask_12) > 0) + ((u And BitMask_13) > 0)

'stryker den utvalda raden så den inte testas igen
Olikarader(intUtvaldRad) = 0
'Beräknar antal rader som det i slutändan kommer att vara
If intMaxAntalRattRader = 0 Then
intAntalRaderIverkligheten = intAntalRaderIverkligheten + 1
ElseIf intMaxAntalRattRader = 1 Then
intAntalRaderIverkligheten = intAntalRaderIverkligheten + Potenser(t - 1)
ElseIf intMaxAntalRattRader <> 1 Then
intAntalRaderIverkligheten = intAntalRaderIverkligheten + Potenser(t)
End If

t = 0
Loop
'Call printprint(olikarader2, strutvaldarader)
strTmpStr = "AntalBlock = " & intAntalUtvaldaRader & " AntalRader = " & intAntalRaderIverkligheten
MsgBox strTmpStr
intAntalRaderIverkligheten = 0
End Sub

</code>

Kanonbra! vilket lyft! :-)
ett par saker:
- Dim'a alla heltal och arrayer av heltal As Long så blir det aningens lite snabbare.
- Anropa functions där inparametrarna är av value-type med ByVal. Det är också lite snabbare. (gör kanske ingen märkbar skillnad just här). På så sätt jobbar funktionen med ett värde och inte med en pekare till ett värde.
Du har fortfarande en array As String. Varför? Gör den As Long också. Den innehåller väl bara tal ändå?
intTempTal är onödig. Gå på arrayen direkt.
Det kanske verkar skitsamma men på tiotusentals loopar så tappar du några bråkdelar för varje loop utan någon anledning... penalty ticks!! ;)

Vad var det jag sa? Du behöver inte porta till C! :)
Grattis!!
På köpet lärde du dig en massa fräcka saker som bitmasking (om du nu inte redan kunde det).
Är man NÖRD eller, när man tycker sånt är "fräckt" ;)

.Ola

Hej
Ja det var verkligen lärorikt.
Bra jobbat den ligger i min godislåda
för framtida bruk. Bitmasking är coolt.

Helt otroligt , din kod kom ner i 2.7 sek för kombinationen 9 5 2
på min slöa 200 mhz.

Sedan ändrade jag alla Integer till Long
alla % till & dvs samma sak som Ola skrev
ändrade också till ByVal i Functionens argument.

En sak du skall tänka på , om du inte redan gjort det.
Vi kompilering skall du för detta exempel använda Fast Code
och Favor Pentium förbockat.
Sedan under Advanced Optimization skall du bocka för alla alternativ.

När jag hade gjort detta gick min exefil på 1.9 sek dvs trimmat
från 2.7 till 1.9 Kanon.

ha det
Sven

Hej igen!

Jag har väl lekt lite med bitmaskning(tex kryptering) men har överhuvudtaget inte programmerat så mycket. Det var kul att se att det är så stor skillnad. Måste tacka igen för att du tipsade om bitlösningen för det är som dag och natt.
Men jag måste erkänna att tid resultaten ovan inte stämde för jag har "splittat" en kass dator och fått två stycken ännu kassare datorer. Så det var ännu större skillnad.

Den där strängen hade jag missat men nu har jag ändrat den och även kört en Redim preserv på den också. Ändrade till ByVal och Long också.
Men "intTempTal" lösningen är snabbare men ytterst marginellt (kollade nu med stopwatchen).

Är det någon gång det är dåligt med all optimization på exe filen?

Kan någon säga varför det är snabbare med Long istället för Integer. Long tar ju mer minne.


sträng lösningen: i vb6= 96 sek som exe= 82 sek
binär lösingen: i vb6= 2,1 sek som exe= 0,25 sek
binär lösning(fixad): i vb6= 2 sek som exe(opt)=0.211(utan inttemptal=0.218)


ps jag tror jag använder en bitmask för mycket (BitMask_13) så den är säkert en del snabbare om jag tar bort den.

Jag kan ju säga att den _garanterat_ hade blivit snabbare i C.

Anledningen till att Long är snabbare än Integer är att Windows numera är ett 32-bitars system, och därmed hanterar long (som är 32 bitar) lättare än Integer som är halva long. Skulle du programera i DOS skulle integer varit snabbare.

/Niklas Jansson

Jag kan ju säga att den _garanterat_ hade blivit snabbare i Assembler


:) Roland, men de' var lite utanför ämnet

Jag kan förklara varför Long är snabbare än int...

Effekten är densamma på moderna grafikkort med, så jag tar dessa som exempel, snabbaste bit-djupet är alltid 8 bitar (256 färger) på grund av att det färgdjupet är minst minneskrävande, om vi sedan går upp till det långsammaste läget (24 bitar) så är det långsamt för att varannan minnesträff ligger på en ojämn minnesadressering och processorn förlorar tid på att inte arbeta med jämna adresseringar (det kostar processorn en klockcykel att korrigera sig till att läsa / skriva till en udda adress) sedan påverkas den också negativt av den adresseringsmetod som används i 16 bitars-läge (Integers i ditt fall) nämligen att adresspekaren inte får göra de 4 byte hopp som den är designad för på minnesadresser där adressen mod 4 != 0, detta fenomen kostar också klockcykler (en till två per adresseringsfel har jag för mig) och i 32 bitars-läge så är tidigare problem som bortblåsta (Long), processorn kan arbeta optimalt utan att bry sig om att adresseringsenheterna beter sig rätt.

*Följande gäller Pentium 1 MMX och tidigare, hur det ligger till på nyare maskiner vet jag inte*

Utanpå allt det här så cachas också all information i processorns cache minne i block om 64 bytes block (16 st adresseringsenheter) och aldrig på något annat vis, det innebär att information som kan vara uppdelad på mindre enheter inte alltid utnyttjar cachen optimalt och därför måste hämtas från Level2-cachen eller ännu värre ram-minnet oftare.


Struligt och svårt att förstå javisst, är ej själv 100% säker på att ovanstående är 100% sann, men principen är sann och har gällt på alla processorer jag känner till...

Den hade garanterat blivit snabbare i assembler, men frågan är om inte den snabbaste lösningen hade varit ren c-kod kompilerad i VC++, den kompilatorn optimerar flera gånger bättre än en duktig assemblerprogrammerare (i de flesta fall)...

Hej
Hittade ytterliggare en optimering.Gör Array Potenser Global
Array Potenser(13) As Long kan du räkna ut redan i Form_Load

Private Sub Form_Load()
Dim i As Long
For i = 0 To 13
Potenser(i) = 2 ^ i
Next
End Sub
Sedan vidhåller jag att det är onödigt att slösa energi på
tidmätning med SubClassing. Lägg in en Dim Start As Single
i General deklaration.Sedan när man trycker på Command1
Start = Timer, och när du kommer tillbaka MsgBox Timer - Start

Tycker gnälliga
Sven

Hmm...

---
2002-11-02 16:59:27 - Niklas Jansson

...
Om 2^t är för långsam kan du alltid använda en array som du gör innan:

Dim Potenser(0 To 10) As Long, i as long
For i=0 to 10
Potenser(i)=2^i
Next
...
---

Svaret efter är skrivet av just SvenPon:

---
Hej
En liten kommentar
>2^t
Är inget bra i Vb , vet ej hur det är i C

Om du behöver skriva 2^3 är det mycket bättre att skriva 2*2*2
---

Du har alltså läst ett svar en dag, klagat på det och sedan visat exakt samma metod dagen efter...

/Niklas Jansson

Hej
>Om du behöver skriva 2^3 är det mycket bättre att skriva 2*2*2
>Du har alltså läst ett svar en dag, klagat på det och sedan visat exakt >samma metod dagen efter...

27/10 vs 2/11 är inte dagen efter,vidare fattar jag
inte varför man skall skriva Dim Potenser(0 To 10) As Long,
När det räcker med Potenser(13)

Jag har väl för faeen inte klagat jag skrev en vänlig kommentar
som visade sig inte hade bäring på detta exempel .

Vidhåller fortfarande med kraft att det är
bättre att skriva 2*2*2 än att skriva 2^3.Men det funkar inget
bra i detta exempel.Och är onödigt när man kör från Form_Load.

mvh
Sven som svar på tjaffset.

När 2^t kompileras i C eller C++ kompileras det sannolikt som (med en hyffsat modern kompilator):


MOV eax, 2 '1 klockcykel
LSL eax, t '1 klockcykel

I vb kompileras det gissningsvis (har inte kollat) som ett funktionsanrop till en X^Y-funktion...

Hej
Så är det nog med Vb,inget som jag hittat på,har läst för länge sedan
att man skall undvika att skriva så om man vill ha speed i en loop.

DS

...och med en snabbare dator :-)

>27/10 vs 2/11 är inte dagen efter,
Ok, jag läste datum från fel inlägg. Det är ändå bara fem dagar. Maningen med inlägget var att du kanske skulle tänka lite på vad som faktiskt skrivits i koden.

>vidare fattar jag inte varför man skall skriva Dim Potenser(0 To 10) As Long,När det räcker med Potenser(13)
Nu vill jag inte ha en diskussion, men eftersom du ställer det som en fråga så tycker jag att min metod är tydligare. Skit samma...

>Jag har väl för faeen inte klagat jag skrev en vänlig kommentar som visade sig inte hade bäring på detta exempel .
Jag har inte heller klagat, jag bara tycker det är konstigt att du först anmärker på en metod och sedan visar samma metod...


>Vidhåller fortfarande med kraft att det är bättre att skriva 2*2*2 än att skriva 2^3.Men det funkar inget bra i detta exempel.Och är onödigt när man kör från Form_Load.
Javisst, det är ju det jag menar i mitt första exempel.
Skälet är helt enkelt att 2^3 beräknas som e^3ln2, och detta för att man skall kunna utföra beräkningen med flyttal.


Och om man skriver 2^3 i C eller C++ kommer det betyda 2 xor 3...

/Niklas Jansson

Tack för förklaringen av Long. Vad är bättre att använda byte eller int?

Jag kommer att stoppa in denna kod i ett större program så det kommer ligga i en modul så jag jag vill inte ladda den i form load.

Jag använde denna kod för första gången på riktigt och gjorde ett system till det italienska stryktipset men tyvärr hjälper inte ett bra system en kass tippare(9 rätt).

Jag jämför som sagt med ett annat program (gjort i c++) som är bäst(har inte kollat alla men ganska många) i denna sorts reducering.
Mitt program är snabbare på dom mindre systemen(upp till ca 4000 rader). Och den ger mindre antal rader för system upp till ca 100 rader. Ju mer rader desto sämre men jag använder oftast inte så många rader så det kvittar om bara jag ska använda det.

Men jag har ganska mycket kvar att göra om det ska få lika många funktioner. En sak som kanske gör att det kommer att ta längre tid är att jag måste få programmet att funka med halvgarderingar(u-rad) också.

Det hjälper mig inte att någon säger att C är snabbare skulle vilja ha uppskattningar (Jag slår inte ihjäl er om det är fel ;) Jag har insett att det spelar mycket roll på hur man skriver koden)

Hej
>Vad är bättre att använda byte eller int?

Det blir samma svar ,du skall byta :-) Byte mot Long
Processorn skyfflar 32 bitar i taget sedan måste programmet
göra några extra turer för att vaska fram Integer eller Byte
delen av dessa 32 bitar = 4 Byte

DVS Long är snabbast sedan kommer Integer sedan Byte

Sven

C är snabbare men det är mycket svårt att säga hur mycket snabbare...

Det finns två aspekt att se det på:

1. Går koden (algoritmen) att skriva effektivare i C?

Jepp. Det finns en hel del grejer som man kan optimera avsevärt genom att språket har vissa möjligheter VB saknar (inline-kod, t ex)

2. Går det snabbare med samma algoritm?

Ofta, eftersom C är konstruerat efter principen att kompilatorn skall optimera så mycket som möjligt själv, och eftersom de allra flesta kompilator är många gånger bättre än VBs kompilator.

Skälet till att det blir så svårt att säga beror alltså på att det dels är kompilatorberoende, dels är programmerarberoende. Du kan få en tiofaldig minskning av tiden, eller kanske bara någon enstaka procent.

Är du bra på att skriva effektiva algoritmer och känner till optimeringstricks i C, och dessutom har en bra kompilator så är det verkligen värt att satsa på.

Annars beror det som sagt var på alla omständigheter.

/Niklas Jansson

Det går inte att ge en siffra typ "C är 57% snabbare än VB" eftersom det beror på vad man gör. Låt säga att du gör en sak som man ofta gör i db-applikationer i VB: öppna ett recordset med 20 poster från en databas och fyll en listbox. Det går ganska snabbt i VB om man vet hur man använder ADO. Det går så snabbt att man inte hinner blinka, ungefär. Gör sedan samma sak i VC++. Vad händer? ingen skillnad alls. Det är ju samma ADO-objekt man använder där (om man inte går på lågnivå-API'erna men det är inte så många som känner för det), större delen av den kod som faktiskt exekveras när man hämtar några poster är alltså exakt samma. Så i det här fallet är kanske C-programmet 2% snabbare. Nu plockar jag detta ur luften givetvis.
Gör du däremot en mycket beräkningsintensiv applikation, eller om du ska jobba komplexa datastrukturer som t ex binära träd, ja då blir det mycket snabbare i C. (om inte helt enkelt absolut nödvändigt för att klara att konstruera algoritmerna). Men jag skulle tro att den enkla och viktigaste anledningen till att man generellt pratar om att C-program är snabbare beror på att erfarna C-programmerare kan mer om optimering, och jobbar mer optimalt, än den genomsnittlige VB-programmeraren som är lite lat och bekväm av sig och använder standardmöjligheterna från VB som man har lärt sig... :)
(jag är främst VB-programmerare).
Ta en sak som strängar. Hur stor andel av alla VB-programmerare VET bergsäkert att VB-strängar tar upp 4 bytes även om de är tomma, eller att strängarna lagras som Unicode i minnet, eller att &-operatorn skapar nya strängar och kastar bort den gamla? 5%? C-programmerare däremot *måste* veta exakt hur strängar, pekare till char-arrayer osv, faktiskt hanteras i datorns minne, för att kunna utföra någonting vettigt med någorlunda framgång... (t ex man har ett string-objekt som man ska passa till en API som tar en LPCSTR osv..). så för att kunna utveckla i C++ som är lite svårare än VB så blir man så illa tvungen att skaffa sig djupare kunskap om vad som pågår bakom ytan... och när man har den kunskapen, då skriver man sannolikt bättre och snabbare kod också...
Eller så kan man lära sig mer om VB och skriva snabb VB-kod. Som du har sett så går det. Och så slipper man hålla reda på alla lpcstr, lpzcstr, bstr's och typecastade char-pekare. Det är faktiskt inget kul alls med det där.. Så man kan säga att VB är mycket bättre än C eftersom man slipper mycket problem! :)

MEN ALLT DETTA KAN VI GLÖMMA i .NET! Halleluja!!
Då är vi alla på samma spelplan. C++, C#, och VB-programmerare använder samma .Net Framework som är precis lika snabbt eller långsamt oavsett vilket språk du väljer!

.Ola

Hej
>MEN ALLT DETTA KAN VI GLÖMMA i .NET! Halleluja!!

Säger bara en sak FY FAEN ! 0 :-)

Sven

Hej.

Intressant diskussion.
Till nästa fråga.

Hur står .NET:s prestanda i förhållande till C, C++ & VB???
Generellt.

//fredda

Lurig fråga.... Generellt snabbare skulle jag vilja säga. Vissa saker blir segare i .Net, t ex att ladda fönster och starta program.... Men nästan allt som är viktigt går mycket snabbare. Mycket beror på att man nu har nya objekt att använda som har mer kraftfull kod bakom sig som man kan använda från Vb.Net. Men det hela är mycket mer komplicerat än så och jag har inte möjlighet att ge en komplett bild här och nu...
Vad som otvivelaktigt har blivit betydligt snabbare är ASP.NET!

Men jag kan tipsa om ett par länkar:

http://www.devhood.com/tutorials/tutorial_details.aspx?tutorial_id=203&printer=t

http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndotnet/html/dotnetperftips.asp

http://dotnet247.com/247reference/guide/63.aspx
http://dotnet247.com/247reference/guide/57.aspx


[redigerad]

Hej Ola
Finns det ingen Enterknapp på ditt tangentbord
Bra om du gör radskifte lite oftare,blir mycket mer lättläst

mvh
Sven

> <b>Bra om du gör radskifte lite oftare,blir mycket mer lättläst</b>

Nej, snälla inte!

Man anpassar radlängden genom att dra i högerkanten på webbläsarfönstret! Vad som är bekväm radlängd för dig är det inte säkert att det är för mig!

Om ingen använder radbrytning för annat än för styckemarkering så går det mycket lättare att justera radlängden så att den passar varje persons önskemål!

Jag kollade lite på att använda bara halvgarderingarna och det gick bra att använda detta program med några små förändringar. Och det skapar samma antal rader som på det andra programmet även på större system.

Och jag tror det ska funka bra med både hel och halv samtidigt men det blir lite jobbigare i huvudprogrammet att omvandla till riktiga rader (har inte testat det än).

Men jag stör mig lite på att det blev sämre på större system. Men blev lite fundersam på varför det var bättre på mindre för han verkar ha lyckats bra på det mesta? Har testat mitt program i en simulator och den ger rätt garanti.

Vissa uträkningar tar ju fortfarande otroligt lång tid(värsta uträkningen som kan bli är 13-13-1) så jag tänkte kasta in DoEvent men det slöar ner hyfsat så jag har hittat några lösningar på planetsourcecode som jag hämtat. Dom verkar vara lite oense om det är bra eller dåligt att använda sig av API för att lösa det. Ska kolla lite på det sen.

Tack Sven det kanske jag borde förstått.

Tack Nicklas och Ola det var ungefär ett sådana svar jag ville ha.
Som jag sa ville jag inte ha några exakta svar mer om det är ide att testa. Det känns nu som att måste vara ganska stor förbättring för att det ska vara värt.

Jag tror jag ska fundera ett tag till och se om jag kan få dom större system att funka bättre(och fixa några buggar som jag upptäckt) sen tror jag att jag ska testa göra samma uträkningar i C (om jag kommer ihåg något). Har för mig att det fanns fler bit-funktioner så det kanske går att göra bättre.

Jag har frågat det förut. Går det bra att skicka en array eller en multdim. array från ett cprogram till VB.

Kära Sven, här kommer ett boktips till dig.

http://www.amazon.com/exec/obidos/tg/detail/-/0764504487/qid=1036534708/sr=8-1/ref=sr_8_1/002-4758008-1829615?v=glance&n=507846

Här kan du lära dig avancerade saker som skillnaderna mellan hård och mjuk radbrytning.

Hur sidorna formatteras på denna sajt kan du prata med Pelle om.

Ja, det går att skicka arrayer mellan c- och vb-program, och även flerdimensionella skulle jag tro. Men det är kanske inte helt solklart hur man ska göra det. Jag kan inte svara på det på rak arm.
.Ola

Ok det låter bra. För jag skulle klara mig med en array tror jag. Men det skulle vara simplare med en multidim eller två arrayer.