BigNum UDF

SUBMITTED BY: Guest

DATE: May 30, 2013, 7:46 a.m.

FORMAT: Text only

SIZE: 30.8 kB

Raw Download

HITS: 2222

Report
  1. #include-once
  3. ; #INDEX# =======================================================================================================================
  4. ; Title .........: BigNum
  5. ; AutoIt Version : 3.2.12.1
  6. ; Language ......: English
  7. ; Description ...: Perform calculations with big numbers
  8. ; ===============================================================================================================================
  10. ; #CURRENT# =====================================================================================================================
  11. ;_BigNum_Parse
  12. ;_BigNum_Add
  13. ;_BigNum_Sub
  14. ;_BigNum_Mul
  15. ;_BigNum_Div
  16. ;_BigNum_Pow
  17. ;_BigNum_SQRT
  18. ;_BigNum_n_Root
  19. ;_BigNum_Mod
  20. ;_BigNum_Round
  21. ;_BigNum_Compare
  22. ; ===============================================================================================================================
  24. ; #INTERNAL_USE_ONLY#============================================================================================================
  25. ;__BigNum_Swap
  26. ;__BigNum_CheckNegative
  27. ;__BigNum_DivAdd
  28. ;__BigNum_DivComp
  29. ;__BigNum_DivSub
  30. ;__BigNum_Div_DivisorGreater14
  31. ;__BigNum_Div_DivisorMaxLen14
  32. ;__BigNum_InsertDecimalSeparator
  33. ;__BigNum_StringIsDecimal
  34. ;__BigNum_IsValid
  35. ; ===============================================================================================================================
  37. ; #FUNCTION# ;====================================================================================
  38. ; Name...........: _BigNum_Parse
  39. ; Description ...: Parses a line using bigNums
  40. ; Syntax.........: _BigNum_Parse($sLine)
  41. ; Parameters ....: $sLine - e.g. "-1-(2-4*3^(2*5))/(-2.5)"
  42. ; ^ : Power
  43. ; % : Mod
  44. ; / : Div
  45. ; * : Mul
  46. ; + : Add
  47. ; - : Sub
  48. ; Return values .: Success - Result
  49. ; Failure - ?
  50. ; Remarks .......:
  51. ; Author ........: eukalyptus
  52. ; ;===============================================================================================
  54. Func _BigNum_Parse($sLine)
  55. $sLine = StringStripWS($sLine, 8)
  56. $sLine = StringRegExpReplace($sLine, "([\^%/*+-])", "$1#")
  57. Local $aReg = StringRegExp($sLine, "\(([^()]+)\)", 3)
  58. If IsArray($aReg) Then
  59. $sLine = StringRegExpReplace($sLine, "\([^()]+\)", Chr(1))
  60. For $i = 0 To UBound($aReg) - 1
  61. $sLine = StringReplace($sLine, Chr(1), _BigNum_Parse($aReg[$i]), 1)
  62. Next
  63. $sLine = _BigNum_Parse($sLine)
  64. EndIf
  65. Local $aOp[6][2] = [["\^", "_BigNum_Pow"],["%", "_BigNum_Mod"],["/", "_BigNum_Div"],["\*", "_BigNum_Mul"],["\+", "_BigNum_Add"],["-", "_BigNum_Sub"]]
  66. Local $iCnt = 0
  67. While $iCnt < 6
  68. $aReg = StringRegExp($sLine, "(-*[0-9.]+)\#*" & $aOp[$iCnt][0] & "\#*(-*[0-9.]+)", 1)
  69. If IsArray($aReg) Then
  70. $sLine = StringRegExpReplace($sLine, "-*[0-9.]+\#*" & $aOp[$iCnt][0] & "\#*-*[0-9.]+", Call($aOp[$iCnt][1], $aReg[0], $aReg[1]), 1)
  71. Else
  72. $iCnt += 1
  73. EndIf
  74. WEnd
  75. $sLine = StringReplace($sLine, "#", "")
  76. $sLine = StringReplace($sLine, "--", "+")
  77. If StringRegExp($sLine, "^\+[0-9.]+$") Then $sLine = StringReplace($sLine, "+", "")
  78. Return $sLine
  79. EndFunc ;==>_BigNum_Parse
  81. ; #FUNCTION# ;====================================================================================
  82. ;
  83. ; Name...........: _BigNum_Add
  84. ; Description ...: Addition $sX + $sY
  85. ; Syntax.........: _BigNum_Add($sX, $sY)
  86. ; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  87. ; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  88. ; Return values .: Success - Result $sX + $sY
  89. ; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
  90. ; Author ........: Eukalyptus www.autoit.de
  91. ;
  92. ; ;===============================================================================================
  93. Func _BigNum_Add($sX, $sY)
  94. If Not __BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
  95. Local $iNeg = __BigNum_CheckNegative($sX, $sY), $sNeg = ""
  96. Switch $iNeg
  97. Case 3
  98. $sNeg = "-"
  99. Case 1
  100. Return _BigNum_Sub($sY, $sX)
  101. Case 2
  102. Return _BigNum_Sub($sX, $sY)
  103. EndSwitch
  104. Local $iDec = __BigNum_StringIsDecimal($sX, $sY)
  105. Local $iTmp = StringLen($sX), $iLen = StringLen($sY), $iCar = 0, $sRet = ""
  106. If $iLen < $iTmp Then $iLen = $iTmp
  107. For $i = 1 To $iLen Step 18
  108. $iTmp = Int(StringRight($sX, 18)) + Int(StringRight($sY, 18)) + $iCar
  109. $sX = StringTrimRight($sX, 18)
  110. $sY = StringTrimRight($sY, 18)
  111. If ($iTmp > 999999999999999999) Then
  112. $iTmp = StringRight($iTmp, 18)
  113. $sRet = $iTmp & $sRet
  114. $iCar = 1
  115. Else
  116. $iTmp = StringRight("000000000000000000" & $iTmp, 18)
  117. $sRet = $iTmp & $sRet
  118. $iCar = 0
  119. EndIf
  120. Next
  121. $sRet = StringRegExpReplace($iCar & $sRet, "^0+([^0]|0$)", "\1", 1)
  122. If $iDec > 0 Then $sRet = __BigNum_InsertDecimalSeparator($sRet, $iDec, $iDec)
  123. If $sRet = "0" Then $sNeg = ""
  124. Return $sNeg & $sRet
  125. EndFunc ;==>_BigNum_Add
  129. ; #FUNCTION# ;====================================================================================
  130. ;
  131. ; Name...........: _BigNum_Sub
  132. ; Description ...: Subtraction $sX - $sY
  133. ; Syntax.........: _BigNum_Sub($sX, $sY)
  134. ; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  135. ; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  136. ; Return values .: Success - Result $sX - $sY
  137. ; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
  138. ; Author ........: Eukalyptus www.autoit.de
  139. ;
  140. ; ;===============================================================================================
  141. Func _BigNum_Sub($sX, $sY)
  142. If Not __BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
  143. Local $iNeg = __BigNum_CheckNegative($sX, $sY), $bNeg = False
  144. Switch $iNeg
  145. Case 3
  146. Return _BigNum_Add("-" & $sX, $sY)
  147. Case 1
  148. Return "-" & _BigNum_Add($sX, $sY)
  149. Case 2
  150. Return _BigNum_Add($sX, $sY)
  151. EndSwitch
  152. Local $iDec = __BigNum_StringIsDecimal($sX, $sY)
  153. If _BigNum_Compare($sX, $sY) = -1 Then $bNeg = __BigNum_Swap($sX, $sY)
  154. Local $iTmp = StringLen($sX), $iLen = StringLen($sY), $iCar = 0, $sRet = ""
  155. If $iLen < $iTmp Then $iLen = $iTmp
  156. For $i = 1 To $iLen Step 18
  157. $iTmp = Int(StringRight($sX, 18)) - Int(StringRight($sY, 18)) - $iCar
  158. $sX = StringTrimRight($sX, 18)
  159. $sY = StringTrimRight($sY, 18)
  160. If $iTmp < 0 Then
  161. $iTmp = 1000000000000000000 + $iTmp
  162. $iCar = 1
  163. Else
  164. $iCar = 0
  165. EndIf
  166. $sRet = StringRight("0000000000000000000" & $iTmp, 18) & $sRet
  167. Next
  168. $sRet = StringRegExpReplace($iCar & $sRet, "^0+([^0]|0$)", "\1", 1)
  169. If $iDec > 0 Then $sRet = __BigNum_InsertDecimalSeparator($sRet, $iDec, $iDec)
  170. If $bNeg = True And $sRet <> "0" Then
  171. Return "-" & $sRet
  172. Else
  173. Return $sRet
  174. EndIf
  175. EndFunc ;==>_BigNum_Sub
  179. ; #FUNCTION# ;====================================================================================
  180. ;
  181. ; Name...........: _BigNum_Mul
  182. ; Description ...: Multiplication $sX * $sY
  183. ; Syntax.........: _BigNum_Mul($sX, $sY)
  184. ; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  185. ; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  186. ; Return values .: Success - Result $sX * $sY
  187. ; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
  188. ; Author ........: Eukalyptus www.autoit.de
  189. ;
  190. ; ;===============================================================================================
  191. Func _BigNum_Mul($sX, $sY)
  192. If Not __BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
  193. Local $iNeg = __BigNum_CheckNegative($sX, $sY), $sNeg = ""
  194. Local $iDec = __BigNum_StringIsDecimal($sX, $sY)
  195. Local $aX = StringRegExp($sX, '\A.{' & 6 - (Ceiling(StringLen($sX) / 6) * 6 - StringLen($sX)) & '}|.{6}+', 3)
  196. Local $aY = StringRegExp($sY, '\A.{' & 6 - (Ceiling(StringLen($sY) / 6) * 6 - StringLen($sY)) & '}|.{6}+', 3)
  197. Local $aRet[UBound($aX) + UBound($aY) - 1]
  198. For $j = 0 To UBound($aX) - 1
  199. For $i = 0 To UBound($aY) - 1
  200. $aRet[$j + $i] += $aX[$j] * $aY[$i]
  201. Next
  202. Next
  203. Local $sRet = "", $iCar = 0, $iTmp
  204. For $i = UBound($aRet) - 1 To 0 Step -1
  205. $aRet[$i] += $iCar
  206. $iCar = Floor($aRet[$i] / 1000000)
  207. $iTmp = Mod($aRet[$i], 1000000)
  208. If $iTmp <= 1000000 Then $iTmp = StringRight("000000" & $iTmp, 6)
  209. $sRet = $iTmp & $sRet
  210. Next
  211. If $iCar > 0 Then $sRet = $iCar & $sRet
  212. $sRet = StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1)
  213. If ($iNeg = 1 Or $iNeg = 2) And $sRet <> "0" Then $sNeg = "-"
  214. If $iDec > 0 Then $sRet = __BigNum_InsertDecimalSeparator($sRet, $iDec * 2, $iDec * 2)
  215. Return $sNeg & $sRet
  216. EndFunc ;==>_BigNum_Mul
  220. ; #FUNCTION# ;====================================================================================
  221. ;
  222. ; Name...........: _BigNum_Div
  223. ; Description ...: Division $sX / $sY
  224. ; Syntax.........: _BigNum_Div($sX, $sY, [$iD = 0])
  225. ; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  226. ; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  227. ; $iD [optional] - Number of Decimalplaces; if -1 then $iD = StringLen($sX) + StringLen($sY)
  228. ; Return values .: Success - Result $sX / $sY
  229. ; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
  230. ; Author ........: Eukalyptus www.autoit.de
  231. ;
  232. ; ;===============================================================================================
  233. Func _BigNum_Div($sX, $sY, $iD = -1)
  234. If Not __BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
  235. Local $iNeg = __BigNum_CheckNegative($sX, $sY), $sNeg = ""
  236. If $iD = -1 Then $iD = StringLen($sX) + StringLen($sY)
  237. Local $iDec = __BigNum_StringIsDecimal($sX, $sY), $sMod
  238. If $sX = 0 Or $sY = 0 Then Return "0"
  239. If $sY = "1" Then Return $sNeg & $sX
  240. While StringLeft($sX, 1) = "0"
  241. $sX = StringTrimLeft($sX, 1)
  242. $iDec += 1
  243. WEnd
  244. While StringLeft($sY, 1) = "0"
  245. $sY = StringTrimLeft($sY, 1)
  246. $iDec += 1
  247. WEnd
  248. Local $sRet = "", $iLnX = StringLen($sX), $iLnY = StringLen($sY), $iTmp, $iCnt, $sTmp, $iDe1 = 0
  249. If $iD > 0 Then $iDe1 += $iD
  250. If $iNeg = 1 Or $iNeg = 2 Then $sNeg = "-"
  251. $iTmp = _BigNum_Compare($sX, $sY)
  252. If $iTmp = -1 Then
  253. For $iCnt = $iLnX To $iLnY
  254. $sX &= 0
  255. $iDe1 += 1
  256. Next
  257. EndIf
  258. If $iTmp = 0 Then Return $sNeg & "1"
  259. If $iD = -1 Then $iD = $iDec * 2
  260. For $iCnt = 1 To $iD
  261. $sX &= "0"
  262. Next
  263. If $iLnY > 14 Then
  264. $sRet = __BigNum_Div_DivisorGreater14($sX, $sY, $sMod)
  265. Else
  266. $sRet = __BigNum_Div_DivisorMaxLen14($sX, $sY, $sMod)
  267. EndIf
  268. If $iDe1 > 0 Then $sRet = __BigNum_InsertDecimalSeparator($sRet, $iDe1, $iD)
  269. If $sRet = "0" Then
  270. Return "0"
  271. Else
  272. Return $sNeg & $sRet
  273. EndIf
  274. EndFunc ;==>_BigNum_Div
  277. ; #FUNCTION# ;====================================================================================
  278. ;
  279. ; Name...........: _BigNum_Pow
  280. ; Description ...: Exponentiation $n^$e
  281. ; Syntax.........: _BigNum_Pow($n [, $e = 2])
  282. ; Parameters ....: $n - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  283. ; $e [optional] - Exponent (must be a positive 64-bit signed integer)
  284. ; Default: $e = 2 means result = $n²
  285. ; Return values .: Success - Result $n^$e
  286. ; Failure - -1, sets @error to 1 if $n not valid StringNumber
  287. ; -1, sets @error to 2 if $e is not a positive Integer
  288. ; Author ........: jennicoattminusonlinedotde
  289. ; Date ..........: 9.12.09
  290. ; Remarks .......: Fractional exponents not allowed - use BigNum_n_root instead.
  291. ; _BigNum_Pow() offers a drastically better efficiency than looping _BigNum_Mul()
  292. ; Reference .....: http://en.wikipedia.org/wiki/Exponentiation_by_squaring
  293. ; ;===============================================================================================
  294. Func _BigNum_Pow($n, $e = 2)
  295. $e = Number($e)
  296. If IsInt($e) = 0 Or $e < 0 Then Return SetError(2, 0, -1)
  297. ;If $e < -2147483648 Or $e > 2147483647 Then Return SetError(-2, 0, -1)
  298. If Not __BigNum_IsValid($n, $n) Then Return SetError(1, 0, -1)
  300. Local $res = 1
  302. While $e
  303. ;If BitAND($e, 1) Then ; bitoperation is not faster !
  304. If Mod($e, 2) Then
  305. $res = _BigNum_Mul($res, $n)
  306. $e -= 1
  307. EndIf
  308. $n = _BigNum_Mul($n, $n)
  309. ;$e = BitShift($e, 1) ; bitoperation is not faster !
  310. $e /= 2
  311. WEnd
  313. Return $res
  314. EndFunc ;==>_BigNum_Pow
  317. ; #FUNCTION# ;====================================================================================
  318. ;
  319. ; Name...........: _BigNum_SQRT
  320. ; Description ...: Square Root (BigNum)
  321. ; Syntax.........: _BigNum_SQRT($n [, $p = -1])
  322. ; Parameters ....: $n - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  323. ; $p [optional] - Precision (Number of Decimalplaces) (must be positive Integer)
  324. ; Default: $p = -1 means automatic precision (stringlen of integer part of $n)
  325. ; Return values .: Success - Result SQRT($n)
  326. ; @extended = Precicion of result (if $p set to automatic precision)
  327. ; @error = Number of Iterations
  328. ; Failure - -1, sets @error to -1 if $n not valid StringNumber
  329. ; -1, sets @error to -2 if $p is out of valid range
  330. ; -1, sets @error to -3 if time-out (>100 iterations)
  331. ; Author ........: jennicoattminusonlinedotde
  332. ; Date ..........: 8.12.09
  333. ; Remarks .......: use Precision param when u want to obtain the square root of a small number with the desired decimal places.
  334. ; References ....: http://www.merriampark.com/bigsqrt.htm
  335. ; "Newton's Method" - before: Heron of Alexandria
  336. ; ;===============================================================================================
  337. Func _BigNum_SQRT($n, $p = -1)
  338. If Not __BigNum_IsValid($n, $n) Then Return SetError(-1, 0, -1)
  339. $p = Number($p)
  340. If IsInt($p) = 0 Or $p < -1 Then Return SetError(-2, 0, -1)
  341. Local $l = StringInStr($n, ".") - 1
  342. If $l = -1 Then $l = StringLen($n)
  343. If $p < 0 Then $p = $l
  344. Local $g = 1, $last
  346. For $i = 3 To $l Step 2
  347. $g = _BigNum_Mul($g, 10)
  348. Next
  350. For $i = 1 To 100
  351. $last = $g
  352. $g = _BigNum_Div(_BigNum_Add(_BigNum_Div($n, $g, $p), $g), 2, $p)
  353. If $last = $g Then Return SetError($i, $p, $g)
  354. Next
  355. Return SetError(-3, 0, -1)
  356. EndFunc ;==>_BigNum_SQRT
  360. ; #FUNCTION# ;====================================================================================
  361. ;
  362. ; Name...........: _BigNum_n_Root
  363. ; Description ...: $e-th Root of $n
  364. ; Syntax.........: _n_Root($n [, $e=2])
  365. ; Parameters ....: $n - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  366. ; $e - [optional] Multiplicity of root (power, exponent) (must be a positive 64-bit signed integer > 0)
  367. ; Default: $e = 2 (=SQRT)
  368. ; $p - [optional] Precision (Number of desired Decimalplaces) (must be positive Integer)
  369. ; Default: $p = -1 means automatic precision (stringlen of integer part of $n)
  370. ; Return values .: Success - Result $e-root($n)
  371. ; @extended = Number of Iterations
  372. ; Failure - -1 and sets @error to 1 if $n not valid StringNumber
  373. ; -1 and sets @error to 2 if $e out of valid range
  374. ; -1 and sets @error to 3 if $p out of valid range
  375. ; Author ........: jennicoattminusonlinedotde
  376. ; Date ..........: 9.12.09
  377. ; References ....: derived from "Newton's Method"
  378. ; ;===============================================================================================
  379. Func _BigNum_n_Root($n, $e = 2, $p = -1)
  380. If Not __BigNum_IsValid($n, $n) Then Return SetError(1, 0, -1)
  381. $e = Number($e)
  382. If IsInt($e) = 0 Or $e < 1 Then Return SetError(2, 0, -1)
  383. $p = Number($p)
  384. If IsInt($p) = 0 Or $p < -1 Then Return SetError(3, 0, -1)
  386. Local $l = StringInStr($n, ".") - 1
  387. If $l = -1 Then $l = StringLen($n)
  388. If $p < 0 Then $p = $l
  389. Local $g = 1, $last, $i = 0
  391. For $i = 3 To $l Step 2
  392. $g = _BigNum_Mul($g, 10)
  393. Next
  395. While 1
  396. $i += 1
  397. $last = $g
  398. $g = _BigNum_Div(_BigNum_Add(_BigNum_Div($n, _BigNum_Pow($g, $e - 1), $p), _BigNum_Mul($g, $e - 1)), $e, $p)
  399. If $last = $g Then Return SetExtended($i, $g)
  400. WEnd
  401. EndFunc ;==>_BigNum_n_Root
  405. ; #FUNCTION# ;====================================================================================
  406. ;
  407. ; Name...........: _BigNum_Mod
  408. ; Description ...: Modulo Mod($sX, $sY)
  409. ; Syntax.........: _BigNum_Mod($sX, $sY)
  410. ; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  411. ; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  412. ; Return values .: Success - Result Mod($sX, $sY)
  413. ; Failure - 0, sets @error to 1 if $sX/$sY not valid StringNumber
  414. ; Author ........: Eukalyptus www.autoit.de
  415. ;
  416. ; ;===============================================================================================
  417. Func _BigNum_Mod($sX, $sY)
  418. If Not __BigNum_IsValid($sX, $sY) Then Return SetError(1, 0, 0)
  419. If $sY = 0 Or $sY = 1 Then Return "0"
  420. Local $sRes = $sX
  421. Local $iNeg = __BigNum_CheckNegative($sX, $sY)
  422. Local $iDec = __BigNum_StringIsDecimal($sX, $sY)
  423. If _BigNum_Compare($sX, $sY) < 0 Then Return $sRes
  424. Local $sRet = "", $iLnX = StringLen($sX), $iLnY = StringLen($sY)
  425. If $iLnY > 14 Then
  426. __BigNum_Div_DivisorGreater14($sX, $sY, $sRet)
  427. Else
  428. __BigNum_Div_DivisorMaxLen14($sX, $sY, $sRet)
  429. EndIf
  430. $sRet = __BigNum_InsertDecimalSeparator($sRet, $iDec, StringLen($sRet))
  431. If ($iNeg = 3 Or $iNeg = 1) And $sRet <> "0" Then $sRet = "-" & $sRet
  432. Return $sRet
  433. EndFunc ;==>_BigNum_Mod
  437. ; #FUNCTION# ;====================================================================================
  438. ;
  439. ; Name...........: _BigNum_Round
  440. ; Description ...: Round $sX to $iD Decimalplaces
  441. ; Syntax.........: _BigNum_Round($sX, $iD)
  442. ; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  443. ; $iD - Number of Decimalplaces
  444. ; Return values .: Success - Result Round($sX, $iD)
  445. ; Failure - 0, sets @error to 1 if $sX not valid StringNumber
  446. ; Author ........: Eukalyptus www.autoit.de
  447. ;
  448. ; ;===============================================================================================
  449. Func _BigNum_Round($sX, $iD)
  450. If Not __BigNum_IsValid($sX, $sX) Then Return SetError(1, 0, 0)
  451. Local $sTmp = 0, $sRet, $sRes = $sX
  452. Local $iNeg = __BigNum_CheckNegative($sX, $sTmp)
  453. Local $iDec = __BigNum_StringIsDecimal($sX, $sTmp)
  454. If $iD > $iDec Or $iDec = 0 Then Return $sRes
  455. $sTmp = StringLeft(StringRight($sX, $iDec - $iD), 1)
  456. $sRet = StringTrimRight($sRes, $iDec - $iD)
  457. If $sTmp >= 5 And $iD > 0 Then
  458. If $iNeg = 1 Then
  459. $sRet = _BigNum_Add($sRet, "-0." & StringFormat("%0" & String($iD) & "u", "1"))
  460. Else
  461. $sRet = _BigNum_Add($sRet, "0." & StringFormat("%0" & String($iD) & "u", "1"))
  462. EndIf
  463. ElseIf $sTmp >= 5 And $iD = 0 Then
  464. If $iNeg = 1 Then
  465. $sRet = _BigNum_Add($sRet, "-1")
  466. Else
  467. $sRet = _BigNum_Add($sRet, "1")
  468. EndIf
  469. Else
  470. If StringRight($sRet, 1) = "." Then $sRet = StringTrimRight($sRet, 1)
  471. EndIf
  472. Return $sRet
  473. EndFunc ;==>_BigNum_Round
  477. ; #FUNCTION# ;====================================================================================
  478. ;
  479. ; Name...........: _BigNum_Compare
  480. ; Description ...: Compares $sX $sY
  481. ; Syntax.........: _BigNum_Compare($sX, $sY)
  482. ; Parameters ....: $sX - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  483. ; $sY - StringNumber: Minus"-" Digits"0"..."9" Separator"." ("-1234567890.12345")
  484. ; Return values .: Success - Return:
  485. ; |0 - $sX and $sY are equal
  486. ; |1 - $sX is greater than $sY
  487. ; |-1 - $sX is less than $sY
  488. ; Failure - sets @error to 1 if $sX/$sY not valid StringNumber
  489. ; Author ........: eXirrah
  490. ;
  491. ; ;===============================================================================================
  492. Func _BigNum_Compare($sX, $sY) ;Algorithm No.2
  493. Local $iNeg = __BigNum_CheckNegative($sX, $sY)
  494. Switch $iNeg
  495. Case 1 ; sX = negative
  496. Return -1
  497. Case 2 ; sY = negative
  498. Return 1
  499. Case 3 ; both negative
  500. __BigNum_Swap($sX, $sY)
  501. EndSwitch
  502. __BigNum_CompEqualizeLength($sX, $sY)
  503. Return StringCompare($sX, $sY)
  504. EndFunc ;==>_BigNum_Compare
  510. ; #INTERNAL_USE_ONLY#============================================================================================================
  514. #Region Internal Functions
  516. Func __BigNum_CompEqualizeLength(ByRef $sX, ByRef $sY)
  517. Local $iXDotPos = StringInStr($sX, ".")
  518. Local $iYDotPos = StringInStr($sY, ".")
  519. Local $iXLen = StringLen($sX)
  520. Local $iYLen = StringLen($sY)
  521. Local $iLeading, $iTrailing
  522. ;Calculation leading and trailing zeroes
  523. If $iXDotPos == 0 And $iYDotPos <> 0 Then
  524. $iLeading = $iXLen - ($iYDotPos - 1)
  525. $iTrailing = -1 * ($iYLen - $iYDotPos)
  526. $sX &= "."
  527. ElseIf $iXDotPos <> 0 And $iYDotPos == 0 Then
  528. $iLeading = ($iXDotPos - 1) - $iYLen
  529. $iTrailing = $iXLen - $iXDotPos
  530. $sY &= "."
  531. ElseIf $iXDotPos == 0 And $iYDotPos == 0 Then
  532. $iLeading = $iXLen - $iYLen
  533. Else
  534. $iLeading = $iXDotPos - $iYDotPos
  535. $iTrailing = ($iXLen - $iXDotPos) - ($iYLen - $iYDotPos)
  536. EndIf
  537. ;adding leading and trailing zeroes
  538. If $iLeading < 0 Then
  539. $sX = __BigNum_CompStringAddZeroes($sX, -1 * $iLeading, 0, 0)
  540. ElseIf $iLeading > 0 Then
  541. $sY = __BigNum_CompStringAddZeroes($sY, $iLeading, 0, 0)
  542. EndIf
  543. If $iTrailing < 0 Then
  544. $sX = __BigNum_CompStringAddZeroes($sX, -1 * $iTrailing, 1, 0)
  545. ElseIf $iTrailing > 0 Then
  546. $sY = __BigNum_CompStringAddZeroes($sY, $iTrailing, 1, 0)
  547. EndIf
  548. EndFunc ;==>__BigNum_CompEqualizeLength
  550. Func __BigNum_CompStringAddZeroes($sString, $iCount, $bTrailing = 0, $bToLength = 1)
  551. ;$bToLength is set when the user wants to add the nescessary amount
  552. ;of zeroes to the string so it is with length $iCount (Default)
  553. If $bToLength Then
  554. $iCount -= StringLen($sString)
  555. EndIf
  556. Local $i = 0
  557. Local $s = ""
  558. While $i < $iCount
  559. $s &= "0"
  560. $i += 1
  561. WEnd
  562. ;$bTrailing is set when the user wants the zeroes to be added at the
  563. ;right side of the string. By defaut zeroes are added at the left side of the string
  564. If $bTrailing Then
  565. Return $sString & $s
  566. EndIf
  567. Return $s & $sString
  568. EndFunc ;==>__BigNum_CompStringAddZeroes
  571. Func __BigNum_Swap(ByRef $sX, ByRef $sY)
  572. Local $sSwap = $sX
  573. $sX = $sY
  574. $sY = $sSwap
  575. Return True
  576. EndFunc ;==>__BigNum_Swap
  578. Func __BigNum_Div_DivisorGreater14($sX, $sY, ByRef $sM)
  579. $sM = "0"
  580. If $sY = "1" Then Return $sX
  581. If $sX = "0" Or $sY = "0" Or $sX = "" Or $sY = "" Then Return "0"
  583. Local $iLnY = StringLen($sY), $bRed = False
  584. Local $sRet = "", $sRem = StringLeft($sX, $iLnY), $sTmp = "", $sTm2 = "", $iCnt, $iLen = 1
  585. $sX = StringTrimLeft($sX, $iLnY)
  586. Do
  587. If __BigNum_DivComp($sRem, $sY) = -1 Then
  588. $sTmp = StringLeft($sX, 1)
  589. $sRem &= $sTmp
  590. $sX = StringTrimLeft($sX, 1)
  591. If StringLen($sTmp) > 0 Then $iLen += 1
  592. EndIf
  593. $sTmp = $sY
  594. $sTm2 = "0"
  595. If __BigNum_DivComp($sRem, $sY) >= 0 Then
  596. For $iCnt = 1 To 9
  597. $sTm2 = $sTmp
  598. $sTmp = __BigNum_DivAdd($sTmp, $sY)
  599. If __BigNum_DivComp($sRem, $sTmp) < 0 Then ExitLoop
  600. Next
  601. Else
  602. $iCnt = 0
  603. EndIf
  605. If StringLen($sX) = 0 Then $bRed = True
  606. $sM = $sRem
  607. $sRem = __BigNum_DivSub($sRem, $sTm2)
  608. If $iCnt > 0 Then $sM = $sRem
  609. $sRet &= StringFormat("%0" & String($iLen) & "u", $iCnt)
  610. $iTrm = $iLnY - StringLen($sRem)
  611. $sTmp = StringLeft($sX, $iTrm)
  612. $sX = StringTrimLeft($sX, $iTrm)
  613. $iLen = StringLen($sTmp)
  614. $sRem &= $sTmp
  615. Until $bRed
  616. $sM = StringRegExpReplace($sM, "^0+([^0]|0$)", "\1", 1)
  618. Return StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1)
  619. EndFunc ;==>__BigNum_Div_DivisorGreater14
  621. Func __BigNum_Div_DivisorMaxLen14($sX, $sY, ByRef $sM)
  622. $sM = "0"
  623. If $sY = "1" Then Return $sX
  624. If $sX = "0" Or $sY = "0" Or $sX = "" Or $sY = "" Then Return "0"
  626. Local $sRet = "", $iRem = StringLeft($sX, 15), $iTmp = 0, $iTrm = 6, $iLen
  627. $sX = StringTrimLeft($sX, 15)
  628. $iTmp = Floor($iRem / $sY)
  629. $sRet &= $iTmp
  631. $iRem -= $iTmp * $sY
  632. While StringLen($sX) > 0
  633. $iTrm = 15 - StringLen($iRem)
  634. $iTmp = StringLeft($sX, $iTrm)
  635. $iLen = StringLen($iTmp)
  636. $iRem &= $iTmp
  637. $sX = StringTrimLeft($sX, $iTrm)
  638. $iTmp = Floor($iRem / $sY)
  639. $iTmp = StringRight("000000000000000" & $iTmp, $iLen)
  641. $sRet &= $iTmp
  642. $iRem -= $iTmp * $sY
  643. WEnd
  644. $sM = String($iRem)
  646. Return StringRegExpReplace($sRet, "^0+([^0]|0$)", "\1", 1)
  647. EndFunc ;==>__BigNum_Div_DivisorMaxLen14
  649. Func __BigNum_DivComp($sX, $sY)
  650. $sX = StringRegExpReplace($sX, "^0+([^0]|0$)", "\1", 1)
  651. $sY = StringRegExpReplace($sY, "^0+([^0]|0$)", "\1", 1)
  652. Local $iLnX = StringLen($sX), $iLnY = StringLen($sY)
  653. If $iLnX < $iLnY Then
  654. Return -1
  655. ElseIf $iLnX > $iLnY Then
  656. Return 1
  657. Else
  658. If $sX < $sY Then
  659. Return -1
  660. ElseIf $sX > $sY Then
  661. Return 1
  662. Else
  663. Return 0
  664. EndIf
  665. EndIf
  666. EndFunc ;==>__BigNum_DivComp
  668. Func __BigNum_DivAdd($sX, $sY)
  669. Local $iTmp = StringLen($sX), $iLen = StringLen($sY), $iCar = 0, $sRet = ""
  670. If $iLen < $iTmp Then $iLen = $iTmp
  671. For $i = 1 To $iLen Step 18
  672. $iTmp = Int(StringRight($sX, 18)) + Int(StringRight($sY, 18)) + $iCar
  673. $sX = StringTrimRight($sX, 18)
  674. $sY = StringTrimRight($sY, 18)
  675. If ($iTmp > 999999999999999999) Then
  676. $sRet = StringRight($iTmp, 18) & $sRet
  677. $iCar = 1
  678. Else
  679. $iTmp = StringRight("000000000000000000" & $iTmp, 18)
  680. $sRet = $iTmp & $sRet
  681. $iCar = 0
  682. EndIf
  683. Next
  684. $sRet = StringRegExpReplace($iCar & $sRet, "^0+([^0]|0$)", "\1", 1)
  685. Return $sRet
  686. EndFunc ;==>__BigNum_DivAdd
  688. Func __BigNum_DivSub($sX, $sY)
  689. Local $iTmp = StringLen($sX), $iLen = StringLen($sY), $iCar = 0, $sRet = ""
  690. If $iLen < $iTmp Then $iLen = $iTmp
  691. For $i = 1 To $iLen Step 18
  692. $iTmp = Int(StringRight($sX, 18)) - Int(StringRight($sY, 18)) - $iCar
  693. $sX = StringTrimRight($sX, 18)
  694. $sY = StringTrimRight($sY, 18)
  695. If $iTmp < 0 Then
  696. $iTmp = 1000000000000000000 + $iTmp
  697. $iCar = 1
  698. Else
  699. $iCar = 0
  700. EndIf
  701. $sRet = StringRight("0000000000000000000" & $iTmp, 18) & $sRet
  702. Next
  703. $sRet = StringRegExpReplace($iCar & $sRet, "^0+([^0]|0$)", "\1", 1)
  704. Return $sRet
  705. EndFunc ;==>__BigNum_DivSub
  707. Func __BigNum_IsValid($sX, $sY)
  708. If StringRegExp($sX, "[^0-9.-]") Or StringRegExp($sY, "[^0-9.-]") Then Return False
  709. Return True
  710. EndFunc ;==>__BigNum_IsValid
  712. Func __BigNum_InsertDecimalSeparator($sX, $iDec, $iD = 18)
  713. If $iD = 0 And $iDec = 0 Then Return $sX
  714. Local $sRet = StringRegExpReplace(StringRight(StringFormat("%0" & String($iDec) & "u", "") & $sX, $iDec), "0+$", "\1", 1)
  715. $sX = StringTrimRight($sX, $iDec)
  716. If $sX = "" Then $sX = "0"
  717. $sRet = StringLeft($sRet, $iD)
  718. If $sRet = "" Or $sRet = "0" Then Return $sX
  719. Return $sX & "." & $sRet
  720. EndFunc ;==>__BigNum_InsertDecimalSeparator
  722. Func __BigNum_StringIsDecimal(ByRef $sX, ByRef $sY)
  723. If StringLeft($sX, 1) = "." Then $sX = "0" & $sX
  724. If StringLeft($sY, 1) = "." Then $sY = "0" & $sY
  725. Local $iPsX = StringInStr($sX, ".", 0, 1) - 1, $iPsY = StringInStr($sY, ".", 0, 1) - 1
  726. $sX = StringRegExpReplace($sX, "\D", "")
  727. $sY = StringRegExpReplace($sY, "\D", "")
  728. Local $iLnX = StringLen($sX), $iLnY = StringLen($sY)
  729. If $iPsX <= 0 Then $iPsX = $iLnX
  730. If $iPsY <= 0 Then $iPsY = $iLnY
  731. If $iLnX - $iPsX > $iLnY - $iPsY Then
  732. For $iCnt = $iLnY - $iPsY To $iLnX - $iPsX - 1
  733. $sY &= "0"
  734. Next
  735. Return $iLnX - $iPsX
  736. ElseIf $iLnX - $iPsX < $iLnY - $iPsY Then
  737. For $iCnt = $iLnX - $iPsX To $iLnY - $iPsY - 1
  738. $sX &= "0"
  739. Next
  740. Return $iLnY - $iPsY
  741. EndIf
  742. Return $iLnX - $iPsX
  743. EndFunc ;==>__BigNum_StringIsDecimal
  745. Func __BigNum_CheckNegative(ByRef $sX, ByRef $sY)
  746. Local $bNgX = False, $bNgY = False
  747. While StringLeft($sX, 1) = "-"
  748. $bNgX = Not $bNgX
  749. $sX = StringTrimLeft($sX, 1)
  750. WEnd
  751. While StringLeft($sY, 1) = "-"
  752. $bNgY = Not $bNgY
  753. $sY = StringTrimLeft($sY, 1)
  754. WEnd
  755. $sX = StringRegExpReplace($sX, "^0+([^0]|0$)", "\1", 1)
  756. $sY = StringRegExpReplace($sY, "^0+([^0]|0$)", "\1", 1)
  757. If $sX = "" Then $sX = "0"
  758. If $sY = "" Then $sY = "0"
  759. If $bNgX = True And $bNgY = True Then
  760. Return 3
  761. ElseIf $bNgX = True And $bNgY = False Then
  762. Return 1
  763. ElseIf $bNgX = False And $bNgY = True Then
  764. Return 2
  765. Else
  766. Return 0
  767. EndIf
  768. EndFunc ;==>__BigNum_CheckNegative
  769. #EndRegion Internal Functions
comments powered by Disqus