#cs
	BOOLEAN & SHIT      >=1 -> ODER       1 -> NICHT       & -> UND
	Anmerkung: 	_DezZuDual gibt die Binärzahlen in umgekehrter Reihenfolge zurück, also ergäbe eine Eingabe von 13 nicht 1101 sondern 1011
	_Volladdieren8Bit rechnet nur mit den inversen Zahlen richtig
	_DualZuDez rechnet auch nur inverse Zahlen in die Richtigen Zahlen im 10er System um!
#ce

$Zahl1 = InputBox("Eingabe 1", "Geben Sie die erste Zahl ein")
$Zahl2 = InputBox("Eingabe 2", "Geben Sie die zweite Zahl ein")

$Dual1 = _DezZuDual($Zahl1)
$Dual2 = _DezZuDual($Zahl2)

$Rueckgabewert = _Volladdieren8Bit($Dual1, $Dual2)
MsgBox(0, "Ausgabe", "Das Ergebnis der Addition ist: " & _DualZuDez($Rueckgabewert))


;Rückgabewerte:
;$return[0-7] -> Dualzahlziffern
;$return[8] -> Übertrag (c)
Func _Volladdieren8Bit($aZahlx, $aZahly)
	$aHA = _HalbAddierer($aZahlx[0], $aZahly[0])
	$aVA1 = _VollAddierer($aZahlx[1], $aZahly[1], $aHA[1])
	$aVA2 = _VollAddierer($aZahlx[2], $aZahly[2], $aVA1[1])
	$aVA3 = _VollAddierer($aZahlx[3], $aZahly[3], $aVA2[1])
	$aVA4 = _VollAddierer($aZahlx[4], $aZahly[4], $aVA3[1])
	$aVA5 = _VollAddierer($aZahlx[5], $aZahly[5], $aVA4[1])
	$aVA6 = _VollAddierer($aZahlx[6], $aZahly[6], $aVA5[1])
	$aVA7 = _VollAddierer($aZahlx[7], $aZahly[7], $aVA6[1])

	Dim $return[9]
	$return[0] = $aHA[0]
	$return[1] = $aVA1[0]
	$return[2] = $aVA2[0]
	$return[3] = $aVA3[0]
	$return[4] = $aVA4[0]
	$return[5] = $aVA5[0]
	$return[6] = $aVA6[0]
	$return[7] = $aVA7[0]
	$return[8] = $aVA7[1]


	Return $return
EndFunc   ;==>_Volladdieren8Bit


;Rückgabewerte:
;$return[0] -> Summe (s)
;$return[1] -> Übertrag (c)
Func _VollAddierer($fX, $fY, $fCin)
	$aHA1 = _HalbAddierer($fX, $fY)
	$aHA2 = _HalbAddierer($fCin, $aHA1[0])

	$fOr = $aHA1[1] Or $aHA2[1]

	Dim $return[2]
	$return[0] = $aHA2[0]
	$return[1] = $fOr
	Return $return
EndFunc   ;==>_VollAddierer




;Rückgabewerte:
;$return[0] -> Summe (s)
;$return[1] -> Übertrag (c)
Func _HalbAddierer($fX, $fY)
	$fOr = $fX Or $fY
	$fAnd1 = $fX And $fY

	$fNot = Not $fAnd1

	$fAnd2 = $fOr And $fNot
	Dim $return[2]
	$return[0] = $fAnd2
	$return[1] = $fAnd1
	Return $return
EndFunc   ;==>_HalbAddierer

#cs
	##########
	Die Dezimalzahl 28 wird ins 2er-System umgewandelt

	Gehe nach folgendem Verfahren vor:
	(1) Teile die Zahl mit Rest durch 2.
	(2) Der Divisionsrest ist die nächste Ziffer (von rechts nach links).
	(3) Falls der (ganzzahlige) Quotient = 0 ist, bist du fertig,
	andernfalls nimm den (ganzzahligen) Quotienten als neue Zahl
	und wiederhole ab (1).

	28 : 2 = 14  Rest: 0
	14 : 2 =  7  Rest: 0
	7 : 2 =  3  Rest: 1
	3 : 2 =  1  Rest: 1
	1 : 2 =  0  Rest: 1

	Resultat: 11100
	##########
#ce
Func _DezZuDual($iZahl)
	Dim $aKurzerArray[1]
	Dim $aAusgabe[8]
	Local $i = 0

	Do
		ReDim $aKurzerArray[$i + 1]
		$iZwischenergebnis = Int($iZahl / 2)
		$aKurzerArray[$i] = $iZahl - 2 * $iZwischenergebnis
		$iZahl = $iZwischenergebnis
		$i = $i + 1
	Until $iZwischenergebnis = 0

	$iLaenge = UBound($aKurzerArray)
	For $i = $iLaenge To 7 Step 1
		ReDim $aKurzerArray[$i + 1]
		$aKurzerArray[$i] = 0
	Next

	Return $aKurzerArray
EndFunc   ;==>_DezZuDual


#cs
	##########
	Die Zahl 11100 (2er-System) wird ins Dezimalsystem umgewandelt

	Jede Stelle der Zahl hat den Wert der entsprechenden 2er-Potenz.
	Die der ersten Ziffer von rechts entsprechende Potenz ist 2º = 1.
	Nimm jede Ziffer mal mit der entsprechenden Potenz und summiere.
	Gehe am besten von rechts nach links vor:

	0 ·  1 =   0
	0 ·  2 =   0
	1 ·  4 =   4
	1 ·  8 =   8
	1 · 16 =  16
	———
	28
	##########
#ce
Func _DualZuDez($aZahl)
	Local $iAusgabe
	Dim $aZwischenergebnis[9]

	For $i = 0 To 8 Step 1
		$aZwischenergebnis[$i] = $aZahl[$i] * 2 ^ ($i)
		$iAusgabe = $iAusgabe + $aZwischenergebnis[$i]
	Next
	Return $iAusgabe
EndFunc   ;==>_DualZuDez