Jump to content
Sign in to follow this  
czardas

Whole Number Division

Recommended Posts

czardas

I have hardly any time to write any code recently. Even so, one of the most frustrating problems I, and others like myself, encounter is corruption from floating point innacuracies and integer overflow. I haven't had much time to test this, but the given example works. The method to fix division with whole numbers does not appear to be as complicated as I first anticipated. Divisible integers only!

Func _WholeNumberDivision($iDividend, $iDivisor) ; Input ranges -9223372036854775807 To 9223372036854775807
    If Not (IsInt($iDividend) And IsInt($iDivisor)) Then Return SetError(1, 0, $iDividend / $iDivisor) ; integers only
    If $iDivisor = 0 Then Return SetError(2, 0, $iDividend / $iDivisor) ; division by zero

    Local $aDiv = [$iDividend, $iDivisor], _
    $iSign = 1

    For $i = 0 To 1
        If $aDiv[$i] > 0x7FFFFFFFFFFFFFFF Or $aDiv[$i] < 0x8000000000000001 Then Return SetError(3, 0, $iDividend / $iDivisor) ; input range exceeded
        If VarGetType($aDiv[$i]) = "Double" Then $aDiv[$i] = Number($aDiv[$i], 2) ; convert to Int-64

        If $aDiv[$i] < 0 Then ; force positive integers
            $aDiv[$i] *= -1
            $iSign *= -1 ; to add back later
        EndIf
    Next

    If Mod($aDiv[0], $aDiv[1]) Then Return SetError(4, 0, $iDividend / $iDivisor) ; not divisible
    If $aDiv[0] = 0 Then Return 0
    If $aDiv[1] = 1 Then Return $aDiv[0] * $iSign

    Local $iDivision = Floor($aDiv[0] / $aDiv[1]), $iDifference, $iIntegral

    While $iDivision * $aDiv[1] > $aDiv[0] ; division is overstated
        $iDifference = ($aDiv[1] * $iDivision) - $aDiv[0]
        $iIntegral = Floor($iDifference / $aDiv[1]) ; avoid shooting beyond the target
        If $iIntegral = 0 Then $iIntegral = 1 ; prevents hanging in an infinite loop
        $iDivision -= $iIntegral
    WEnd

    While $iDivision * $aDiv[1] < $aDiv[0] ; division is understated
        $iDifference = $aDiv[0] - ($aDiv[1] * $iDivision)
        $iIntegral = Floor($iDifference / $aDiv[1])
        If $iIntegral = 0 Then $iIntegral = 1 ; prevents hanging
        $iDivision += $iIntegral
    WEnd

    Return $iDivision * $iSign
EndFunc

This function currently works with all int-64 values with one exception - the lowest value 0x8000000000000000, and that's only divisible by powers of 2 anyway. :guitar:

Edited by czardas
  • Like 1

Share this post


Link to post
Share on other sites
czardas

Perhaps I ought to have waited a little while before posting the above function, but I saw fit to post a solution to a rather messy problem as proof of concept. The function may be limited to divisible integers right now, and that's mostly how I intend to use it - particularly with the next implementation of my Fraction UDF. The absence of error return values is both temporary and superfluous. There is still a lot I don't understand about floating point maths, however I don't feel so bad about the fact because I know I'm not alone in this. It seems to me that even 'experts' make apparently contradictory statements regarding some of the finer details of double precision floating point arithmetic. One thing you can say for certain is that it is pretty darn fast! :poke:

It's probably going to take me a while to progress the way things are right now: I simply have too many commitments. For this reason I intend to post related snippets as and when they are created - but only if I think they might be useful to someone else. The following function grabs the first 16 (rounded) digits from a float. The 17th digit is unreliable. The sixteenth digit may become unreliable after a mathematical operation - at least I believe this is the case. The extended value must be accessed (immediately): to preserve information about the numeric order of magnitude.
 

Local $fValue = (1.025) ; Try inputting some different floats.
Local $sMachineValue = StringFormat('%.16e', $fValue)
Local $iDigits = _FloatToDigits($fValue)
Local $iExponent = @extended
MsgBox(0, 'Value => ' & $fValue, _
    'Machine Value' & @TAB & $sMachineValue & @LF & _
    'Extracted Digits' & @TAB & $iDigits & " * 10^" & $iExponent)

; Returns a 32-bit or 64-bit signed integer. Sets @extended to the decimal exponent (float = int * 10 ^ exponent).
Func _FloatToDigits($fFloat)
    If VarGetType($fFloat) <> 'Double' Or StringInStr($fFloat, '#') Then Return SetError(1)
    Local $iSign = ($fFloat < 0) ? -1 : 1, $iDigits = 15 ; machine epsilon = 5 × 10^-15
    $fFloat = StringFormat('%.' & $iDigits & 'e', $fFloat) ; rounds to 15 decimal places

    Local $aFloat = StringSplit($fFloat, "e", 2) ; zero-based array
    If $iSign < 0 Then $aFloat[0] = StringTrimLeft($aFloat[0], 1) ; Remove the minus sign.

    $aFloat[0] = StringLeft($aFloat[0], 1) & StringRegExpReplace(StringRight($aFloat[0], $iDigits), '(0+\z)', '') ; Remove the decimal point and trailing zeros.
    $aFloat[1] += 1 - StringLen($aFloat[0]) ; Adjust the exponent to accommodate changes.

    Return SetExtended($aFloat[1], Int($aFloat[0]) * $iSign) ; Add back the minus sign.
EndFunc

 

Edited by czardas

Share this post


Link to post
Share on other sites
czardas

A bug has been discovered, affecting the function _WholeNumberDivision(), which caused division by 1 to return incorrect results. A patch has been added. After looking again at this, for a moment, I wondered why I had excluded the input value 0x8000000000000000. If anyone else wondered about this, here is the answer: you cannot change the sign of that number without invoking integer overflow. Error return values may also be added to this function at some point in the future.

Testing reveals further serious bugs. Pity I had no time to test this until now.

Edited by czardas

Share this post


Link to post
Share on other sites
czardas

This was not working at all: apart from the few tests I did at the time I wrote this function. It seems to be working now, after several failed attempts to fix it. I've only run a few tests so far and I'm not sure it is entirely reliable, although I know why it was failing before making these changes. :)

Global $g_Dividend = 0, $g_Divisor = 1

Local $aExamples = [ _
    [9223372036854775807, 7], _
    [9223372036854775552, 2], _
    [9999997800000121, 99999989], _
    [99999999999999990, 5], _
    [9223372036854775552, 4611686018427387776], _
    [99999999999999999, 1], _
    [6, 2] _
    ]

