BigInteger UDF

**eukalyptus**

Ich habe mal die besten Elemente des Wettbewerbs kombiniert und konnte nochmals 10% schneller werden
dann hab ich die UDF gleich mal auf alle 4 Grundrechenarten ausgebaut.
und heute noch auf Dezimalstellen erweitert.
(Ist noch nicht gründlich getestet, und ich hab auch noch keine Errorcodes usw. eingebaut... Beta halt;))

Dadurch ist die Performance wieder etwas schlechter geworden (0.0557 beim µit-Benchmark), aber immer noch ganz flink!

Kann jemand das Script gründlich testen? mein BigInt-Rechner schafft leider keine Dezimalzahlen.

Erklärung zu den Algo´s folgt irgendwann nach...
Wär schön, wenn die UDF langsam wachsen und immer mehr Funktionen bekommen würde...bzw. noch bessere Algo´s...

EDIT: Neue Version: autoit.de/wcf/attachment/11017/

lgE

BigInt BigDec BigNum BigNumber BigDecimal BigInteger _BigNum_Add _BigNum_Sub _BigNum_Mul _BigNum_Div _BigNum_Mod _BigNum_Round _BigNum_Compare

**peethebee**

Hi!

Großartig :). So habe ich mir das vorgestellt :). Bitte auch im englischen Forum posten später falls es sich als bugfrei erweist :).

Auf den ersten Blick sollte diese Zeile in Round überflüssig sein, oder?

[autoit]

$sRet = _BigInt_Add($sRet, "0")

[/autoit]

Weiter so!

peethebee

**AspirinJunkie**

Da die UDF jetzt ja auch Gleitkommazahlen unterstützt ist es ja eigentlich gar keine "BigInt"-UDF mehr sondern eher eine "BigFloat"-UDF - oder? ...

Black Viper

Danke eukalyptus, genau sowas hab ich gesucht :P, wenn du willst schick ich dir das Script fürs Wurzelziehen, hab iwie langeweile und da die 14 stellen langweilig sind in der normalen rechenkapazität wollt ich genau so was machen, wusste nur ned genau wie ich die funktionen einbauen soll.

PS: Es basiert auf dem Heron Verfahren, das heißt man braucht kein SQRT oder so sondern einfach nur *,/,+ (denke mal aber das weißt du bereits :P)

**eukalyptus**

Na dann immer her mit der Wurzel!
Die UDF soll ja nicht nur auf die Grundrechenarten beschränkt bleiben...

Soll ich die Funktionen eigentlich jetzt umbenennen? z.b. auf BigNum_

lgE

progandy

*Vote* für Umbenennen
Dann fehlt nur noch
- Quadrieren -> Wrapper für Multiplizieren mit sich slebst
- gibts noch was?

Black Viper

mir fällt momentan nix ein was noch fehlen könnte (jedenfalls nichts wichtiges) und an den wurzeln bin ich dran, das programm machts nur noch ned so wie ichs will

**eukalyptus**

So, nun ist Version 1 mal fertig.

Hinzugekommen ist _BigNum_Mod (Rest einer Division)
Durch eigene Add,Sub,Compare-Functions ist die Division nun fast doppelt so schnell.

Bugs oder Erweiterungsvorschläge bitte sogleich posten

lgE

**BugFix**

Hi,
du kannst ja anhand dieser Alghoritmen für schriftliches Rechnen, die Funktionen für Quadrat- und Kubikwurzel erstellen.

**eukalyptus**

Wurzeln müßen noch etwas warten...zuerst will ich mal alles andere gescheit getestet wissen

Hab einen Bug bei der Division entfernt und eine Debugfunktion eingebaut.
Wenn man die Global Const $BigNum_Debug = True setzt, dann wird ein TXT-File mit den einzelnen Rechenschritten erstellt.

Dann seht ihr mal, wie die Algorithmen eigentlich funktionieren

[autoit]

_BigNum_Add("1000000000000000000000000000","12345678901234567890")
Run('notepad.exe "' & @ScriptDir & '\BigNum_Debug.txt"')

[/autoit]

lgE

Black Viper

Sry Leute, hatte lange keine Zeit an dem Script weiter zu machen dann versagte mein PC und eine neuinstallation war nötig (Datensicherung nicht mehr möglich -.-) . Ich werde mich mal wieder ransetzen und versuchen wieder nach zu kommen was wurzeln betrifft. Der Heron Algorithmus an sich ist recht leicht um zu setzen, es gibt halt 2 verschiedene Möglichkeiten, 1. Man gibt dem Programm eine bestimmte anzahl an schritten vor die es durhführen soll, oder 2. man lässt es solange arbeiten bis es auf eine bestimmte abweichung genau ist. (Warum until x=y nicht funktioniert sollte klar sein, unendliche zahlen werden halt mal nie gleich^^)

hier mal möglichkeit 1:

Spoiler anzeigen

[autoit]

$a = inputbox("Wurzelziehen","Bitte die gewünschte Zahl eingeben:")
$0 = 0
$x = ($a/3) ; Die 3 dient nur als Startwert und kann durch jede beliebige Zahl ausgetauscht werden
$y = ($a/$x)
Do
$x1 = (($x+$y)/2)
$y1 = ($a/$x1)
$x = (($x1+$y1)/2)
$y = ($a/$x)
$0 = $0 + 1

[/autoit] [autoit][/autoit] [autoit]

until $0 = 100 ; 100 ist die Anzahl der Schritte, je mehr Schritte er durchführt desto genauer wird das Ergebnis
msgBox (0,"Wurzelziehen","Die Wurzel aus " &$a&" ist: "&$x )

[/autoit]

progandy

Um das Thema mal wieder etwas hervorzuholen:
Die BigInteger-UDF hat im englischen Forum hier ein paar Erweiterungen bekommen. Es gibt jetzt:

