getallenstelsels in visual basic.net

[Land_of_spirits]

hoe kan ik met visual basic.NET een programma schrijven dat een getal uit bijvoorbeeld het decimale getallenstelsel omrekent naar het hexadecimale stelsel?

[freyk]

(volgends mij is dit een maak-mijn-huiswerk vraag.
Maar we willen je altijd helpen met de dingen die je al hebt )
Dus zeg ik je het volgende:

1. zoek uit hoe je dit berekend
2. probeer dit om te zetten in een script
3. post je script
4. en wacht op commentaar.

[Land_of_spirits]

Maak je maar geen zorgen, ik wil juist NIET dat jullie m'n huiswerk gaan maken. Het punt is dat ik wel snap hoe je met pen/papier naar bijv. hexadecimaal kunt omrekenen, en het hele principe erachter begrijp. Ik snap echter niet hoe je dit dus in een script kunt zetten. Specifieker: hoe vertel ik de computer dat bijvoorbeeld 130 gedeeld door 13 geen 10 is (in bijvoorbeeld een 13 tallig stelsel), maar A..?

[dafelix]

kent VB standaard geen base() functie oid ?

Anyhow, decimaal naar binair (pseudocode, althans, dat probeer ik)

if number > 255
  exit
end if

var binair

if number > 128
  binair = binair & 1
else
    binair = binair & 0
end if

if number > 64
  binair = binair & 1
else
    binair = binair & 0
end if

(...)

return binair

of gebruik de logische AND, although ik niet weet hoe VB die intepreteerd:

(...)
if number AND 128
  binair = binair & 1
else
  binair = binair & 0
end if

[dafelix]

en via google kwam ik dit tegen:

Public Function DecimalToBinary(DecimalNum As Long) As String
Dim tmp As String
Dim n As Long

n = DecimalNum

tmp = Trim(Str(n Mod 2))
n = n \ 2

Do While n <> 0
tmp = Trim(Str(n Mod 2)) & tmp
n = n \ 2
Loop

DecimalToBinary = tmp
End Function

[Gimme more beer]

dafelix schreef op 17-09-2006 @ 15:06 :

if number > 255
  exit
end if

Ik vraag me sterk af waarom je dat doet. Je kunt beter beginnen met het verhogen van de machten van twee tot je een getal hebt dat groter is dan het getal in kwestie. Dat kan bijvoorbeeld 4096 zijn. Dan tel je dus 2048 (100000000000, gezien het 2^11 is, dus 11 nullen) op bij je variabele en ga je delen door twee. Past 1024 nog in het restgetal? If yes, dan tel je er nog eens 10000000000 bij die variabele op. If not, dan tel je er niets bij op en ga je verder. Je lijkt in de veronderstelling dat het binaire stelsel tot 2^8 gaat, dat is niet waar.

Dat is de uitgebreide uitleg, zo stapsgewijs ga je natuurlijk geen code schrijven, maar het idee is duidelijk.

.NET?

Dan kan het toch gewoon met:

Convert.ToByte(getal,10)

(of een van de andere Convert methods)

[Land_of_spirits]

Dat weet ik dus niet...die methode ken ik verder niet iig.

Kun je eens voordoen hoe dat volgens jouw methode komt uit te zien als je het getal 131 van decimaal naar 13 tallig stelsel wilt omrekenen? De uitkomst moet dan A1 zijn...

[dafelix]

Land_of_spirits schreef op 17-09-2006 @ 19:41 :
Dat weet ik dus niet...die methode ken ik verder niet iig.

Kun je eens voordoen hoe dat volgens jouw methode komt uit te zien als je het getal 131 van decimaal naar 13 tallig stelsel wilt omrekenen? De uitkomst moet dan A1 zijn...

ffs dude, ik denk dat we je genoeg handvatten hebben aangereikt waarmee je verder kan, ik bedoel, probeer zelf eerst de formule te maken (of berekening), schrijf die uit, probeer die dan in VB te gooien, ga debuggen en komt d'r iets raars uit, post 't dan hier