For $i = 0 To UBound($aExamples) -1
    ConsoleWrite( _ ; Internal AutoIt division
        $aExamples[$i][$g_Dividend] & " / " & $aExamples[$i][$g_Divisor] & " = " & _
        Number($aExamples[$i][$g_Dividend] / $aExamples[$i][$g_Divisor], 2) & _
    @LF & _ ; _WholeNumberDivision()
        $aExamples[$i][$g_Dividend] & " / " & $aExamples[$i][$g_Divisor] & " = " & _
        _WholeNumberDivision($aExamples[$i][$g_Dividend], $aExamples[$i][$g_Divisor]) & _
    @LF & @LF)
Next

#cs
9223372036854775807 / 7 = 1317624576693539329
9223372036854775807 / 7 = 1317624576693539401

9223372036854775552 / 2 = 4611686018427387905
9223372036854775552 / 2 = 4611686018427387776

9999997800000121 / 99999989 = 99999989
9999997800000121 / 99999989 = 99999989

99999999999999990 / 5 = 19999999999999997
99999999999999990 / 5 = 19999999999999998

9223372036854775552 / 4611686018427387776 = 2
9223372036854775552 / 4611686018427387776 = 2

99999999999999999 / 1 = 100000000000000001
99999999999999999 / 1 = 99999999999999999

6 / 2 = 3
6 / 2 = 3
#ce
Edited by czardas

Share this post


Link to post
Share on other sites
czardas

I have been going about this the wrong way: almost randomly testing methods every time I found a new bug. All I needed was a couple of hours sleep, after which the solution turns out to be really very simple - I ought to kick myself. I decided to return the floats generated by division when errors occur. I contemplated forcing an integer error return value in such cases but couldn't see any advantage in doing so.

The range test below has not revealed any bugs and should not throw any errors. The start (and range) values can be modifed, and timers added if you were curious enough.

Local $iStart1 = 1317624639329, _
      $iRange1 = 500, _
      $iStart2 = 101, _
      $iRange2 = 500

Local $iProduct, $iDiv, $iErrors = 0, $iBugs = 0

For $i = $iStart1 To $iStart1 + $iRange1
    For $j = $iStart2 To $iStart2 + $iRange2
        $iProduct = $i * $j

        ; Test 1
        $iDiv = _WholeNumberDivision($iProduct, $i)
        If @error Then
            ConsoleWrite($iProduct & " / " & $i & " ERROR " & @error & @LF)
            $iErrors += 1
        ElseIf $iDiv * $i <> $iProduct Then
            ConsoleWrite($iProduct & " / " & $i & " BUG FOUND" & @LF)
            $iBugs += 1
        EndIf

        ; Test 2
        $iDiv = _WholeNumberDivision($iProduct, $j)
        If @error Then
            ConsoleWrite($iProduct & " / " & $j & " ERROR " & @error & @LF)
            $iErrors += 1
        ElseIf $iDiv * $j <> $iProduct Then
            ConsoleWrite($iProduct & " / " & $j & " BUG FOUND" & @LF)
            $iBugs += 1
        EndIf
    Next
Next

MsgBox(0, "Range Analysis", "Encountered errors : " & $iErrors & @LF & _
                            "Bugs found : " & $iBugs)


Func _WholeNumberDivision($iDividend, $iDivisor) ; Input ranges -9223372036854775807 To 9223372036854775807
    If Not (IsInt($iDividend) And IsInt($iDivisor)) Then Return SetError(1, 0, $iDividend / $iDivisor) ; integers only
    If $iDivisor = 0 Then Return SetError(2, 0, $iDividend / $iDivisor) ; division by zero

    Local $aDiv = [$iDividend, $iDivisor], _
    $iSign = 1

    For $i = 0 To 1
        If $aDiv[$i] > 0x7FFFFFFFFFFFFFFF Or $aDiv[$i] < 0x8000000000000001 Then Return SetError(3, 0, $iDividend / $iDivisor) ; input range exceeded
        If VarGetType($aDiv[$i]) = "Double" Then $aDiv[$i] = Number($aDiv[$i], 2) ; convert to Int-64

        If $aDiv[$i] < 0 Then ; force positive integers
            $aDiv[$i] *= -1
            $iSign *= -1 ; to add back later
        EndIf
    Next

    If Mod($aDiv[0], $aDiv[1]) Then Return SetError(4, 0, $iDividend / $iDivisor) ; not divisible
    If $aDiv[0] = 0 Then Return 0
    If $aDiv[1] = 1 Then Return $aDiv[0] * $iSign

    Local $iDivision = Floor($aDiv[0] / $aDiv[1]), $iDifference, $iIntegral

    While $iDivision * $aDiv[1] > $aDiv[0] ; division is overstated
        $iDifference = ($aDiv[1] * $iDivision) - $aDiv[0]
        $iIntegral = Floor($iDifference / $aDiv[1]) ; avoid shooting beyond the target
        If $iIntegral = 0 Then $iIntegral = 1 ; prevents hanging in an infinite loop
        $iDivision -= $iIntegral
    WEnd

    While $iDivision * $aDiv[1] < $aDiv[0] ; division is understated
        $iDifference = $aDiv[0] - ($aDiv[1] * $iDivision)
        $iIntegral = Floor($iDifference / $aDiv[1])
        If $iIntegral = 0 Then $iIntegral = 1 ; prevents hanging
        $iDivision += $iIntegral
    WEnd

    Return $iDivision * $iSign
EndFunc

Now the real work can begin. :D

Edit
Now that this is actually working, further tests reveal the extent of the problems presented by floating point division in extreme fringe cases. While the inaccuracies do not make a great deal of difference in terms of comparative ratios, they make a very real and significant difference if you want to calculate the trajectory of a deep space probe or, in my case, simplify fractions correctly. Accumilative errors are totally unacceptable in these situations. As has often been said; AutoIt is not necessarily the best choice to use for every project, but the accuracy of a fraction comprising two signed 64-bit integers will leave double precision floats flailing around in the mud. I'm not refering to speed: but rather to extremely accurate calibration within a significant numeric range. There can clearly be no comparison, by any stretch of the imagination.
 

Local $iStart1 = 4500000000000000001, _
      $iRange1 = 1000, _
      $iStart2 = 2, _
      $iRange2 = 0

Local $iProduct, $iDiv, $iErrors = 0, $iBugs = 0

For $i = $iStart1 To $iStart1 + $iRange1 Step 10
    For $j = $iStart2 To $iStart2 + $iRange2
        $iProduct = $i * $j

        $iDiv = _WholeNumberDivision($iProduct, $j)
        If @error Then
            ConsoleWrite($iProduct & " / " & $j & " ERROR " & @error & @LF)
            $iErrors += 1
        ElseIf $iDiv * $j <> $iProduct Then
            ConsoleWrite($iProduct & " / " & $j & " BUG FOUND" & @LF)
            $iBugs += 1
        ElseIf $iDiv <> Int($iProduct / $j) Then
            ConsoleWrite($iProduct & " / " & $j & @LF & Int($iProduct / $j) & " wrong" & @LF & $iDiv & " correct" & @LF & @LF)
        EndIf
    Next