Zitat

;_BigNum_Sum
;_BigNum_Add
;_BigNum_Sub
;_BigNum_Mul
;_BigNum_Div
;_BigNum_Pow
;_BigNum_SQRT
;_BigNum_n_Root
;_BigNum_Mod
;_BigNum_Round
;_BigNum_Compare (größe vergleichen, sieht aber noch nicht wiriklich perfekt aus)
;_BigNum_Swap (zwei Zahlen vertauschen)

Alles anzeigen

BigNum.au3 - include

[autoit]

#include-once

[/autoit] [autoit][/autoit] [autoit]

Global Const $BigNum_Debug = False

[/autoit] [autoit][/autoit] [autoit]

; #INDEX# =======================================================================================================================
; Title .........: BigNum
; AutoIt Version : 3.2.12.1
; Language ......: English
; Description ...: Perform calculations with big numbers
; ===============================================================================================================================

[/autoit] [autoit][/autoit] [autoit]

; #CURRENT# =====================================================================================================================
;_BigNum_Sum
;_BigNum_Add
;_BigNum_Sub
;_BigNum_Mul
;_BigNum_Div
;_BigNum_Pow
;_BigNum_SQRT
;_BigNum_n_Root
;_BigNum_Mod
;_BigNum_Round
;_BigNum_Compare
;_BigNum_Swap
; ===============================================================================================================================

[/autoit] [autoit][/autoit] [autoit]

; #INTERNAL_USE_ONLY#============================================================================================================
;_BigNum_CheckNegative
;_BigNum_DivAdd
;_BigNum_DivComp
;_BigNum_DivSub
;_BigNum_Div_DivisorGreater14
;_BigNum_Div_DivisorMaxLen14
;_BigNum_InsertDecimalSeparator
;_BigNum_StringIsDecimal
;_BigNum_IsValid
; ===============================================================================================================================