[dafelix]

Gimme more beer schreef op 17-09-2006 @ 17:31 :
Ik vraag me sterk af waarom je dat doet. Je kunt beter beginnen met het verhogen van de machten van twee tot je een getal hebt dat groter is dan het getal in kwestie. (...)

Of de functie recursive gebruiken natuurlijk, zodat je een X aantal words returned

En qua code-shortening;

for number in 128 64 32 16 8 4 2 1
  if (number AND getal) 
    binair = binair & 1
  else
    binair = binair & 0
  end if
end for

[Chimera]

eddie schreef op 17-09-2006 @ 17:36 :
.NET?

Dan kan het toch gewoon met:

Convert.ToByte(getal,10)

(of een van de andere Convert methods)

Als dit huiswerk is, mag dat natuurlijk sowieso niet.

[ILUsion]

dafelix schreef op 17-09-2006 @ 22:55 :
Of de functie recursive gebruiken natuurlijk, zodat je een X aantal words returned

En qua code-shortening;

for number in 128 64 32 16 8 4 2 1
  if (number AND getal) 
    binair = binair & 1
  else
    binair = binair & 0
  end if
end for

Dat gaat volgens mij helemaal niet werken omdat je die 1 en 0 geen plaats aanwijst in feite (een 1 op de 1e positie van achter te tellen heeft een andere betekenis dan een 1 op de 10e positie, de ene keer is hij 1 waard, de andere keer 1024).

Zelf schrijf ik al lang geen Basic meer, dus zal ik maar geen moeite doen om in psuedocode te werken, maar je gaat hier volgens mij gewoon enerzijds met wat wiskunde te maken krijgen en anderzijds met stringbewerkingen (omdat een computer alles binair opslaat, en de programma's die binaire gegevens natuurlijk omzetten naar decimale notatie, wat in feite een string is).

Mijn idee is als volgt:
1. je maakt een functie die een de mogelijke tekens teruggeeft in de volgorde van hun waarde, voor het tientallig stelsel heb je dan "0123456789", voor het 16-delig zou dat "0123456789abcde" zijn, bijvoorbeeld. Dit is nodig omdat je anders vast voor elk stelsel nogal sprongen gaat moeten maken in je berekeningen. Wat ik persoonlijk zou doen is in die functie een constante opslaan en dan als je als argument bv. 13 meegeeft, dat hij van die constante string '0123 .... xyz' (lijkt me het meest logische) de eerste 13 tekens als resultaat teruggeeft.

2. verder heb je nog twee functies nodig, eentje om om te zetten van getal naar getal in andere notatie (string eigenlijk) en omgekeerd (string in bepaald getalstelsel naar getal in computernotatie/integer dus).

Die functies zijn niet zo heel moeilijk te schrijven, lijkt me, gewoon wat over nadenken en je komt er wel. Toch hier nog enkele tips:
Vergeet niet dat elke getalspositie een andere waarde vertegenwoordigt, in het tientalligstelsel, bijvoorbeeld:
132465 = 100000 + 30000 + 2000 + 400 + 60 + 5 en niet 1 + 3 + 2 + 4 + 6 + 5.
In het binair krijg je 10101 = 10000 + 0000 + 100 + 00 + 1
Wiskundig valt dit nog mooier te schrijven, dat is wat jij moet doen.

Berekening laat je best steeds gewoon door de computer uitwerken, dus gewoon steeds naar integer omzetten, bewerkingen laten uitvoeren en terugrekenen naar je getalstelsel, anders zit je met vreselijk ingewikkelde stringbewerkingen, lijkt me, als het zelfs niet zo goed als onmogelijk is om een generisch oplossing voor alle getalstelsels te maken).

Chimera schreef op 18-09-2006 @ 11:06 :
Als dit huiswerk is, mag dat natuurlijk sowieso niet.

en waarom zou dat niet mogen? zoiets heet goed gebruik maken van de geleverde functionaliteit