Next

MsgBox(0, "Range Analysis", "Encountered errors : " & $iErrors & @LF & _
                            "Bugs found : " & $iBugs)


Sample Results:

9000000000000000502 / 2
4500000000000000001 wrong
4500000000000000251 correct

9000000000000001382 / 2
4500000000000000513 wrong
4500000000000000691 correct

9000000000000001402 / 2
4500000000000000513 wrong
4500000000000000701 correct

9000000000000001422 / 2
4500000000000000513 wrong
4500000000000000711 correct

9000000000000001442 / 2
4500000000000000513 wrong
4500000000000000721 correct

9000000000000001462 / 2
4500000000000000513 wrong
4500000000000000731 correct

9000000000000001482 / 2
4500000000000000513 wrong
4500000000000000741 correct

9000000000000001502 / 2
4500000000000000513 wrong
4500000000000000751 correct

9000000000000001522 / 2
4500000000000000513 wrong
4500000000000000761 correct

9000000000000001542 / 2
4500000000000001025 wrong
4500000000000000771 correct

9000000000000001562 / 2
4500000000000001025 wrong
4500000000000000781 correct

9000000000000001582 / 2
4500000000000001025 wrong
4500000000000000791 correct

It's good to be back. :thumbsup:

Edited by czardas

Share this post


Link to post
Share on other sites
czardas

Another related function - the next on my list - is detecting integer overflow occurring with addition, subtraction or multiplication. I wasn't quite sure how to approach this problem, but came up with the idea of using doubles to test for proximity: doubles are not accurate enough to make an exact comparison but that should not be necessary.

; test for overflow with the expression ==> 0x7FFFFFFFFFFFFFFF + 1
MsgBox(0, "", _OverflowDetect("+", 0x7FFFFFFFFFFFFFFF, 1))

Func _OverflowDetect($sOperator, $iOperand_1, $iOperand_2)
    If Not StringRegExp($sOperator, '\A\s*[\+\-\*]\s*\z') Then Return SetError(1) ; operator not recognized
    If Not StringInStr(VarGetType($iOperand_1), 'Int') Then Return SetError(2) ; meaningless request
    If Not StringInStr(VarGetType($iOperand_2), 'Int') Then Return SetError(3) ; ditto

    ; execute the expression
    Local $iExecute = Execute($iOperand_1 & $sOperator & $iOperand_2)

    ; execute the expression with the operands converted to doubles
    Local $fCompare = Execute('Number(' & $iOperand_1 & ', 3)' & $sOperator & 'Number(' & $iOperand_2 & ', 3)')

    ; the results should be approximately equal
    Return StringFormat('%.15e', $iExecute) <> StringFormat('%.15e', $fCompare)
EndFunc

This function is not as reliable as the new version posted in the topic: https://www.autoitscript.com/forum/topic/176620-operator64/
The following topic may also be of interest: https://www.autoitscript.com/forum/topic/176690-number-puzzle/

Edited by czardas

Share this post


Link to post
Share on other sites

Create an account or sign in to comment

You need to be a member in order to leave a comment

Create an account

Sign up for a new account in our community. It's easy!

Register a new account

Sign in

Already have an account? Sign in here.