[/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
; Name...........: _BigNum_Sum
; Description ...: Parses a sum using bigNums
; Syntax.........: _BigNum_Sum($sSum)
; Parameters ....: $sSum - A String showing the sum e.g. "2342314-9073458320-4953425342535+432532453245324534*34524532452345"
; Return values .: Success - Result
; Failure - 0, and sets @Error. If @Error = 0xDEAD then there is a function missing.
; Remarks .......: Becouse this uses call, Internal functions are not supported.
; Author ........: Mat
; ;===============================================================================================

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_Sum($sIn)
$sIn = StringStripWS($sIn,
Local $aReg = StringRegExp($sIn, "(?i)([0x;&H][0-9]*)", 3)
If Not @error Then
For $i = 0 To UBound($aReg) - 1
$sIn = StringReplace($sIn, $aReg[$i], Dec(StringTrimLeft($aReg[$i], 2)))
Next
EndIf

[/autoit] [autoit][/autoit] [autoit]

Local $aMatches = StringRegExp ($sIn, "(\w*$.*?$)", 3), $aParts, $sRet
If Not @Error Then
For $i = 0 to UBound ($aMatches) - 1
$aParts = StringSplit (StringRegExpReplace ($aMatches[$i], ".*?$(.*?)$", "\1"), ",")
$aParts[0] = "CallArgArray"
$sRet = Call (StringRegExpReplace ($aMatches[$i], "\(.*", ""), $aParts)
If @Error Then
$sRet = Call ("_BigNum_" & StringRegExpReplace ($aMatches[$i], "\(.*", ""), $aParts)
If @Error Then Return SetError (@Error, @extended, $sRet)
EndIf
$sIn = StringReplace ($sIn, $aMatches[$i], $sRet)
Next
EndIf

[/autoit] [autoit][/autoit] [autoit]

; Brackets
Local $sNest, $res
While StringInStr($sIn, "(")
$sNest = StringRegExpReplace($sIn, ".*?$([^\(]+?)$.*", "\1")
$res = _BigNum_Sum($sNest)
If @error Then Return SetError (@Error, @Extended, 0)

[/autoit] [autoit][/autoit] [autoit]

$sIn = StringReplace($sIn, "(" & $sNest & ")", $res)
WEnd

[/autoit] [autoit][/autoit] [autoit]

Local $aOps[6][2] = [["\^", "_BigNum_Pow"], ["%", "_BigNum_Mod"],["/", "_BigNum_Div"],["\*", "_BigNum_Mul"],["\+", "_BigNum_Add"],["-", "_BigNum_Sub"]]

[/autoit] [autoit][/autoit] [autoit]

For $i = 0 To 5
$aMatches = StringRegExp($sIn, "(-?\d*" & $aOps[$i][0] & "\d*)", 3)
If Not @error Then
For $x = 0 To UBound($aMatches) - 1
$aParts = StringSplit($aMatches[$x], StringRight($aOps[$i][0], 1))
$aParts[0] = "CallArgArray"
$sRet = Call($aOps[$i][1], $aParts)
If @Error Then Return SetError (@Error, @Extended, 0)
$sIn = StringReplace($sIn, $aMatches[$x], $sRet)
Next
EndIf
Next

[/autoit] [autoit][/autoit] [autoit]

Return $sIn
EndFunc ;==>_BigNum_Sum

[/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_Add
; Description ...: Addition $sX + $sY
; Syntax.........: _BigNum_Add($sX, $sY)
; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; Return values .: Success - Result $sX + $sY
; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
; Author ........: Eukalyptus http://www.autoit.de
;
; ;===============================================================================================
Func _BigNum_Add($sX, $sY)
If _BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
Local $iNeg = _BigNum_CheckNegative($sX, $sY), $sNeg = ""
If $iNeg = 3 Then $sNeg = "-"
If $iNeg = 1 Then Return _BigNum_Sub($sY, $sX)
If $iNeg = 2 Then Return _BigNum_Sub($sX, $sY)
If $BigNum_Debug Then Local $BN_File = FileOpen(@ScriptDir & "\BigNum_Debug.txt", 2)
Local $iDec = _BigNum_StringIsDecimal($sX, $sY)
Local $iTmp = StringLen($sX), $iLen = StringLen($sY), $iCar = 0, $sRet = ""
If $BigNum_Debug Then FileWrite($BN_File, " " & _BigNum_DS($iLen - $iTmp, "0") & $sX & " + " & @CRLF & " " & _BigNum_DS($iTmp - $iLen, "0") & $sY & @CRLF)
If $iLen < $iTmp Then $iLen = $iTmp
If $BigNum_Debug Then FileWrite($BN_File, " " & _BigNum_DS($iLen, "-") & @CRLF)
For $i = 1 To $iLen Step 18
$iTmp = Int(StringRight($sX, 18)) + Int(StringRight($sY, 18)) + $iCar
$sX = StringTrimRight($sX, 18)
$sY = StringTrimRight($sY, 18)
If ($iTmp > 999999999999999999) Then
$iTmp = StringRight($iTmp, 18)
$sRet = $iTmp & $sRet
If $BigNum_Debug Then FileWrite($BN_File, _BigNum_DS($iLen - $i - StringLen($iTmp) + 2) & $iTmp & _BigNum_DS($i) & "+" & $iCar & @CRLF)
$iCar = 1
Else
If $BigNum_Debug Then FileWrite($BN_File, _BigNum_DS($iLen - $i - StringLen($iTmp) + 2) & $iTmp & _BigNum_DS($i) & "+" & $iCar & @CRLF)
$iTmp = StringRight("000000000000000000" & $iTmp, 18)
$sRet = $iTmp & $sRet
$iCar = 0
EndIf
Next
$sRet = StringRegExpReplace($iCar & $sRet, "^0+([^0]|0$)", "\1", 1)
If $iDec > 0 Then $sRet = _BigNum_InsertDecimalSeparator($sRet, $iDec, $iDec)
If $sRet = "0" Then $sNeg = ""
If $BigNum_Debug Then
FileWrite($BN_File, " " & _BigNum_DS($iLen, "-") & @CRLF)
FileWrite($BN_File, _BigNum_DS($iLen - StringLen($sRet) + 1) & $sRet)
FileClose($BN_File)
EndIf
Return $sNeg & $sRet
EndFunc ;==>_BigNum_Add

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_Sub
; Description ...: Subtraction $sX - $sY
; Syntax.........: _BigNum_Sub($sX, $sY)
; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; Return values .: Success - Result $sX - $sY
; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
; Author ........: Eukalyptus http://www.autoit.de
;
; ;===============================================================================================
Func _BigNum_Sub($sX, $sY)
If _BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
Local $iNeg = _BigNum_CheckNegative($sX, $sY), $bNeg = False
If $iNeg = 3 Then Return _BigNum_Add("-" & $sX, $sY)
If $iNeg = 1 Then Return "-" & _BigNum_Add($sX, $sY)
If $iNeg = 2 Then Return _BigNum_Add($sX, $sY)
If $BigNum_Debug Then Local $BN_File = FileOpen(@ScriptDir & "\BigNum_Debug.txt", 2)
Local $iDec = _BigNum_StringIsDecimal($sX, $sY)
If _BigNum_Compare($sX, $sY) = -1 Then $bNeg = _BigNum_Swap($sX, $sY)
Local $iTmp = StringLen($sX), $iLen = StringLen($sY), $iCar = 0, $sRet = ""
If $BigNum_Debug Then FileWrite($BN_File, " " & _BigNum_DS($iLen - $iTmp, "0") & $sX & " - " & @CRLF & " " & _BigNum_DS($iTmp - $iLen, "0") & $sY & @CRLF)
If $iLen < $iTmp Then $iLen = $iTmp
If $BigNum_Debug Then FileWrite($BN_File, " " & _BigNum_DS($iLen, "-") & @CRLF)
For $i = 1 To $iLen Step 18
$iTmp = Int(StringRight($sX, 18)) - Int(StringRight($sY, 18)) - $iCar
$sX = StringTrimRight($sX, 18)
$sY = StringTrimRight($sY, 18)
If $iTmp < 0 Then
$iTmp = 1000000000000000000 + $iTmp
If $BigNum_Debug Then FileWrite($BN_File, _BigNum_DS($iLen - $i - StringLen($iTmp) + 2) & $iTmp & _BigNum_DS($i) & "-" & $iCar & @CRLF)
$iCar = 1
Else
If $BigNum_Debug Then FileWrite($BN_File, _BigNum_DS($iLen - $i - StringLen($iTmp) + 2) & $iTmp & _BigNum_DS($i) & "-" & $iCar & @CRLF)
$iCar = 0
EndIf
$sRet = StringRight("0000000000000000000" & $iTmp, 18) & $sRet
Next
$sRet = StringRegExpReplace($iCar & $sRet, "^0+([^0]|0$)", "\1", 1)
If $iDec > 0 Then $sRet = _BigNum_InsertDecimalSeparator($sRet, $iDec, $iDec)
If $BigNum_Debug Then
FileWrite($BN_File, " " & _BigNum_DS($iLen, "-") & @CRLF)
FileWrite($BN_File, _BigNum_DS($iLen - StringLen($sRet) + 1) & $sRet)
FileClose($BN_File)
EndIf
If $bNeg = True And $sRet <> "0" Then
Return "-" & $sRet
Else
Return $sRet
EndIf
EndFunc ;==>_BigNum_Sub

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_Mul
; Description ...: Multiplication $sX * $sY
; Syntax.........: _BigNum_Mul($sX, $sY)
; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; Return values .: Success - Result $sX * $sY
; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
; Author ........: Eukalyptus http://www.autoit.de
;
; ;===============================================================================================
Func _BigNum_Mul($sX, $sY)
If _BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
Local $iNeg = _BigNum_CheckNegative($sX, $sY), $sNeg = ""
Local $iDec = _BigNum_StringIsDecimal($sX, $sY)
If $BigNum_Debug Then
Local $BN_File = FileOpen(@ScriptDir & "\BigNum_Debug.txt", 2), $BN_X = StringLen($sX)
FileWrite($BN_File, " " & $sX & " * " & $sY & " = " & @CRLF)
FileWrite($BN_File, " " & _BigNum_DS($BN_X + StringLen($sY) + 3, "-") & @CRLF)
EndIf
Local $aX = StringRegExp($sX, '\A.{' & 6 - (Ceiling(StringLen($sX) / 6) * 6 - StringLen($sX)) & '}|.{6}+', 3)
Local $aY = StringRegExp($sY, '\A.{' & 6 - (Ceiling(StringLen($sY) / 6) * 6 - StringLen($sY)) & '}|.{6}+', 3)
Local $aRet[UBound($aX) + UBound($aY) - 1]
For $j = 0 To UBound($aX) - 1
For $i = 0 To UBound($aY) - 1
If $BigNum_Debug Then
FileWrite($BN_File, " " & _BigNum_DS(StringLen($aX[0]) + $j * 6 - StringLen($aX[$j])) & $aX[$j] & _BigNum_DS($BN_X - (StringLen($aX[0]) + $j * 6)) & " * " & _BigNum_DS(StringLen($aY[0]) + $i * 6 - StringLen($aY[$i])) & $aY[$i])
FileWrite($BN_File, " " & _BigNum_DS(((UBound($aY) - 1 - $i) * 6) + ($i * 15 + $j * 15)) & $aX[$j] * $aY[$i] & @CRLF)
EndIf
$aRet[$j + $i] += $aX[$j] * $aY[$i]
Next
Next
If $BigNum_Debug Then
FileWrite($BN_File, " " & _BigNum_DS($BN_X + StringLen($sY) + 3) & _BigNum_DS($i * 15 + $j * 15, "-") & @CRLF)
FileWrite($BN_File, " " & _BigNum_DS($BN_X + StringLen($sY) + 6))
For $i = 0 To UBound($aRet) - 1
FileWrite($BN_File, $aRet[$i] & _BigNum_DS(15 - StringLen($aRet[$i])))
Next
FileWrite($BN_File, @CRLF & @CRLF)
For $i = 0 To UBound($aRet) - 1
FileWrite($BN_File, _BigNum_DS($BN_X + StringLen($sY)) & _BigNum_DS($i * 6 + 15 - StringLen($aRet[$i])) & $aRet[$i] & @CRLF)
Next
FileWrite($BN_File, _BigNum_DS($BN_X + StringLen($sY)) & _BigNum_DS(15 - StringLen($aRet[0])) & _BigNum_DS($i * 6, "-") & @CRLF)
EndIf
Local $sRet = "", $iCar = 0, $iTmp
For $i = UBound($aRet) - 1 To 0 Step - 1
$aRet[$i] += $iCar
$iCar = Floor($aRet[$i] / 1000000)
$iTmp = Mod($aRet[$i], 1000000)
If $iTmp <= 1000000 Then $iTmp = StringRight("000000" & $iTmp, 6)
$sRet = $iTmp & $sRet
Next
If $iCar > 0 Then $sRet = $iCar & $sRet
$sRet = StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1)
If ($iNeg = 1 Or $iNeg = 2) And $sRet <> "0" Then $sNeg = "-"
If $iDec > 0 Then $sRet = _BigNum_InsertDecimalSeparator($sRet, $iDec * 2, $iDec * 2)
If $BigNum_Debug Then
FileWrite($BN_File, _BigNum_DS($BN_X + StringLen($sY)) & _BigNum_DS(15 - StringLen($aRet[0])) & $sRet)
FileClose($BN_File)
EndIf
Return $sNeg & $sRet
EndFunc ;==>_BigNum_Mul

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_Div
; Description ...: Division $sX / $sY
; Syntax.........: _BigNum_Div($sX, $sY, [$iD = 0])
; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $iD [optional] - Number of Decimalplaces
; Return values .: Success - Result $sX / $sY
; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
; Author ........: Eukalyptus http://www.autoit.de
;
; ;===============================================================================================
Func _BigNum_Div($sX, $sY, $iD = 0)
If _BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
Local $iNeg = _BigNum_CheckNegative($sX, $sY), $sNeg = ""
Local $iDec = _BigNum_StringIsDecimal($sX, $sY), $sMod
If $sX = 0 Or $sY = 0 Then Return "0"
If $sY = "1" Then Return $sNeg & $sX
While StringLeft($sX, 1) = "0"
$sX = StringTrimLeft($sX, 1)
$iDec += 1
WEnd
While StringLeft($sY, 1) = "0"
$sY = StringTrimLeft($sY, 1)
$iDec += 1
WEnd
Local $sRet = "", $iLnX = StringLen($sX), $iLnY = StringLen($sY), $iTmp, $iCnt, $sTmp, $iDe1 = 0
If $iD > 0 Then $iDe1 += $iD
If $iNeg = 1 Or $iNeg = 2 Then $sNeg = "-"
$iTmp = _BigNum_Compare($sX, $sY)
If $iTmp = -1 Then
For $iCnt = $iLnX To $iLnY
$sX &= 0
$iDe1 += 1
Next
EndIf
If $iTmp = 0 Then Return $sNeg & "1"
If $iD = -1 Then $iD = $iDec * 2
For $iCnt = 1 To $iD
$sX &= "0"
Next
If $iLnY > 14 Then
$sRet = _BigNum_Div_DivisorGreater14($sX, $sY, $sMod)
Else
$sRet = _BigNum_Div_DivisorMaxLen14($sX, $sY, $sMod)
EndIf
If $iDe1 > 0 Then $sRet = _BigNum_InsertDecimalSeparator($sRet, $iDe1, $iD)
If $sRet = "0" Then
Return "0"
Else
Return $sNeg & $sRet
EndIf
EndFunc ;==>_BigNum_Div

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_Pow
; Description ...: Exponentiation $n^$e
; Syntax.........: _BigNum_Pow($n [, $e = 2])
; Parameters ....: $n - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $e [optional] - Exponent (must be a positive 64-bit signed integer)
; Default: $e = 2 means result = $n²
; Return values .: Success - Result $n^$e
; Failure - -1, sets @error to 1 if $n not valid StringNumber
; -1, sets @error to 2 if $e is not a positive Integer
; Author ........: jennicoattminusonlinedotde
; Date ..........: 9.12.09
; Remarks .......: Fractional exponents not allowed - use BigNum_n_root instead.
; _BigNum_Pow() offers a drastically better efficiency than looping _BigNum_Mul()
; Reference .....: http://en.wikipedia.org/wiki/Exponentiation_by_squaring
; ;===============================================================================================
Func _BigNum_Pow($n, $e = 2)
$e = Number($e)
If IsInt($e) = 0 Or $e < 0 Then Return SetError(2, 0, -1)
;If $e < -2147483648 Or $e > 2147483647 Then Return SetError(-2, 0, -1)
If _BigNum_IsValid($n, $n) Then Return SetError(1, 0, -1)

[/autoit] [autoit][/autoit] [autoit]

Local $res = 1

[/autoit] [autoit][/autoit] [autoit]

While $e
;If BitAND($e, 1) Then ; bitoperation is not faster !
If Mod($e, 2) Then
$res = _BigNum_Mul($res, $n)
$e -= 1
EndIf
$n = _BigNum_Mul($n, $n)
;$e = BitShift($e, 1) ; bitoperation is not faster !
$e /= 2
WEnd

[/autoit] [autoit][/autoit] [autoit]

Return $res
EndFunc ;==>_BigNum_Pow

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_SQRT
; Description ...: Square Root (BigNum)
; Syntax.........: _BigNum_SQRT($n [, $p = -1])
; Parameters ....: $n - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $p [optional] - Precision (Number of Decimalplaces) (must be positive Integer)
; Default: $p = -1 means automatic precision (stringlen of integer part of $n)
; Return values .: Success - Result SQRT($n)
; @extended = Precicion of result (if $p set to automatic precision)
; @error = Number of Iterations
; Failure - -1, sets @error to -1 if $n not valid StringNumber
; -1, sets @error to -2 if $p is out of valid range
; -1, sets @error to -3 if time-out (>100 iterations)
; Author ........: jennicoattminusonlinedotde
; Date ..........: 8.12.09
; Remarks .......: use Precision param when u want to obtain the square root of a small number with the desired decimal places.
; References ....: http://www.merriampark.com/bigsqrt.htm
; "Newton's Method" - before: Heron of Alexandria
; ;===============================================================================================
Func _BigNum_SQRT($n, $p = -1)
If _BigNum_IsValid($n, $n) Then Return SetError(-1, 0, -1)
$p = Number($p)
If IsInt($p) = 0 Or $p < -1 Then Return SetError(-2, 0, -1)
Local $l = StringInStr($n, ".") - 1
If $l = -1 Then $l = StringLen($n)
If $p < 0 Then $p = $l
Local $g = 1, $last

[/autoit] [autoit][/autoit] [autoit]

For $i = 3 To $l Step 2
$g = _BigNum_Mul($g, 10)
Next

[/autoit] [autoit][/autoit] [autoit]

For $i = 1 To 100
$last = $g
$g = _BigNum_Div(_BigNum_Add(_BigNum_Div($n, $g, $p), $g), 2, $p)
If $last = $g Then Return SetError($i, $p, $g)
Next
Return SetError(-3, 0, -1)
EndFunc ;==>_BigNum_SQRT

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_n_Root
; Description ...: $e-th Root of $n
; Syntax.........: _n_Root($n [, $e=2])
; Parameters ....: $n - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $e - [optional] Multiplicity of root (power, exponent) (must be a positive 64-bit signed integer > 0)
; Default: $e = 2 (=SQRT)
; $p - [optional] Precision (Number of desired Decimalplaces) (must be positive Integer)
; Default: $p = -1 means automatic precision (stringlen of integer part of $n)
; Return values .: Success - Result $e-root($n)
; @extended = Number of Iterations
; Failure - -1 and sets @error to 1 if $n not valid StringNumber
; -1 and sets @error to 2 if $e out of valid range
; -1 and sets @error to 3 if $p out of valid range
; Author ........: jennicoattminusonlinedotde
; Date ..........: 9.12.09
; References ....: derived from "Newton's Method"
; ;===============================================================================================
Func _BigNum_n_Root($n, $e = 2, $p = -1)
If _BigNum_IsValid($n, $n) Then Return SetError(1, 0, -1)
$e = Number($e)
If IsInt($e) = 0 Or $e < 1 Then Return SetError(2, 0, -1)
$p = Number($p)
If IsInt($p) = 0 Or $p < -1 Then Return SetError(3, 0, -1)

[/autoit] [autoit][/autoit] [autoit]

Local $l = StringInStr($n, ".") - 1
If $l = -1 Then $l = StringLen($n)
If $p < 0 Then $p = $l
Local $g = 1, $last, $i = 0

[/autoit] [autoit][/autoit] [autoit]

For $i = 3 To $l Step 2
$g = _BigNum_Mul($g, 10)
Next

[/autoit] [autoit][/autoit] [autoit]

While 1
$i += 1
$last = $g
$g = _BigNum_Div(_BigNum_Add(_BigNum_Div($n, _BigNum_Pow($g, $e - 1), $p), _BigNum_Mul($g, $e - 1)), $e, $p)
If $last = $g Then Return SetExtended($i, $g)
WEnd
EndFunc ;==>_BigNum_n_Root

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_Mod
; Description ...: Modulo Mod($sX, $sY)
; Syntax.........: _BigNum_Mod($sX, $sY)
; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; Return values .: Success - Result Mod($sX, $sY)
; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
; Author ........: Eukalyptus http://www.autoit.de
;
; ;===============================================================================================
Func _BigNum_Mod($sX, $sY)
If _BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
If $sY = 0 Or $sY = 1 Then Return "0"
Local $sRes = $sX
Local $iNeg = _BigNum_CheckNegative($sX, $sY)
Local $iDec = _BigNum_StringIsDecimal($sX, $sY)
If _BigNum_Compare($sX, $sY) < 0 Then Return $sRes
Local $sRet = "", $iLnX = StringLen($sX), $iLnY = StringLen($sY)
If $iLnY > 14 Then
_BigNum_Div_DivisorGreater14($sX, $sY, $sRet)
Else
_BigNum_Div_DivisorMaxLen14($sX, $sY, $sRet)
EndIf
$sRet = _BigNum_InsertDecimalSeparator($sRet, $iDec, StringLen($sRet))
If ($iNeg = 3 Or $iNeg = 1) And $sRet <> "0" Then $sRet = "-" & $sRet
Return $sRet
EndFunc ;==>_BigNum_Mod

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_Round
; Description ...: Round $sX to $iD Decimalplaces
; Syntax.........: _BigNum_Round($sX, $iD)
; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $iD - Number of Decimalplaces
; Return values .: Success - Result Round($sX, $iD)
; Failure - 0, sets @error to 1 if $sX not valid StringNumber
; Author ........: Eukalyptus http://www.autoit.de
;
; ;===============================================================================================
Func _BigNum_Round($sX, $iD)
If _BigNum_IsValid($sX, $sX) Then Return SetError(1, 0, 0)
Local $sTmp = 0, $sRet, $sRes = $sX
Local $iNeg = _BigNum_CheckNegative($sX, $sTmp)
Local $iDec = _BigNum_StringIsDecimal($sX, $sTmp)
If $iD > $iDec Or $iDec = 0 Then Return $sRes
$sTmp = StringLeft(StringRight($sX, $iDec - $iD), 1)
$sRet = StringTrimRight($sRes, $iDec - $iD)
If $sTmp >= 5 And $iD > 0 Then
If $iNeg = 1 Then
$sRet = _BigNum_Add($sRet, "-0." & StringFormat("%0" & String($iD) & "u", "1"))
Else
$sRet = _BigNum_Add($sRet, "0." & StringFormat("%0" & String($iD) & "u", "1"))
EndIf
ElseIf $sTmp >= 5 And $iD = 0 Then
If $iNeg = 1 Then
$sRet = _BigNum_Add($sRet, "-1")
Else
$sRet = _BigNum_Add($sRet, "1")
EndIf
Else
If StringRight($sRet, 1) = "." Then $sRet = StringTrimRight($sRet, 1)
EndIf
Return $sRet
EndFunc ;==>_BigNum_Round

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #FUNCTION# ;====================================================================================
;
; Name...........: _BigNum_Compare
; Description ...: Compares $sX $sY
; Syntax.........: _BigNum_Compare($sX, $sY)
; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
; Return values .: Success - Return:
; |0 - $sX and $sY are equal
; |1 - $sX is greater than $sY
; |-1 - $sX is less than $sY
; Failure - sets @error to 1 if $sX/$sY not valid StringNumber
; Author ........: Eukalyptus http://www.autoit.de
;
; ;===============================================================================================
Func _BigNum_Compare($sX, $sY)
Local $iNeg = _BigNum_CheckNegative($sX, $sY)
If $iNeg = 1 Then Return -1
If $iNeg = 2 Then Return 1
Local $iLnX = StringLen($sX), $iLnY = StringLen($sY)
If $iNeg = 3 Then
If $iLnX > $iLnY Then
Return -1
ElseIf $iLnX < $iLnY Then
Return 1
Else
If $sX > $sY Then
Return -1
ElseIf $sX < $sY Then
Return 1
Else
Return 0
EndIf
EndIf
Else
If $iLnX > $iLnY Then
Return 1
ElseIf $iLnX < $iLnY Then
Return -1
Else
If $sX > $sY Then
Return 1
ElseIf $sX < $sY Then
Return -1
Else
Return 0
EndIf
EndIf
EndIf
EndFunc ;==>_BigNum_Compare

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_Swap(ByRef $sX, ByRef $sY)
Local $sSwap = $sX
$sX = $sY
$sY = $sSwap
Return True
EndFunc ;==>_BigNum_Swap

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

; #INTERNAL_USE_ONLY#============================================================================================================

[/autoit] [autoit][/autoit] [autoit][/autoit] [autoit][/autoit] [autoit]

#region Internal Functions
Func _BigNum_Div_DivisorGreater14($sX, $sY, ByRef $sM)
$sM = "0"
If $sY = "1" Then Return $sX
If $sX = "0" Or $sY = "0" Or $sX = "" Or $sY = "" Then Return "0"
If $BigNum_Debug Then
Local $BN_File = FileOpen(@ScriptDir & "\BigNum_Debug.txt", 2), $BN_X = StringLen($sX)
FileWrite($BN_File, " " & $sX & " / " & $sY & " = " & @CRLF)
FileWrite($BN_File, " " & _BigNum_DS($BN_X + StringLen($sY) + 3, "-") & @CRLF)
EndIf
Local $iLnY = StringLen($sY), $bRed = False
Local $sRet = "", $sRem = StringLeft($sX, $iLnY), $sTmp = "", $sTm2 = "", $iCnt, $iLen = 1
$sX = StringTrimLeft($sX, $iLnY)
Do
If _BigNum_DivComp($sRem, $sY) = -1 Then
$sTmp = StringLeft($sX, 1)
$sRem &= $sTmp
$sX = StringTrimLeft($sX, 1)
If StringLen($sTmp) > 0 Then $iLen += 1
EndIf
$sTmp = $sY
$sTm2 = "0"
If _BigNum_DivComp($sRem, $sY) >= 0 Then
For $iCnt = 1 To 9
$sTm2 = $sTmp
$sTmp = _BigNum_DivAdd($sTmp, $sY)
If _BigNum_DivComp($sRem, $sTmp) < 0 Then ExitLoop
Next
Else
$iCnt = 0
EndIf
If $BigNum_Debug Then FileWrite($BN_File, _BigNum_DS($BN_X - StringLen($sX) - StringLen($sRem) + 1) & $sRem & _BigNum_DS($BN_X + 10 - $iLen - $iLnY) & StringFormat("%0" & String($iLen) & "u", $iCnt) & @CRLF)
If StringLen($sX) = 0 Then $bRed = True
$sM = $sRem
$sRem = _BigNum_DivSub($sRem, $sTm2)
If $iCnt > 0 Then $sM = $sRem
$sRet &= StringFormat("%0" & String($iLen) & "u", $iCnt)
$iTrm = $iLnY - StringLen($sRem)
$sTmp = StringLeft($sX, $iTrm)
$sX = StringTrimLeft($sX, $iTrm)
$iLen = StringLen($sTmp)
$sRem &= $sTmp
Until $bRed
$sM = StringRegExpReplace($sM, "^0+([^0]|0$)", "\1", 1)
If $BigNum_Debug Then
FileWrite($BN_File, " " & _BigNum_DS($BN_X + 9 + StringRegExp($sRet, "^0+([^0]|0$)", "\1", 1)) & _BigNum_DS(StringLen(StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1)), "-") & @CRLF)
FileWrite($BN_File, " " & _BigNum_DS($BN_X + 9 + StringRegExp($sRet, "^0+([^0]|0$)", "\1", 1)) & StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1))
FileClose($BN_File)
EndIf
Return StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1)
EndFunc ;==>_BigNum_Div_DivisorGreater14

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_Div_DivisorMaxLen14($sX, $sY, ByRef $sM)
$sM = "0"
If $sY = "1" Then Return $sX
If $sX = "0" Or $sY = "0" Or $sX = "" Or $sY = "" Then Return "0"
If $BigNum_Debug Then
Local $BN_File = FileOpen(@ScriptDir & "\BigNum_Debug.txt", 2), $BN_X = StringLen($sX)
FileWrite($BN_File, " " & $sX & " / " & $sY & " = " & @CRLF)
FileWrite($BN_File, " " & _BigNum_DS($BN_X + StringLen($sY) + 3, "-") & @CRLF)
EndIf
Local $sRet = "", $iRem = StringLeft($sX, 15), $iTmp = 0, $iTrm = 6, $iLen
$sX = StringTrimLeft($sX, 15)
$iTmp = Floor($iRem / $sY)
$sRet &= $iTmp
If $BigNum_Debug Then FileWrite($BN_File, " " & $iRem & _BigNum_DS(StringLen($sX) + 10) & $iTmp & @CRLF)
$iRem -= $iTmp * $sY
While StringLen($sX) > 0
$iTrm = 15 - StringLen($iRem)
$iTmp = StringLeft($sX, $iTrm)
$iLen = StringLen($iTmp)
$iRem &= $iTmp
$sX = StringTrimLeft($sX, $iTrm)
$iTmp = Floor($iRem / $sY)
$iTmp = StringRight("000000000000000" & $iTmp, $iLen)
If $BigNum_Debug Then FileWrite($BN_File, _BigNum_DS($BN_X - StringLen($sX) + 1 - StringLen($iRem)) & $iRem & _BigNum_DS(StringLen($sX) + 10 + StringLen($sRet)) & $iTmp & @CRLF)
$sRet &= $iTmp
$iRem -= $iTmp * $sY
WEnd
$sM = String($iRem)
If $BigNum_Debug Then
FileWrite($BN_File, " " & _BigNum_DS($BN_X + 10) & _BigNum_DS(StringLen(StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1)), "-") & @CRLF)
FileWrite($BN_File, " " & _BigNum_DS($BN_X + 10) & StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1))
FileClose($BN_File)
EndIf
Return StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1)
EndFunc ;==>_BigNum_Div_DivisorMaxLen14

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_DivComp($sX, $sY)
$sX = StringRegExpReplace($sX, "^0+([^0]|0$)", "\1", 1)
$sY = StringRegExpReplace($sY, "^0+([^0]|0$)", "\1", 1)
Local $iLnX = StringLen($sX), $iLnY = StringLen($sY)
If $iLnX < $iLnY Then
Return -1
ElseIf $iLnX > $iLnY Then
Return 1
Else
If $sX < $sY Then
Return -1
ElseIf $sX > $sY Then
Return 1
Else
Return 0
EndIf
EndIf
EndFunc ;==>_BigNum_DivComp

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_DivAdd($sX, $sY)
Local $iTmp = StringLen($sX), $iLen = StringLen($sY), $iCar = 0, $sRet = ""
If $iLen < $iTmp Then $iLen = $iTmp
For $i = 1 To $iLen Step 18
$iTmp = Int(StringRight($sX, 18)) + Int(StringRight($sY, 18)) + $iCar
$sX = StringTrimRight($sX, 18)
$sY = StringTrimRight($sY, 18)
If ($iTmp > 999999999999999999) Then
$sRet = StringRight($iTmp, 18) & $sRet
$iCar = 1
Else
$iTmp = StringRight("000000000000000000" & $iTmp, 18)
$sRet = $iTmp & $sRet
$iCar = 0
EndIf
Next
$sRet = StringRegExpReplace($iCar & $sRet, "^0+([^0]|0$)", "\1", 1)
Return $sRet
EndFunc ;==>_BigNum_DivAdd

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_DivSub($sX, $sY)
Local $iTmp = StringLen($sX), $iLen = StringLen($sY), $iCar = 0, $sRet = ""
If $iLen < $iTmp Then $iLen = $iTmp
For $i = 1 To $iLen Step 18
$iTmp = Int(StringRight($sX, 18)) - Int(StringRight($sY, 18)) - $iCar
$sX = StringTrimRight($sX, 18)
$sY = StringTrimRight($sY, 18)
If $iTmp < 0 Then
$iTmp = 1000000000000000000 + $iTmp
$iCar = 1
Else
$iCar = 0
EndIf
$sRet = StringRight("0000000000000000000" & $iTmp, 18) & $sRet
Next
$sRet = StringRegExpReplace($iCar & $sRet, "^0+([^0]|0$)", "\1", 1)
Return $sRet
EndFunc ;==>_BigNum_DivSub

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_IsValid($sX, $sY)
If StringRegExp($sX, "[^0-9.-]") <> 0 Or StringRegExp($sY, "[^0-9.-]") <> 0 Then Return True
Return False
EndFunc ;==>_BigNum_IsValid

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_InsertDecimalSeparator($sX, $iDec, $iD = 18)
If $iD = 0 And $iDec = 0 Then Return $sX
Local $sRet = StringRegExpReplace(StringRight(StringFormat("%0" & String($iDec) & "u", "") & $sX, $iDec), "0+$", "\1", 1)
$sX = StringTrimRight($sX, $iDec)
If $sX = "" Then $sX = "0"
$sRet = StringLeft($sRet, $iD)
If $sRet = "" Or $sRet = "0" Then Return $sX
Return $sX & "." & $sRet
EndFunc ;==>_BigNum_InsertDecimalSeparator

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_StringIsDecimal(ByRef $sX, ByRef $sY)
If StringLeft($sX, 1) = "." Then $sX = "0" & $sX
If StringLeft($sY, 1) = "." Then $sY = "0" & $sY
Local $iPsX = StringInStr($sX, ".", 0, 1) - 1, $iPsY = StringInStr($sY, ".", 0, 1) - 1
$sX = StringRegExpReplace($sX, "\D", "")
$sY = StringRegExpReplace($sY, "\D", "")
Local $iLnX = StringLen($sX), $iLnY = StringLen($sY)
If $iPsX <= 0 Then $iPsX = $iLnX
If $iPsY <= 0 Then $iPsY = $iLnY
If $iLnX - $iPsX > $iLnY - $iPsY Then
For $iCnt = $iLnY - $iPsY To $iLnX - $iPsX - 1
$sY &= "0"
Next
Return $iLnX - $iPsX
ElseIf $iLnX - $iPsX < $iLnY - $iPsY Then
For $iCnt = $iLnX - $iPsX To $iLnY - $iPsY - 1
$sX &= "0"
Next
Return $iLnY - $iPsY
EndIf
Return $iLnX - $iPsX
EndFunc ;==>_BigNum_StringIsDecimal

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_CheckNegative(ByRef $sX, ByRef $sY)
Local $bNgX = False, $bNgY = False
While StringLeft($sX, 1) = "-"
$bNgX = Not $bNgX
$sX = StringTrimLeft($sX, 1)
WEnd
While StringLeft($sY, 1) = "-"
$bNgY = Not $bNgY
$sY = StringTrimLeft($sY, 1)
WEnd
$sX = StringRegExpReplace($sX, "^0+([^0]|0$)", "\1", 1)
$sY = StringRegExpReplace($sY, "^0+([^0]|0$)", "\1", 1)
If $sX = "" Then $sX = "0"
If $sY = "" Then $sY = "0"
If $bNgX = True And $bNgY = True Then
Return 3
ElseIf $bNgX = True And $bNgY = False Then
Return 1
ElseIf $bNgX = False And $bNgY = True Then
Return 2
Else
Return 0
EndIf
EndFunc ;==>_BigNum_CheckNegative

[/autoit] [autoit][/autoit] [autoit]

Func _BigNum_DS($iC, $sS = " ")
Local $sRet = "", $iCnt
For $iCnt = 1 To $iC
$sRet &= $sS
Next
Return $sRet
EndFunc ;==>_BigNum_DS
#endregion Internal Functions

[/autoit]

eukalyptus: Mat hat angefragt, ob du die Funktionen nicht verbessern kannst.

Dial

Bekomme bei Benutzung eines Zahlensystem Rechners das:

$Var3 = _BigNum_Add($Var3, _BigNum_Mul(Dec($Var1[$i]), _BigNum_Potenz($Base, $Var2)))
$Var3 = _BigNum_Add($Var3, _BigNum_Mul(Dec($Var1[$i]), ^ ERROR

als Meldung

i2c

; Syntax.........: _BigNum_Add($sX, $sY)
Die Funktion erwartet nur 2 Parameter, bei dir sind es 3.

$Var3
_BigNum_Mul(Dec($Var1[$i])
_BigNum_Potenz($Base, $Var2)