[Dr HenDre]

ik zou zeggen pas gewoon de definities van de (hexa)decimale stelsels toe.

125₁₀=1×10²+2×10¹+5×10⁰
Dit wiskunde implementeren is natuurlijk veel 'leuker' dan een bestaande functie gebruiken

[Land_of_spirits]

maar bij dat laatste heb je het probleem van een eindig stelsel, zoals jij het defineert. Wat ik meer bedoel is een algemene code die 155 kan uitrekenen, maar bijvoorbeeld ook 3465425344235243523625262546347 (decimaal) eventjes omzet naar het 13tallige stelsel. Dus dat je van te voren niet weet hoe groot het getal is dat je d'r in stopt...de methode mag dus niet eindigen, voordat er niets meer overblijft.

Ik zat zelf meer aan een loop te denken:

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim getal As Integer = txtbx10tal1.Text
nieuwGetal(getal)
txtbx13tal1.Text = (nieuwGetal(getal))
End Sub

Private Function nieuwGetal(ByVal getal As Integer) As Integer
Do
Dim x as integer
x= getal mod 13
nieuwGetal = getal / 13
If nieuwgetal < 13 then return nieuwGetal
loop

[Land_of_spirits]

dan is alleen nog de vraag hoe ik 1 2 3 4 5 6 7 8 9 omzet in 1 2 3 4 5 6 7 8 9 A B C D

[ILUsion]

Land_of_spirits schreef op 21-09-2006 @ 13:35 :
dan is alleen nog de vraag hoe ik 1 2 3 4 5 6 7 8 9 omzet in 1 2 3 4 5 6 7 8 9 A B C D

Je vergeet de 0, een zeer belangrijk getal. Dat je een 6, vergeet, dat is een kleine fout, maar een 0 of een 1 vergeten, is veel fundamenteler dan een simpele 6, zou ik zeggen (en dat is inderdaad een mening, want een fout is een fout, maar een 6 zou een vergetelheid zijn, een 0 of een 1 eerder fundamenteel).

Maar bon, soit.

Verder, ik zou niet denken in functie van getallen, de computer telt enkel binair en toont dat decimaal. Je interger kan nooit "AAA" zijn als weergave, hoewel dat ook een getal kan voorstellen in de wiskunde, werk met stringbewerkingen, kijk die eens na.

Stel je hebt een getalstring "ABCDE" (hexadecimaal, voor de eenvoud), hoe bepaal je dan de grootteorde van die A? (simpeler: begin van achteren te redenen: E, D , C, ...)

Wat is "B" in het hexadecimaal stelsel? Ja, het "B"-de teken (hex), dat is dus het 11e teken (dec) (als je nul als 0e teken ziet, wat volgens mij het simpelste is, zeker bij een dergelijke implementatie). Wat is dan een "B" op de 2e locatie waard? B(hex) x "16"(dec). En op de derde plaats? B(hex) x 16^2 (dec). En ga zo maar door. Dit is vrij makkelijk te implementeren.

In jouw implementatie zie ik trouwens slechts een vast gegeven; die "13", dat stoort me. Probeer de methode die ik hierboven al aangeef eens: een functie om een getalstring in getalstelsel X om te zetten naar een voor de computer werkbaar getal (integer) en een functie omgekeer: een integer naar een getalstring in stelsel Y (en X en Y zijn daarin parameters, of dat nu 1 of 13 of 27 of 666 is, dat maakt voor de implementatie zelf weinig uit: dat is programmeren, een algemene oplossing vinden voor een probleem).

[Land_of_spirits]

ja oke, ik snap inderdaad de omrekening. Dan vraag ik me alleen dus af: HOE koppel ik zoiets aan een string? met CStr?

[ILUsion]

Land_of_spirits schreef op 24-09-2006 @ 17:13 :
ja oke, ik snap inderdaad de omrekening. Dan vraag ik me alleen dus af: HOE koppel ik zoiets aan een string? met CStr?