Sign In Now
Sign in to follow this  

  • Similar Content

    • czardas
      By czardas
      Perform accurate division using real fractions and convert floating point numbers to fractions.

      Floating point arithmetic often introduces small inaccuracies. Most of the time this is not a problem, but sometimes it can be. As a workaround, many programmers decide to only use whole numbers for specific calculations - ones which need to return exact results. The fraction 1/3 cannot be represented using a float. You would need a decimal (or floating point variant) of infinite length to give an accurate representation of 1/3. Working with fractions is not entirely straight forward, and at times this can be a little frustrating.
      With the functions in this library, there is potential for internal calculations to produce numbers which are out of range. Not withstanding oversights: both input numbers should be less than 16 digits and the difference between the denominator and the divisor should be an order of magnitude less than 10^16, otherwise the function will return an error.
      With the exception of Fraction(), all included functions take array parameters. All return values are either arrays or boolean values. Documentation and examples pending.
      NEW VERSION requires operator64.au3 found here: https://www.autoitscript.com/forum/topic/176620-operator64/
      This is an alpha release -see post 33.
      #include-once #include 'operator64.au3' ; #INDEX# ====================================================================================================================== ; Title .........: Fraction ; AutoIt Version : 3.3.14.0 ; Language ......: English ; Description ...: Maths functions intended to be used with vulgar fractions. ; Notes .........: In this library, a fraction is defined as two integers stored in a two element array. ; Several functions use approximation when internal calculations go out of range. ; When an approximation occurs, @extended is set to 1. This return value should be checked in most instances. ; ----------------------------------------------------------------------------------------------------------- ; Input Size Limits for _Fraction() ; Unlimited within the confines of AutoIt (approximately) between -1e+308 and +1e+308 ; Smallest value (approximately) 1e-323 ; -------------------------------------------------------------------- ; Negative Output Size Limits for All Functions That Return a Fraction ; 9223372036854775807 /-1 To -1/ 9223372036854775807 negative range ; - 2^63 /1 Out of range ; tiny negative values are either rounded down to -1/ 9223372036854775807 or rounded up to 0/-1 ; ---------------------------------------------------------------- ; Positive Output Size Limits for Functions That Return a Fraction ; 1/ 9223372036854775807 To 9223372036854775807 /1 positive range ; 2^63 /1 Out of range ; tiny positive values are either rounded up to 1/ 9223372036854775807 or rounded down to 0/1 ; Author(s) .....: czardas, Pheonix XL ; ============================================================================================================================== ; #CURRENT# ==================================================================================================================== ; _Fraction ; _FractionAbs ; _FractionAdd ; _FractionApproximate ; _FractionCeiling ; _FractionDivide ; _FractionFloor ; _FractionMod ; _FractionMultiply ; _FractionPower ; _FractionRoot ; _FractionSubtract ; _IsFraction ; _IsFractionNegative ; _Reciprocal ; ============================================================================================================================== ; #INTERNAL_USE_ONLY#=========================================================================================================== ; __GCD ; __FloatRatio ; __FloatToDigits ; __Quotient ; __Simplify ; ============================================================================================================================== ; #FUNCTION# =================================================================================================================== ; Name...........: _Fraction ; Description ...: Conversion from float to fraction and whole number division. ; Syntax.........: _Fraction($nDividend [, $nDivisor = 1]) ; Parameters.....; $iDividend - Top fractional part ; $iDivisor - [Optional] Lower fractional part. The default value is 1. ; Return Values ; Success - Returns an array of two elements. The first element is the dividend, and the second is the divisor. ; Sets @Extended to 1 if rounding or approximation occurs, or if one of the input parameters is a float. ; Failure sets @error as follows ; |@error = 1 Input contains non-numeric or undefined data. ; |@error = 2 The divisor cannot be zero. ; |@error = 3 Out of range. ; Author ........: czardas ; Comments ......; Accepts Int32, Int64 and floats. Output ranges are shown in the main header. ; ============================================================================================================================== Func _Fraction($nDividend, $nDivisor = 1) If Not IsNumber($nDividend) Or StringInStr($nDividend, '#') Or _ Not IsNumber($nDivisor) Or StringInStr($nDivisor, '#') Then Return SetError(1) ; non-numeric input or undefined value If $nDivisor = 0 Then Return SetError(2) ; division by zero produces meaningless results Local $iExtended = 0 ; will be set to 1 if rounding or approximation occurs, or if one of the input parameters is a float $nDividend = __Integer64($nDividend) If @error Or $nDividend = 0x8000000000000000 Then $iExtended = 1 $nDivisor = __Integer64($nDivisor) If @error Or $nDivisor = 0x8000000000000000 Then $iExtended = 1 Local $aFraction[2] ; if both the dividend and divisor are negative, then both output values will be positive $aFraction[0] = ($nDividend < 0 And $nDivisor > 0) ? -1 : 1 $aFraction[1] = ($nDivisor < 0 And $nDividend > 0) ? -1 : 1 If $iExtended Then ; float parameters require preprocessing $nDividend = Number($nDividend, 3) $nDivisor = Number($nDivisor, 3) __FloatRatio($nDividend, $nDivisor) If @error Then Return SetError(3) ; out of range EndIf If $nDividend = 0 Then $aFraction[0] = 0 $aFraction[1] = $nDivisor > 0 ? 1 : -1 ; a fraction may have a value of negative zero (purpose unknown) Return $aFraction EndIf $nDividend = _Abs64($nDividend) $nDivisor = _Abs64($nDivisor) If $nDividend <> 0 Then __Simplify($nDividend, $nDivisor) ; division by the greatest common divisor $aFraction[0] *= $nDividend ; return values may be negative $aFraction[1] *= $nDivisor ; as above. Return SetExtended($iExtended, $aFraction) EndFunc ;==> _Fraction ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionAbs ; Description ...: Calculates the absolute value of a fraction. ; Syntax.........: _FractionAbs($aFraction) ; Parameters.....; $aFraction - A two element array containing a dividend and a divisor. ; Return values .: Success - Returns a two element array containing the absolute values of both dividend and divisor. ; Failure sets @error to 1 if the input is not a valid array containing both a dividend and a divisor. ; Author ........: czardas ; ============================================================================================================================== Func _FractionAbs($aFraction) If Not _IsFraction($aFraction) Then Return SetError(1) $aFraction[0] = _Abs64($aFraction[0]) $aFraction[1] = _Abs64($aFraction[1]) Return $aFraction EndFunc ;==> _FractionAbs ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionAdd ; Description ...: Calculates the sum of two fractions. ; Syntax.........: _FractionAdd($aFraction1, $aFraction2) ; Parameters.....; $aFraction1 - The first two element array containing a dividend and a divisor. ; $aFraction2 - The second two element array containing a dividend and a divisor. ; Return values .: Success - Returns a two element array containing the sum of the two fractions. ; Sets @Extended to 1 if rounding or approximation occurs. ; Failure sets @error as follows ; |@error = 1 Invalid input. ; |@error = 2 The divisor cannot become zero. ; |@error = 3 Out of range. ; Author ........: czardas ; ============================================================================================================================== Func _FractionAdd($aFraction1, $aFraction2) If Not (_IsFraction($aFraction1) And _IsFraction($aFraction2)) Then Return SetError(1) Local $iValue_1, $iValue_2, $iDividend, $iDivisor, $iExtended = 0 If __OverflowDetect('*', $aFraction1[0], $aFraction2[1], $iValue_1) Then $iExtended = 1 If __OverflowDetect('*', $aFraction1[1], $aFraction2[0], $iValue_2) Then $iExtended = 1 If __OverflowDetect('+', $iValue_1, $iValue_2, $iDividend) Then $iExtended = 1 If __OverflowDetect('*', $aFraction1[1], $aFraction2[1], $iDivisor) Then $iExtended = 1 Local $aAddition = _Fraction($iDividend, $iDivisor) If @extended Then $iExtended = 1 Return SetError(@error, $iExtended, $aAddition) EndFunc ;==> _FractionAdd ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionApproximate ; Description ...: Approximates the value of a fraction according to limits imposed on the size of the divisor. ; Syntax.........: _FractionApproximate($aFraction, $iMaxDivisor) ; Parameters.....; $aFraction - A two element array containing a valid dividend and divisor. ; $iMaxDivisor - The maximum numeric limit for the divisor. ; Return values .: Success - Returns a two element array containing the approximated fraction. ; Failure sets @error as follows ; |@error = 1 Invalid input for $aFraction. ; |@error = 2 Invalid input for $iMaxDivisor. ; Author ........: czardas ; Comments ......; Approximates fractions using the method of continued fractions. ; ============================================================================================================================== Func _FractionApproximate($aFraction, $iMaxDivisor) If Not _IsFraction($aFraction) Then Return SetError(1) Local $bNegative = @extended $iMaxDivisor = _Abs64($iMaxDivisor) If @extended Then Return SetError(2, 0, $aFraction) Local $aCurrentFraction = _FractionAbs($aFraction) If $iMaxDivisor < 1 Or $iMaxDivisor >= $aCurrentFraction[1] Or $aCurrentFraction[1] <= 1 Then Return SetError(2, 0, $aFraction) ; determine the terms of the continued fraction Local $sFractionOfFraction = '' Do $sFractionOfFraction &= __Quotient($aCurrentFraction[0], $aCurrentFraction[1]) & ',' $aCurrentFraction[0] = Mod($aCurrentFraction[0], $aCurrentFraction[1]) $aCurrentFraction = _Reciprocal($aCurrentFraction) Until @error Local $aContinued = StringSplit(StringTrimRight($sFractionOfFraction, 1), ',', 2) Local $iTry, $iRange, $iMin = 0, $iMax = Ubound($aContinued) -1, $aConvergence[2] ; binary search algorithm Do $aConvergence[0] = 0 $aConvergence[1] = 1 $iRange = $iMax - $iMin +1 $iTry = $iMin + Floor($iRange/2) If $iTry > $iMax Then $iTry = $iMax ; added patch ; evaluate the significant first few terms of the continued fraction If $iTry > 0 Then For $i = $iTry To 1 Step -1 $aConvergence = _FractionAdd($aConvergence, _Fraction(Number($aContinued[$i]))) $aConvergence = _Reciprocal($aConvergence) Next EndIf $aConvergence = _FractionAdd($aConvergence, _Fraction(Number($aContinued[0]))) If $aConvergence[1] > $iMaxDivisor Then ; aim was too high - target is lower $iMax = $iTry -1 Else ; aim was too low - target may be higher ; log low entry $aCurrentFraction = $aConvergence $iMin = $iTry +1 EndIf Until $iRange <= 1 If $bNegative Then $aCurrentFraction[(($aFraction[0] < 0) ? 0 : 1)] *= -1 Return $aCurrentFraction EndFunc ;==> _FractionApproximate ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionCeiling ; Description ...: Calculates the ceiling value of a fraction. ; Syntax.........: _FractionCeiling($aFraction) ; Parameters.....; $aFraction - A two element array containing a dividend and a divisor. ; Return values .: Success - Returns a two element array ==> The first element is the ceiling value, and the divisor is always 1. ; Failure sets @error as follows ; |@error = 1 The input is not a valid array containing a dividend and a divisor. ; Author ........: czardas ; Comments ......; If the fraction is negative, then its ceiling value represents the integer part of the fraction. ; ============================================================================================================================== Func _FractionCeiling($aFraction) If Not _IsFraction($aFraction) Then Return SetError(1) Local $bNegative = @extended If $aFraction[0] = 0 Then Return $aFraction ; for this to work we need to simplify the fraction $aFraction = _FractionAbs($aFraction) Local $iDividend = $aFraction[0], $iDivisor = $aFraction[1] __Simplify($iDividend, $iDivisor) If $iDivisor = 1 Then Return _Fraction($iDividend * ($bNegative = 0 ? 1 : -1)) Local $iCeiling = __Quotient($iDividend, $iDivisor) If $bNegative Then Return _Fraction($iCeiling * -1) Return _Fraction($iCeiling + 1) EndFunc ;==> _FractionCeiling ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionDivide ; Description ...: Divides the first fraction by the second. ; Syntax.........: _FractionDivide($aDividend, $aDivisor) ; Parameters.....; $aDividend - The first two element array containing a dividend and a divisor. ; $aDivisor - The second two element array containing a dividend and a divisor. ; Return values .: Success - Returns a two element array containing the result after division. ; Sets @Extended to 1 if rounding or approximation occurs. ; Failure sets @error as follows ; |@error = 1 Invalid input. ; |@error = 2 The divisor cannot become zero. ; |@error = 3 Out of range. ; Author ........: czardas ; ============================================================================================================================== Func _FractionDivide($aDividend, $aDivisor) If Not (_IsFraction($aDividend) And _IsFraction($aDivisor)) Then Return SetError(1) Local $iValue_1, $iValue_2, $iExtended = 0 If __OverflowDetect('*', $aDividend[0], $aDivisor[1], $iValue_1) Then $iExtended = 1 If __OverflowDetect('*', $aDividend[1], $aDivisor[0], $iValue_2) Then $iExtended = 1 If $aDivisor[0] = 0 Then Return SetError(2) Local $aDivision = _Fraction($iValue_1, $iValue_2) If @extended Then $iExtended = 1 Return SetError(@error, $iExtended, $aDivision) EndFunc ;==> _FractionDivide ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionFloor ; Description ...: Calculates the floor value of a fraction. ; Syntax.........: _FractionFloor($aFraction) ; Parameters.....; $aFraction - A two element array containing a dividend and a divisor. ; Return values .: Success - Returns a two element array ==> The first element is the floor value, and the divisor is always 1. ; Failure sets @error as follows ; |@error = 1 The input is not a valid array containing a dividend and a divisor. ; Author ........: czardas ; Comments ......; If the fraction is positive, then its floor value represents the integer part of the fraction. ; ============================================================================================================================== Func _FractionFloor($aFraction) If Not _IsFraction($aFraction) Then Return SetError(1) Local $bNegative = @extended If $aFraction[0] = 0 Then Return $aFraction ; for this to work we need to simplify the fraction $aFraction = _FractionAbs($aFraction) Local $iDividend = $aFraction[0], $iDivisor = $aFraction[1] __Simplify($iDividend, $iDivisor) If $iDivisor = 1 Then Return _Fraction($iDividend * ($bNegative = 0 ? 1 : -1)) Local $iFloor = __Quotient($iDividend, $iDivisor) If Not $bNegative Then Return _Fraction($iFloor) Return _Fraction($iFloor * -1 - 1) EndFunc ;==> _FractionFloor ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionMod ; Description ...: Performs the modulus operation with two fractions. ; Syntax.........: _FractionMod($aDividend, $aDivisor) ; Parameters.....; $aDividend - The first fraction is the dividend array. ; $aDivisor - The second fraction is the divisor array. ; Return values .: Success - Returns a two element array containing the modulus of $aDividend and $aDivisor. ; Sets @Extended to 1 if rounding or approximation occurs. ; Failure sets @error to: ; |@error = 1 Out of bounds - Fraction division failure. ; |@error = 2 Out of bounds - Fraction multiplication failure. ; |@error = 3 Out of bounds - Fraction subtraction failure. ; Author ........: czardas ; ============================================================================================================================== Func _FractionMod($aDividend, $aDivisor) Local $iExtended = 0, $aDivision = _FractionDivide($aDividend, $aDivisor) If @error Then Return SetError(1) If @extended Then $iExtended = @extended Local $aModulus[2] If $aDividend[0] = 0 Then $aModulus[0] = 0 $aModulus[1] = ($aDividend[0] < 0) ? -1 : 1 Return $aModulus EndIf Local $aMultiple = _FractionMultiply(_FractionAbs($aDivisor), _FractionFloor(_FractionAbs($aDivision))) If @error Then Return SetError(2) If @extended Then $iExtended = @extended $aModulus = _FractionSubtract(_FractionAbs($aDividend), $aMultiple) If @error Then Return SetError(3) If @extended Then $iExtended = @extended If _IsFractionNegative($aDividend) Then If $aDividend[0] < 0 Then $aModulus[0] *= -1 Else $aModulus[1] *= -1 EndIf EndIf Return SetExtended($iExtended, $aModulus) EndFunc ;==> _FractionMod ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionMultiply ; Description ...: Calculates the product of two fractions. ; Syntax.........: _FractionMultiply($aFraction1, $aFraction2) ; Parameters.....; $aFraction1 - The first two element array containing a dividend and a divisor. ; $aFraction2 - The second two element array containing a dividend and a divisor. ; Return values .: Success - Returns a two element array containing the product of the two fractions. ; Sets @Extended to 1 if rounding or approximation occurs. ; Failure sets @error as follows ; |@error = 1 Invalid input. ; |@error > 1 Internal calculations went out of range. ; Author ........: czardas ; ============================================================================================================================== Func _FractionMultiply($aFraction1, $aFraction2) If Not (_IsFraction($aFraction1) And _IsFraction($aFraction2)) Then Return SetError(1) Local $iValue_1, $iValue_2, $iExtended = 0 If __OverflowDetect('*', $aFraction1[0], $aFraction2[0], $iValue_1) Then $iExtended = 1 If __OverflowDetect('*', $aFraction1[1], $aFraction2[1], $iValue_2) Then $iExtended = 1 Local $aProduct = _Fraction($iValue_1, $iValue_2) If @extended Then $iExtended = 1 Return SetError(@error, $iExtended, $aProduct) EndFunc ;==> _FractionMultiply ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionPower ; Description ...: Raises a fraction to the power of a fraction. ; Syntax.........: _FractionPower($aFraction, $aPower) ; Parameters.....; $aFraction - The first two element array containing a dividend and a divisor. ; $aPower - The second two element array containing a dividend and a divisor. ; Return values .: Success - Returns a two element array containing $aFraction to the power of $aPower. ; Sets @Extended to 1 if rounding or approximation occurs. ; Failure sets @error as follows ; |@error = 1 Invalid input. ; |@error = 3 Out of range. ; |@error = 5 Imaginary fraction detected. ; Author ........: czardas ; Comments ......; Calculating fractional powers of approximated negative fractions leads to ambiguity. ; ============================================================================================================================== Func _FractionPower($aFraction, $aPower) If Not _IsFraction($aPower) Then Return SetError(1) Local $bNegative = _IsFractionNegative($aFraction) If @error Then Return SetError(1) If $bNegative And Mod($aPower[1], 2) = 0 Then Return SetError(5) Local $iSign = ($bNegative And Mod($aPower[0], 2) <> 0) ? -1 : 1 $aFraction = _FractionAbs($aFraction) Local $iExtended, $iPower = __WholeNumberDivision($aPower[0], $aPower[1]) If @extended Then $iExtended = 1 Local $iDividend If $iExtended Then $iDividend = $aFraction[0] ^ $iPower Else $iDividend = _Power64($aFraction[0], $iPower) If @extended Then $iExtended = 1 EndIf Local $iDivisor If $iExtended Then $iDivisor = $aFraction[1] ^ $iPower Else $iDivisor = _Power64($aFraction[1], $iPower) If @extended Then $iExtended = 1 EndIf $aPower = _Fraction($iSign * $iDividend, $iDivisor) If @extended Then $iExtended = 1 Return SetError(@error, $iExtended, $aPower) EndFunc ;==> FractionPower ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionRoot ; Description ...: Calculates the fractional root of a fraction. ; Syntax.........: _FractionRoot($aFraction, $aRoot) ; Parameters.....; $aFraction - The first two element array containing a dividend and a divisor. ; $aRoot - The second two element array containing a dividend and a divisor. ; Return values .: Success - Returns a two element array containing $aFraction to the power of the reciprocal of $aRoot. ; Sets @Extended to 1 if rounding or approximation occurs. ; Failure sets @error as follows ; |@error = 1 Invalid input. ; |@error = 3 Out of range. ; |@error = 5 Imaginary fraction detected. ; Author ........: czardas ; Comments ......; Calculating fractional roots of approximated negative fractions leads to ambiguity. ; ============================================================================================================================== Func _FractionRoot($aFraction, $aRoot) If Not _IsFraction($aRoot) Then Return SetError(1) Local $bNegative = _IsFractionNegative($aFraction) If @error Then Return SetError(1) If $bNegative And Mod($aRoot[0], 2) = 0 Then Return SetError(5) Local $iSign = ($bNegative And Mod($aRoot[1], 2) <> 0) ? -1 : 1 $aFraction = _FractionAbs($aFraction) Local $iExtended, $iRoot = __WholeNumberDivision($aRoot[0], $aRoot[1]) If @extended Then $iExtended = 1 Local $iDividend If $iExtended Then $iDividend = $aFraction[0] ^ (1 / $iRoot) Else $iDividend = _Root64($aFraction[0], $iRoot) If @extended Then $iExtended = 1 EndIf Local $iDivisor If $iExtended Then $iDivisor = $aFraction[1] ^ (1 / $iRoot) Else $iDivisor = _Root64($aFraction[1], $iRoot) If @extended Then $iExtended = 1 EndIf $aRoot = _Fraction($iSign * $iDividend, $iDivisor) If @extended Then $iExtended = 1 Return SetError(@error, $iExtended, $aRoot) EndFunc ;==> FractionRoot ; #FUNCTION# =================================================================================================================== ; Name...........: _FractionSubtract ; Description ...: Subtracts the second fraction from the first. ; Syntax.........: _FractionSubtract($aFraction1, $aFraction2) ; Parameters.....; $aFraction1 - The first two element array containing a dividend and a divisor. ; $aFraction2 - The second two element array containing a dividend and a divisor (subtracted from $aFraction1). ; Return values .: Success - Returns a two element array containing the resulting fraction. ; Sets @Extended to 1 if rounding or approximation occurs. ; Failure sets @error as follows ; |@error = 1 Invalid input. ; |@error = 2 The divisor cannot become zero. ; |@error = 3 Out of range. ; Author ........: czardas ; ============================================================================================================================== Func _FractionSubtract($aFraction1, $aFraction2) If Not (_IsFraction($aFraction1) And _IsFraction($aFraction2)) Then Return SetError(1) Local $iValue_1, $iValue_2, $iDividend, $iDivisor, $iExtended = 0 If __OverflowDetect('*', $aFraction1[0], $aFraction2[1], $iValue_1) Then $iExtended = 1 If __OverflowDetect('*', $aFraction1[1], $aFraction2[0], $iValue_2) Then $iExtended = 1 If __OverflowDetect('-', $iValue_1, $iValue_2, $iDividend) Then $iExtended = 1 If __OverflowDetect('*', $aFraction1[1], $aFraction2[1], $iDivisor) Then $iExtended = 1 Local $aSubtraction = _Fraction($iDividend, $iDivisor) If @extended Then $iExtended = 1 Return SetError(@error, $iExtended, $aSubtraction) EndFunc ;==> _FractionSubtract ; #FUNCTION# =================================================================================================================== ; Name...........: _IsFraction ; Description ...: Checks if the input is an array containing two valid integers ==> representing dividend and divisor. ; Syntax.........: _IsFraction($aFraction) ; Parameters.....; $aFraction - A two element array containing a dividend and a divisor. ; Return values .: Returns True if the input matches the criteria, otherwise returns False. ; Author.........: czardas ; Comments ......; Sets @extended to 1 if the fraction is negative. ; ============================================================================================================================== Func _IsFraction($aFraction) If Not IsArray($aFraction) Then Return False If Ubound($aFraction,0) <> 1 Or Ubound($aFraction) <> 2 Then Return False If Not StringInStr(VarGetType($aFraction[0]), 'Int') Or $aFraction[0] = 0x8000000000000000 Then Return False If Not StringInStr(VarGetType($aFraction[1]), 'Int') Or $aFraction[1] = 0x8000000000000000 Then Return False Return SetExtended((($aFraction[0] < 0 And $aFraction[1] > 0) Or ($aFraction[0] >= 0 And $aFraction[1] < 0)) ? 1 : 0, True) EndFunc ;==> _IsFraction ; #FUNCTION# =================================================================================================================== ; Name...........: _IsFractionNegative ; Description ...: Checks if the input array is a negative fraction. ; Syntax.........: _IsFractionNegative($aFraction) ; Parameters.....; $aFraction - A two element array containing a dividend and a divisor. ; Return values .: Returns True if the dividend and the divisor are of the opposite sign, othewise returns False. ; Failure sets @error to 1 if the input is not a valid array containing a dividend and a divisor. ; Author.........: czardas ; ============================================================================================================================== Func _IsFractionNegative($aFraction) Local $bNegative, $bIsFraction = _IsFraction($aFraction) $bNegative = @extended Return SetError(1 - $bIsFraction, 0, ($bNegative = 1)) EndFunc ;==> _IsFractionNegative ; #FUNCTION# =================================================================================================================== ; Name...........: _Reciprocal ; Description ...: Inverts a fraction by swapping the dividend and the divisor. ; Syntax.........: _Reciprocal($aFraction) ; Parameters.....; $aFraction - A two element array containing a dividend and a divisor. ; Return values .: Returns the reciprocal of the fraction. ; Failure sets @error as follows ; |@error = 1 The input is not a valid array containing a dividend and a divisor. ; |@error = 2 The divisor cannot become zero. ; Author.........: czardas ; ============================================================================================================================== Func _Reciprocal($aFraction) If Not _IsFraction($aFraction) Then Return SetError(1) Local $iDivisor = $aFraction[0] If $iDivisor = 0 Then Return SetError(2) $aFraction[0] = $aFraction[1] $aFraction[1] = $iDivisor Return $aFraction EndFunc ;==> _Reciprocal ; #INTERNAL_USE_ONLY# ========================================================================================================== ; Name...........: __FloatRatio ; Description ...: Helper function for Fraction() - preprocessing of float parameters to generate two proportional integers. ; Syntax.........: __FloatRatio([ByRef] $nDividend, [ByRef] $nDivisor) ; Parameters.....; $iDividend - Top fractional part ; $iDivisor - Lower fractional part ; Return values .: Success - Integer values are returned ByRef. ; Failure sets @error as follows ; |@error = 1 Out of bounds. ; Author ........: czardas ; Comments ......; No attempt has been made to accomodate for any double precision limitations. ; Small innacuracies can affect the 17th and (sometimes) the 16th digit in double precision. ; Using floats can easily be avoided by only passing integers to the function _Fraction(). ; Input positive floats only ; ============================================================================================================================== Func __FloatRatio(ByRef $nDividend, ByRef $nDivisor) If $nDivisor < 0 Then $nDividend *= -1 $nDivisor *= -1 EndIf If $nDivisor <> 1 Then $nDividend /= $nDivisor Local $nSignificand, $iExponent, $iDigits = 16 ; might as well grab as many digits as are available $nSignificand = __FloatToDigits($nDividend, $iDigits) $iExponent = @extended $nSignificand = Number($nSignificand, 2) ; Int-64 While $iExponent < - 18 ; divide the significand by powers of 10 $iDigits -= 1 If $iDigits < 0 Then ; too small If $nDividend < 1 / (2 * 10 ^ 18) Then ; round down to 0 / 1 $nSignificand = 0 $iExponent = 0 Else ; round up to 1 / 1000000000000000000 $nSignificand = 1 $iExponent = 18 EndIf ExitLoop EndIf $nSignificand = __FloatToDigits($nDividend, $iDigits) $iExponent = @extended ; adjust the exponent to accomodate division of the significand $nSignificand = Number($nSignificand, 2) ; Int-64 WEnd While $iExponent > 0 ; multiply the significand by powers of 10 If __OverflowDetect('*', $nSignificand, 10, $nSignificand) Then Return SetError(1) ; too large ~ out of bounds $iExponent -= 1 ; adjust the exponent to accomodate multiplication of the significand If $iExponent = 0 Then ExitLoop WEnd $nDividend = $nSignificand ; range 0 to 1000000000000000000 $nDivisor = _Power64(10, Abs($iExponent)) ; range 10 ^ (0 to 18) ==> powers of 10 only EndFunc ;==> __FloatRatio ; #INTERNAL_USE_ONLY# ========================================================================================================== ; Name...........: __FloatToDigits ; Description ...: Extracts a specified number of digits from a float. ; Syntax.........: __FloatToDigits($fFloat, $iDigits) ; Parameters.....; $fFloat - The float to extract the digits from. ; $iDigits - The number of digits to extract after the floating point (exponential representation). ; Return values .: Success - Returns a 32-bit or 64-bit signed integer. ; Sets @extended to the decimal exponent. ==> $fFloat = return value * 10 ^ exponent ; Failure sets @error to 1 if the input is not a float or undefined. ; Author ........: czardas ; ============================================================================================================================== Func __FloatToDigits($fFloat, $iDigits = 14) If VarGetType($fFloat) <> 'Double' Or StringInStr($fFloat, '#') Then Return SetError(1) Local $iSign = ($fFloat < 0) ? -1 : 1 ; machine epsilon = 5 × 10^-15, so the final two digits (16 and 17) could be highly innacurate $fFloat = StringFormat('%.' & $iDigits & 'e', $fFloat) ; rounds to the specified number of decimal places Local $aFloat = StringSplit($fFloat, "e", 2) ; zero-based array If $iSign < 0 Then $aFloat[0] = StringTrimLeft($aFloat[0], 1) ; remove the minus sign ; remove the decimal point and trailing zeros $aFloat[0] = StringLeft($aFloat[0], 1) & StringRegExpReplace(StringRight($aFloat[0], $iDigits), '(0+\z)', '') $aFloat[1] += 1 - StringLen($aFloat[0]) ; adjust the exponent to accommodate changes Return SetExtended($aFloat[1], Int($aFloat[0]) * $iSign) ; add back the minus sign EndFunc ;==> __FloatToDigits ; #INTERNAL_USE_ONLY# ========================================================================================================== ; Name...........: __GCD ; Description ...: Calculates the greatest common divisor of two integers. Original function name ==> _Greatest_Common_Factor() ; Syntax.........: __GCD($iValue1, $iValue2) ; Parameters.....; $iValue1 - First Integer. ; $iValue2 - Second Integer. ; Return values .: Success - Returns the greatest common divisor of $iValue1 and $iValue2. ; Author.........: Pheonix XL ; Modified.......; czardas ; Comments ......; IMPORTANT - Error checks have been removed. You must run the checks if you use this function yourself. ; ============================================================================================================================== Func __GCD($iValue1, $iValue2) ; Only accepts positive integers greater than zero. ; If Not (IsInt($iValue1) And IsInt($iValue2)) Or $iValue1 < 1 Or $iValue2 < 1 Then Return SetError(1) Local $iToggle If $iValue1 < $iValue2 Then ; Switch values. $iToggle = $iValue1 $iValue1 = $iValue2 $iValue2 = $iToggle EndIf Local $iModulus While 1 ; Method of Euclid. $iModulus = Mod($iValue1, $iValue2) If $iModulus = 0 Then ExitLoop $iValue1 = $iValue2 $iValue2 = $iModulus WEnd Return $iValue2 EndFunc ;==> __GCD ; #INTERNAL_USE_ONLY# ========================================================================================================== ; Name...........: __Quotient ; Description ...: Returns the quotient after division ~(the whole number part of a fraction). ; Syntax.........: __Quotient($nDividend, $nDivisor) ; Parameters.....; $iDividend - The integer to divide ; $iDivisor - The integer to divide by ; Return values .: Returns the quotient. ; Author ........: czardas ; Comments ......; Uses the same correction method as __WholeNumberDivision() in operator64.au3. ; ============================================================================================================================== Func __Quotient($nDividend, $nDivisor) Local $iQuotient = Floor($nDividend / $nDivisor), $iDifference, $iIntegral While $iQuotient * $nDivisor > $nDividend ; division is overstated $iDifference = ($nDivisor * $iQuotient) - $nDividend $iIntegral = Floor($iDifference / $nDivisor) ; avoid shooting beyond the target If $iIntegral = 0 Then $iIntegral = 1 ; prevents hanging in an infinite loop $iQuotient -= $iIntegral WEnd While $iQuotient * $nDivisor < $nDividend ; division is understated $iDifference = $nDividend - ($nDivisor * $iQuotient) $iIntegral = Floor($iDifference / $nDivisor) ; as above If $iIntegral = 0 Then ExitLoop ; we have found the floor already $iQuotient += $iIntegral WEnd Return $iQuotient EndFunc ;==> __Quotient ; #INTERNAL_USE_ONLY# ========================================================================================================== ; Name...........: __Simplify ; Description ...: Simplification by division. ; Syntax.........: __Simplify($iDividend, $iDivisor) ; Parameters.....; $iDividend - Top fractional part. ; $iDivisor - Lower fractional part. ; Author ........: czardas ; ============================================================================================================================== Func __Simplify(ByRef $iDividend, ByRef $iDivisor) Local $iGCD = __GCD($iDividend, $iDivisor) If $iGCD > 1 Then $iDividend = __WholeNumberDivision($iDividend, $iGCD) $iDivisor = __WholeNumberDivision($iDivisor, $iGCD) EndIf EndFunc ;==> __Simplify Examples - currently testing for accuracy and possible bugs.
      #include 'Fraction.au3' Local $aFraction = _Fraction(3.1416) If @error Then Exit ; ==> Error handling. ConsoleWrite("3.1416 = " & $aFraction[0] & " / " & $aFraction[1] & @LF) $aFraction = _Fraction(0.125 , 2) ConsoleWrite("0.125 / 2 = " & $aFraction[0] & " / " & $aFraction[1] & @LF) $aFraction = _Fraction(0.00125, -0.32) ConsoleWrite("0.00125 / -0.32 = " & $aFraction[0] & " / " & $aFraction[1] & @LF) $aFraction = _Fraction(86418753, 2977963408767) ConsoleWrite("86418753 / 2977963408767 = " & $aFraction[0] & " / " & $aFraction[1] & @LF) ; Multiply two fractions (27 / 28 x 374 / 555) using whole number arithmetic: Local $aProduct = _FractionMultiply(_Fraction(27, 28), _Fraction(374, 555)) ConsoleWrite("27 / 28 x 374 / 555 = " & $aProduct[0] & " / " & $aProduct[1] & @LF) ; The modulus of two fractions: Local $aMod = _FractionMod(_Fraction(-1, 2), _Fraction(1, 3)) ConsoleWrite("Mod(-1/2, 1/3) = " & $aMod[0] & "/" & $aMod[1] & @LF) ; Represent pi (as accurately as possible) using a fraction with denominator of no more than thirteen digits. Local $aPi = _FractionApproximate(_Fraction(3.14159265358979), 1e+013 -1) ConsoleWrite($aPi[0] & " / " & $aPi[1] & " = " & $aPi[0] / $aPi[1] & " ~ Pi" & @LF) Local $aR2 = _FractionApproximate(_Fraction(2^.5), 1.0e+13 -1) ConsoleWrite($aR2[0] & " / " & $aR2[1] & " = " & $aR2[0] / $aR2[1] & " ~ 2^(1/2)" & @LF) Local $aLarge = _Fraction(1.23456789e+017,100000000000000100) If @error Then MsgBox(0, "", @error) ConsoleWrite(@extended & @LF) ConsoleWrite($aLarge[0] & " / " & $aLarge[1] & " = " & $aLarge[0] / $aLarge[1] & " = " & 1.23456789e+017 / 100000000000001000 & @LF) Local $aSmall = _Fraction(1.23456789e-200,8.64197523e-192) If @error Then MsgBox(0, "", @error) ConsoleWrite(@extended & @LF) ConsoleWrite($aSmall[0] & " / " & $aSmall[1] & " = " & $aSmall[0] / $aSmall[1] & " = " & 1.23456789e-200 / 8.64197523e-192 & @LF) Local $aTooSmall = _Fraction(1.23456789e-200,100000000000000100) If @error Then MsgBox(0, "", @error) ConsoleWrite("@extended = " & @extended & @LF) ConsoleWrite($aTooSmall[0] & " / " & $aTooSmall[1] & " = " & $aTooSmall[0] / $aTooSmall[1] & " = " & 1.23456789e-200 / 100000000000001000 & @LF) Local $aTooLarge = _Fraction(100000000000000100, 1.23456789e-200) ConsoleWrite("@error = " & @error & @LF) Local $aAddApprox = _FractionAdd(_Fraction(134567890000, 999999999999), _Fraction(987654321000, 777777777777777)) ConsoleWrite("@extended = " & @extended & @LF) ConsoleWrite($aAddApprox[0] & " / " & $aAddApprox[1] & " = " & $aAddApprox[0] / $aAddApprox[1] & " = " & (134567890000/999999999999 + 987654321000/777777777777777) ;
      See post 33 for information on the latest update.
×