Mijn kennis van VB zit te ver weg voor de specifieke implementatie daarvan, daarom hier wat ik (ongeveer) zou doen in Object PAscal / Delphi (met genoeg commentaar zodat je de taal niet echt hoeft te kennen, hoop ik).

// functie om standaard tekens (volgorde) te bepalen, zodat na 9 een a volgt enzovoorts)
function base(n:integer): string;
const default = '0123456789abcdefghijklmnopqrstuvwxyz';
begin
// geeft de n eerste tekens van de string
result := copy(default,0,n);
end;

//functie om STR > INT
// num: string die het getal in de notatie bevat
// base: string die de verschillende mogelijke tekens in volgorde bevat
function numToInt(num: string; base: string): integer;
var cnt:integer; //enumeratievariabele
begin
result := 0;
// teken per teken uitlezen (van achter naar voor) (en length geeft "N" terug (lengte van de string), maar de verschillende tekens zijn te benaderen door indexen 0 tot en met N-1)
for cnt := (length(num)-1) to 0 do
  begin
    // hier gebeurt het volgende: voor elk teken doen we hetzelfde, de eerste doorloping staat de som op 0, dus krijgen we enkel de toewijzing, daarna tellen we de bekomen uitkomsten steeds op
    // we nemen de positie cnt (let erop, de positie begint bij 0 en stop bij n-1) van het getal, dit geeft ons één teken terug (namelijk het teken dat op die plaats in het getal staat. Om nu voor dit teken te vinden welke waarde het in het getal heeft, gaan we een product maken van welke waarde het zou hebben als het alleen zou staan (bv. A = "10") door middel van POS (deze functie bepaalt op welke plaats het teken voorkomt in de string "base" (op plaats "0" staat de 0, op plaats "1" staat 1 enzovoorts, dat komt dus handig uit)), het tweede deel van het product is de bepaling op welke plaats het teken in het getal staat, hierin gaan we moeten compenseren voor het feit dat een string van 0..n-1 loopt (terwijl de machten van n-1..0 moeten lopen: het eerste teken heeft de grootste waarde)
    result := result + (pos(num[cnt],base)*pow(length(base),length(num)-cnt-1))
  end;
end;

//functie om een computerwaarde n om te zetten naar een stringrepresentatie van dat getal met base als getalstelsel(string)
function intToNum(n: integer; base: string): string;
var  x, y, l: integer;
begin
  x := n; // de beginwaarde van x gelijkstellen aan het getal
  l := length(base); // L = lengte van "base" (= grootte van het getalstelsel)
  while x <> 0 do
    begin
      // we beginnen hier met een grote waarde voor x, maar het resultaat wordt van achter opgebouwd (daarom op het einde + result en niet vanvoor)
      // we rekenen uit hoeveel de rest is als we x delen door L  (x mod l) en nemen dat teken uit het getalstelsel (notatie base[x] geeft teken x (van de 0..n-1 tekens uit de string base terug), we berekenen ook hoeveel het geheel deeltal is (x div L, in Pascal is dat de integerdeling, dit is niet hetzelfde als x / L (dat is de float-deling die een reëel getal als uitkomst geeft, daar kunnen we hier niet veel mee doen) en nemen dat als nieuwe waarde voor x en passen hierop hetzelfde toe, uiteindelijk komen we uit aan een getal dat kleiner wordt dan L, (en dus x div l = 0 dus x wordt 0, dus stop)
      result := base[x mod l] + result;
      x := x div l;
    end;
end;

Dit zou volgens mij wel moeten werken, maar zoals ik al zei: in VB zal dat net iets anders gaat, je zal gelijkaardige functies voor div, mod, pos, string[n], copy, ... moeten vinden in de help. Ik hoop dat je een beetje begrijpt wat ze hier staan te doen.

Met behulp van volgende code, zou je bijvoorbeeld een getal van binair naar hexadecimaal dan omzetten:

var bingetal, hexgetal: string;
begin
  bingetal := '101001011101';
  hexgetal := intToNum(NumToInt(bingetal,base(2)),base(16));
end;

Misschien iets makkelijker uitgeschreven als volgt:

var bingetal, hexgetal:string;
 n: integer;
begin
  bingetal := '101001011101';
  n := NumToInt(bingetal,base(2));
  hexgetal := IntToNum(n,base(16));
end;

De functie "base" is enkel om alles wat makkelijker te maken, je zou ook manueel zo'n string kunnen maken (als je bijvoorbeeld een alternatief tiendelig stelsel zou willen maken waarbij "A" = 0, "B" = 1, ... (of zelfs "9" = 0, "8" = 1, "7" = 2, ...), je geeft gewoon de grootte van je getalstelsel (tot n = 36) in en je krijgt een string die je het meest waarschijnlijk gaat nodig hebben.

Wat er dus gebeurt is dat het binair getal in stringformaat eerst naar een getal in computerformaat (binair, maar meestal weergegeven in het decimaal) en dan ga je dat getal omrekenen naar een hexadecimaal getal.

Ik hoop dat je een beetje de werkwijze begrijpt, je moet zelf een beetje proberen, de bovenstaande code is geschreven op een half uurtje, gok ik, en is zeker niet machinaal getest (maar wel manueel eens geevalueerd). Voor de specifieke implementatie in Basic, moet je daar in de help maar eens rondkijken of op sites naar stringbewerkingen voor Basic zoeken, want daar komt het meestal wel op neer.

Land_of_spirits schreef op 17-09-2006 @ 14:53 :
Maak je maar geen zorgen, ik wil juist NIET dat jullie m'n huiswerk gaan maken. Het punt is dat ik wel snap hoe je met pen/papier naar bijv. hexadecimaal kunt omrekenen, en het hele principe erachter begrijp. Ik snap echter niet hoe je dit dus in een script kunt zetten. Specifieker: hoe vertel ik de computer dat bijvoorbeeld 130 gedeeld door 13 geen 10 is (in bijvoorbeeld een 13 tallig stelsel), maar A..?

Wat ILUsion zegt inderdaad en voor delingen zou ik het lekker makkelijk houden: eerst beide getallen omzetten naar decimaal, dat delen (gewoon met een standaard deling van twee vars, hoef je geen eigen functie te maken) en de uitkomst weer terug zetten naar het gewenste talstelsel.

[Land_of_spirits]

allereerst: iedereen die iets zinnigs postte: bedankt!

ten tweede: dit is de code die ik er van geproduceerd heb. Volgens mij klopt hij.

Private Sub Button1_Click(ByVal sender As System.Object, ByVal e As System.EventArgs) Handles Button1.Click
Dim intTemp, intInput, intStelsel As Integer
Dim strOutput As String = ""
Dim arrConversie() As String = {"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"}
intInput = CInt(txtbx10tal1.Text)
intStelsel = 13
convertRoutine:
intTemp = intInput - Int(intInput / intStelsel) * intStelsel
If intInput = 0 Then GoTo prgEinde
intInput = (intInput - intTemp) / intStelsel
strOutput = arrConversie(intTemp) + strOutput
GoTo convertRoutine
prgEinde:
txtbx13tal1.Text = (CStr(strOutput))


End Sub
End Class

[ILUsion]

Mijn kennis Basic zit zoals ik gezegd heb te ver om de juistheid te controleren, ik kan je enkel de volgende tip geven: gebruik niet te veel goto/gosub in Basic, als je nadien je code moet aanpassen, ga je het hier best moeilijk mee krijgen om up te daten. Daarom zijn er structuren als WHILE en UNTIL (hoe de juiste syntaxis in Basic is, dat kan je wel opzoeken, ze verschillen normaal niet al te veel van Object Pascal, maar mijn Basic zit echt te ver om je te kunnen zeggen of het exact hetzelfde is (enkel dat de FOR-lus net wat anders is, kan ik zeggen).

[MightyMarcel]

ILUsion schreef op 25-09-2006 @ 16:16 :
Mijn kennis Basic zit zoals ik gezegd heb te ver om de juistheid te controleren, ik kan je enkel de volgende tip geven: gebruik niet te veel goto/gosub in Basic, als je nadien je code moet aanpassen, ga je het hier best moeilijk mee krijgen om up te daten. Daarom zijn er structuren als WHILE en UNTIL (hoe de juiste syntaxis in Basic is, dat kan je wel opzoeken, ze verschillen normaal niet al te veel van Object Pascal, maar mijn Basic zit echt te ver om je te kunnen zeggen of het exact hetzelfde is (enkel dat de FOR-lus net wat anders is, kan ik zeggen).

mij is ooit uitdrukkelijk verboden om uberhaupt goto's en gosub's te gebruiken, en die heb je - als je een beetje fatsoenlijke code hebt - absoluut niet nodig ook.

VB kent (geloof ik) 'do { } while (bool)' of 'while (bool) do { }'.

in C heb je ook geen goto's nodig. dus hoeft dat in VB ook niet, daar wordt je code alleen maar vervelend van.

[MightyMarcel]

onderstaande code heb ik ff aangepast, zoals ik t zou doen. ik heb t echter niet getest (en weet niet zeker of alles wel VB is).

Land_of_spirits schreef op 25-09-2006 @ 16:12 :


public function Convert(bijval int intStelsel, bijRef string[] Input)
{

Dim intTemp, intInput, intStelsel As Integer
Dim strOutput As String = ""
Dim arrConversie() As String =
{"0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "A", "B", "C"}
intInput = CInt(Input) // input = argument voor functie
// intStelsel is nu een argument voor de functie !

dim Quit as boolean
Quit = false;

do while (Quit == false)
{

intTemp = intInput - Int(intInput / intStelsel) * intStelsel
If intInput = 0 Then Quit = true; break;
intInput = (intInput - intTemp) / intStelsel
strOutput = arrConversie(intTemp) + strOutput
}

Input = (CStr(strOutput))
return Input


}

een en ander is wellicht ook slordige code, maar het gaat om het idee. nu heb je een functie die je kunt gebruiken om elke willekeurige string om te toveren in een ander stelsel. (even ervan uitgaande dat jouw code verder goed werkt, ik heb alleen de vorm wat aangepast).

al dit soort zooi kun je het beste in een module zetten, die je dan bij al je projecten kunt gebruiken. dat scheelt werk, en is 'good coding practice'.

[ILUsion]

MightyMarcel schreef op 25-09-2006 @ 16:26 :
mij is ooit uitdrukkelijk verboden om uberhaupt goto's en gosub's te gebruiken, en die heb je - als je een beetje fatsoenlijke code hebt - absoluut niet nodig ook.

VB kent (geloof ik) 'do { } while (bool)' of 'while (bool) do { }'.

in C heb je ook geen goto's nodig. dus hoeft dat in VB ook niet, daar wordt je code alleen maar vervelend van.

Visual Basic gebruikt voor zover ik weet geen accolades ( '{' en '}' , dat is eerder voor C-gerelateerde talen), bij Basic is het eerder een Pascal-achtige toepassing, als ik me niet vergis: afsluiten met end (waar pascal begint met "begin" en afsluit met "end;" is het bij Basic eerder WHILE conditie (haakjes zijn hier niet verplicht zoals bij PHP en C?) DO ... ... ... END

[MightyMarcel]

ILUsion schreef op 25-09-2006 @ 17:44 :
Visual Basic gebruikt voor zover ik weet geen accolades ( '{' en '}' , dat is eerder voor C-gerelateerde talen), bij Basic is het eerder een Pascal-achtige toepassing, als ik me niet vergis: afsluiten met end (waar pascal begint met "begin" en afsluit met "end;" is het bij Basic eerder WHILE conditie (haakjes zijn hier niet verplicht zoals bij PHP en C?) DO ... ... ... END

je hebt gelijk dat basic geen {} gebruikt. het gaat om het idee.