algorithm - फ्लोट को मानव-पठनीय अंशों में कैसे परिवर्तित करें?




language-agnostic numbers (18)

मान लें कि हमारे पास 0.33 है, हमें "1/3" आउटपुट करने की आवश्यकता है। अगर हमारे पास "0.4" है, तो हमें "2/5" आउटपुट करने की आवश्यकता है।

यह सामान्य मामले में गलत है, क्योंकि 1/3 = 0.3333333 = 0. (3) इसके अलावा, उपर्युक्त समाधानों से पता लगाना असंभव है, दशमलव को निर्धारित परिशुद्धता के साथ अंश में परिवर्तित किया जा सकता है, क्योंकि आउटपुट हमेशा अंश होता है।

लेकिन, मैं विशेष रूप से फॉर्मूला पर अनंत ज्यामितीय श्रृंखला के विचार के आधार पर कई विकल्पों के साथ अपने व्यापक कार्य का सुझाव देता हूं:

सबसे पहले यह फ़ंक्शन स्ट्रिंग प्रस्तुति में अंश की अवधि खोजने की कोशिश कर रहा है। सूत्र के ऊपर वर्णित उसके बाद लागू किया गया है।

तर्कसंगत संख्या कोड को सी # में स्टीफन एम। मैककेमी तर्कसंगत संख्या कार्यान्वयन से उधार लिया जाता है। मुझे उम्मीद है कि अन्य भाषाओं पर अपना कोड पोर्ट करना बहुत मुश्किल नहीं है।

/// <summary>
/// Convert decimal to fraction
/// </summary>
/// <param name="value">decimal value to convert</param>
/// <param name="result">result fraction if conversation is succsess</param>
/// <param name="decimalPlaces">precision of considereation frac part of value</param>
/// <param name="trimZeroes">trim zeroes on the right part of the value or not</param>
/// <param name="minPeriodRepeat">minimum period repeating</param>
/// <param name="digitsForReal">precision for determination value to real if period has not been founded</param>
/// <returns></returns>
public static bool FromDecimal(decimal value, out Rational<T> result, 
    int decimalPlaces = 28, bool trimZeroes = false, decimal minPeriodRepeat = 2, int digitsForReal = 9)
{
    var valueStr = value.ToString("0.0000000000000000000000000000", CultureInfo.InvariantCulture);
    var strs = valueStr.Split('.');

    long intPart = long.Parse(strs[0]);
    string fracPartTrimEnd = strs[1].TrimEnd(new char[] { '0' });
    string fracPart;

    if (trimZeroes)
    {
        fracPart = fracPartTrimEnd;
        decimalPlaces = Math.Min(decimalPlaces, fracPart.Length);
    }
    else
        fracPart = strs[1];

    result = new Rational<T>();
    try
    {
        string periodPart;
        bool periodFound = false;

        int i;
        for (i = 0; i < fracPart.Length; i++)
        {
            if (fracPart[i] == '0' && i != 0)
                continue;

            for (int j = i + 1; j < fracPart.Length; j++)
            {
                periodPart = fracPart.Substring(i, j - i);
                periodFound = true;
                decimal periodRepeat = 1;
                decimal periodStep = 1.0m / periodPart.Length;
                var upperBound = Math.Min(fracPart.Length, decimalPlaces);
                int k;
                for (k = i + periodPart.Length; k < upperBound; k += 1)
                {
                    if (periodPart[(k - i) % periodPart.Length] != fracPart[k])
                    {
                        periodFound = false;
                        break;
                    }
                    periodRepeat += periodStep;
                }

                if (!periodFound && upperBound - k <= periodPart.Length && periodPart[(upperBound - i) % periodPart.Length] > '5')
                {
                    var ind = (k - i) % periodPart.Length;
                    var regroupedPeriod = (periodPart.Substring(ind) + periodPart.Remove(ind)).Substring(0, upperBound - k);
                    ulong periodTailPlusOne = ulong.Parse(regroupedPeriod) + 1;
                    ulong fracTail = ulong.Parse(fracPart.Substring(k, regroupedPeriod.Length));
                    if (periodTailPlusOne == fracTail)
                        periodFound = true;
                }

                if (periodFound && periodRepeat >= minPeriodRepeat)
                {
                    result = FromDecimal(strs[0], fracPart.Substring(0, i), periodPart);
                    break;
                }
                else
                    periodFound = false;
            }

            if (periodFound)
                break;
        }

        if (!periodFound)
        {
            if (fracPartTrimEnd.Length >= digitsForReal)
                return false;
            else
            {
                result = new Rational<T>(long.Parse(strs[0]), 1, false);
                if (fracPartTrimEnd.Length != 0)
                    result = new Rational<T>(ulong.Parse(fracPartTrimEnd), TenInPower(fracPartTrimEnd.Length));
                return true;
            }
        }

        return true;
    }
    catch
    {
        return false;
    }
}

public static Rational<T> FromDecimal(string intPart, string fracPart, string periodPart)
{
    Rational<T> firstFracPart;
    if (fracPart != null && fracPart.Length != 0)
    {
        ulong denominator = TenInPower(fracPart.Length);
        firstFracPart = new Rational<T>(ulong.Parse(fracPart), denominator);
    }
    else
        firstFracPart = new Rational<T>(0, 1, false);

    Rational<T> secondFracPart;
    if (periodPart != null && periodPart.Length != 0)
        secondFracPart =
            new Rational<T>(ulong.Parse(periodPart), TenInPower(fracPart.Length)) *
            new Rational<T>(1, Nines((ulong)periodPart.Length), false);
    else
        secondFracPart = new Rational<T>(0, 1, false);

    var result = firstFracPart + secondFracPart;
    if (intPart != null && intPart.Length != 0)
    {
        long intPartLong = long.Parse(intPart);
        result = new Rational<T>(intPartLong, 1, false) + (intPartLong == 0 ? 1 : Math.Sign(intPartLong)) * result;
    }

    return result;
}

private static ulong TenInPower(int power)
{
    ulong result = 1;
    for (int l = 0; l < power; l++)
        result *= 10;
    return result;
}

private static decimal TenInNegPower(int power)
{
    decimal result = 1;
    for (int l = 0; l > power; l--)
        result /= 10.0m;
    return result;
}

private static ulong Nines(ulong power)
{
    ulong result = 9;
    if (power >= 0)
        for (ulong l = 0; l < power - 1; l++)
            result = result * 10 + 9;
    return result;
}

उपयोग के कुछ उदाहरण हैं:

Rational<long>.FromDecimal(0.33333333m, out r, 8, false);
// then r == 1 / 3;

Rational<long>.FromDecimal(0.33333333m, out r, 9, false);
// then r == 33333333 / 100000000;

सही भाग शून्य भाग trimming के साथ आपका मामला:

Rational<long>.FromDecimal(0.33m, out r, 28, true);
// then r == 1 / 3;

Rational<long>.FromDecimal(0.33m, out r, 28, true);
// then r == 33 / 100;

न्यूनतम अवधि demostration:

Rational<long>.FromDecimal(0.123412m, out r, 28, true, 1.5m));
// then r == 1234 / 9999;
Rational<long>.FromDecimal(0.123412m, out r, 28, true, 1.6m));
// then r == 123412 / 1000000; because of minimu repeating of period is 0.1234123 in this case.

अंत में गोल:

Rational<long>.FromDecimal(0.8888888888888888888888888889m, out r));
// then r == 8 == 9;

सबसे दिलचस्प मामला:

Rational<long>.FromDecimal(0.12345678m, out r, 28, true, 2, 9);
// then r == 12345678 / 100000000;

Rational<long>.FromDecimal(0.12345678m, out r, 28, true, 2, 8);
// Conversation failed, because of period has not been founded and there are too many digits in fraction part of input value.

Rational<long>.FromDecimal(0.12121212121212121m, out r, 28, true, 2, 9));
// then r == 4 / 33; Despite of too many digits in input value, period has been founded. Thus it's possible to convert value to fraction.

अन्य परीक्षण और कोड सब लोग गणित पर मेरी MathFunctions लाइब्रेरी में पा सकते हैं।

मान लें कि हमारे पास 0.33 है, हमें "1/3" आउटपुट करने की आवश्यकता है।
अगर हमारे पास "0.4" है, तो हमें "2/5" आउटपुट करने की आवश्यकता है।

विचार यह है कि उपयोगकर्ता को डेटा को समझने के बेहतर तरीके के रूप में "वाई से बाहर हिस्सों" को समझने के लिए मानव-पठनीय बनाना है।

मुझे पता है कि प्रतिशत एक अच्छा विकल्प है लेकिन मैं सोच रहा था कि ऐसा करने का कोई आसान तरीका है या नहीं?


"मान लें कि हमारे पास 0.33 है, हमें" 1/3 "आउटपुट करने की आवश्यकता है।"

आपको "समाधान" की क्या सटीकता की उम्मीद है? 0.33 1/3 के बराबर नहीं है। आप "अच्छा" (पढ़ने में आसान) उत्तर कैसे पहचानते हैं?

कोई फर्क नहीं पड़ता कि, एक संभावित एल्गोरिदम हो सकता है:

यदि आप एक फॉर्म एक्स / वाई में निकटतम अंश प्राप्त करने की अपेक्षा करते हैं, जहां वाई 10 से कम है, तो आप प्रत्येक वाई कंप्यूट एक्स के लिए सभी 9 संभावित वाईएस को लूप कर सकते हैं, और फिर सबसे सटीक चुनें।


आप निम्न चरणों का उपयोग कर किसी भी प्रोग्रामिंग भाषा में ऐसा कर सकते हैं:

  1. 10 ^ x से गुणा करें और विभाजित करें जहां एक्स 10 की शक्ति है यह सुनिश्चित करने के लिए कि संख्या में कोई दशमलव स्थान शेष नहीं है। उदाहरण: इसे 333 बनाने के लिए 0.33 को 10 ^ 2 = 100 से गुणा करें और 33/100 प्राप्त करने के लिए इसे विभाजित करें
  2. परिणामी अंश के अंकनक और denominator को कारक द्वारा कम करें, जब तक आप परिणाम से पूर्णांक प्राप्त नहीं कर सकते।
  3. परिणामस्वरूप कम अंश आपका जवाब होना चाहिए।

उदाहरण: 0.2 = 0.2 x 10 ^ 1/10 ^ 1 = 2/10 = 1/5

तो, इसे '5 में से 1 भाग' के रूप में पढ़ा जा सकता है


आप पढ़ना चाहेंगे कि प्रत्येक कंप्यूटर वैज्ञानिक को फ़्लोटिंग प्वाइंट अंकगणित के बारे में क्या पता होना चाहिए

आपको बड़ी संख्या में गुणा करके कुछ सटीकता निर्दिष्ट करनी होगी:

3.141592 * 1000000 = 3141592

तो आप एक अंश बना सकते हैं:

3 + (141592 / 1000000)

और जीसीडी के माध्यम से कम ...

3 + (17699 / 125000)

लेकिन इच्छित अंश प्राप्त करने का कोई तरीका नहीं है। आप हमेशा अपने कोड के दौरान हमेशा भिन्नता का उपयोग करना चाहते हैं - जब आप अतिप्रवाह से बचने के लिए भिन्न हो सकते हैं तो भिन्नता को कम करना याद रखें!


आपको यह पता लगाना होगा कि आप किस स्तर की त्रुटि स्वीकार करना चाहते हैं। सभी दशमलव अंश एक साधारण अंश में कम नहीं होंगे। मैं शायद 60 की तरह आसानी से विभाजित संख्या चुनता हूं, और यह पता लगाता हूं कि कितने 60 वें मूल्य के सबसे नज़दीकी हैं, फिर अंश को सरल बनाएं।


आर में एक अंतर्निहित समाधान:

library(MASS)
fractions(0.666666666)
## [1] 2/3

यह एक निरंतर अंश विधि का उपयोग करता है और सटीक समायोजन के लिए वैकल्पिक cycles और max.denominator तर्क है।


एक समाधान है कि सभी संख्याओं को केवल तर्कसंगत संख्याओं के रूप में पहले स्थान पर स्टोर करें। तर्कसंगत संख्या अंकगणितीय (उदाहरण के लिए GMP ) के लिए पुस्तकालय हैं। यदि ओओ भाषा का उपयोग करना है तो आप अपनी संख्या वर्ग को बदलने के लिए केवल एक तर्कसंगत संख्या वर्ग पुस्तकालय का उपयोग करने में सक्षम हो सकते हैं।

वित्त कार्यक्रम, दूसरों के बीच, इस तरह के समाधान का उपयोग सटीक गणना करने में सक्षम होने के लिए करेंगे और एक सादे फ्लोट का उपयोग करके खोए जा सकने वाले परिशुद्धता को संरक्षित करेंगे।

बेशक यह बहुत धीमा हो जाएगा, इसलिए यह आपके लिए व्यावहारिक नहीं हो सकता है। इस पर निर्भर करता है कि आपको कितनी गणना करने की आवश्यकता है, और आपके लिए सटीकता कितनी महत्वपूर्ण है।

a = rational(1);
b = rational(3);
c = a / b;

print (c.asFraction)  --->  "1/3"
print (c.asFloat) ----> "0.333333"

एसी # कार्यान्वयन

/// <summary>
/// Represents a rational number
/// </summary>
public struct Fraction
{
    public int Numerator;
    public int Denominator;

    /// <summary>
    /// Constructor
    /// </summary>
    public Fraction(int numerator, int denominator)
    {
        this.Numerator = numerator;
        this.Denominator = denominator;
    }

    /// <summary>
    /// Approximates a fraction from the provided double
    /// </summary>
    public static Fraction Parse(double d)
    {
        return ApproximateFraction(d);
    }

    /// <summary>
    /// Returns this fraction expressed as a double, rounded to the specified number of decimal places.
    /// Returns double.NaN if denominator is zero
    /// </summary>
    public double ToDouble(int decimalPlaces)
    {
        if (this.Denominator == 0)
            return double.NaN;

        return System.Math.Round(
            Numerator / (double)Denominator,
            decimalPlaces
        );
    }


    /// <summary>
    /// Approximates the provided value to a fraction.
    /// http://.com/questions/95727/how-to-convert-floats-to-human-readable-fractions
    /// </summary>
    private static Fraction ApproximateFraction(double value)
    {
        const double EPSILON = .000001d;

        int n = 1;  // numerator
        int d = 1;  // denominator
        double fraction = n / d;

        while (System.Math.Abs(fraction - value) > EPSILON)
        {
            if (fraction < value)
            {
                n++;
            }
            else
            {
                d++;
                n = (int)System.Math.Round(value * d);
            }

            fraction = n / (double)d;
        }

        return new Fraction(n, d);
    }
}

दशमलव को एक अंश में परिवर्तित करने के पीछे गणित को समझाते हुए एक लिंक यहां दिया गया है:

http://www.webmath.com/dec2fract.html

और यहां एक उदाहरण समारोह है कि वास्तव में इसे VB का उपयोग करके कैसे करें (www.freevbcode.com/ShowCode.asp?ID=582 से):

Public Function Dec2Frac(ByVal f As Double) As String

   Dim df As Double
   Dim lUpperPart As Long
   Dim lLowerPart As Long

   lUpperPart = 1
   lLowerPart = 1

   df = lUpperPart / lLowerPart
   While (df <> f)
      If (df < f) Then
         lUpperPart = lUpperPart + 1
      Else
         lLowerPart = lLowerPart + 1
         lUpperPart = f * lLowerPart
      End If
      df = lUpperPart / lLowerPart
   Wend
Dec2Frac = CStr(lUpperPart) & "/" & CStr(lLowerPart)
End Function

(Google खोजों से: दशमलव से अंश में परिवर्तित करें, दशमलव को अंश कोड में परिवर्तित करें)


पायथन 2.6 से फ्रैक्शंस मॉड्यूल है।

(दस्तावेज़ों से उद्धरण।)

>>> from fractions import Fraction
>>> Fraction('3.1415926535897932').limit_denominator(1000)
Fraction(355, 113)

>>> from math import pi, cos
>>> Fraction.from_float(cos(pi/3))
Fraction(4503599627370497, 9007199254740992)
>>> Fraction.from_float(cos(pi/3)).limit_denominator()
Fraction(1, 2)

मैं एक विशेष रूप से सुरुचिपूर्ण हास्केल समाधान आया जो एक एनामोर्फिज्म का उपयोग कर रहा था। यह recursion-schemes पैकेज पर निर्भर करता है।

{-# LANGUAGE AllowAmbiguousTypes #-}
{-# LANGUAGE FlexibleContexts    #-}

import           Control.Applicative   (liftA2)
import           Control.Monad         (ap)
import           Data.Functor.Foldable
import           Data.Ratio            (Ratio, (%))

isInteger :: (RealFrac a) => a -> Bool
isInteger = ((==) <*>) (realToFrac . floor)

continuedFraction :: (RealFrac a) => a -> [Int]
continuedFraction = liftA2 (:) floor (ana coalgebra)
    where coalgebra x
              | isInteger x = Nil
              | otherwise = Cons (floor alpha) alpha
                  where alpha = 1 / (x - realToFrac (floor x))

collapseFraction :: (Integral a) => [Int] -> Ratio a
collapseFraction [x]    = fromIntegral x % 1
collapseFraction (x:xs) = (fromIntegral x % 1) + 1 / collapseFraction xs

-- | Use the nth convergent to approximate x
approximate :: (RealFrac a, Integral b) => a -> Int -> Ratio b
approximate x n = collapseFraction $ take n (continuedFraction x)

यदि आप ghci में इसे आज़माते हैं, तो यह वास्तव में काम करता है!

λ:> approximate pi 2
22 % 7

मैंने डेविड एपस्टीन के वास्तविक तर्कसंगत अनुमान को वास्तविक संख्या सी कोड देने के लिए पाया है जो आप पूछ रहे हैं। यह निरंतर भिन्नता के सिद्धांत और बहुत तेज और काफी कॉम्पैक्ट के सिद्धांत पर आधारित है।

मैंने विशिष्ट संख्यात्मक और denominator सीमाओं के लिए इस अनुकूलित संस्करण का उपयोग किया है।

/*
** find rational approximation to given real number
** David Eppstein / UC Irvine / 8 Aug 1993
**
** With corrections from Arno Formella, May 2008
**
** usage: a.out r d
**   r is real number to approx
**   d is the maximum denominator allowed
**
** based on the theory of continued fractions
** if x = a1 + 1/(a2 + 1/(a3 + 1/(a4 + ...)))
** then best approximation is found by truncating this series
** (with some adjustments in the last term).
**
** Note the fraction can be recovered as the first column of the matrix
**  ( a1 1 ) ( a2 1 ) ( a3 1 ) ...
**  ( 1  0 ) ( 1  0 ) ( 1  0 )
** Instead of keeping the sequence of continued fraction terms,
** we just keep the last partial product of these matrices.
*/

#include <stdio.h>

main(ac, av)
int ac;
char ** av;
{
    double atof();
    int atoi();
    void exit();

    long m[2][2];
    double x, startx;
    long maxden;
    long ai;

    /* read command line arguments */
    if (ac != 3) {
        fprintf(stderr, "usage: %s r d\n",av[0]);  // AF: argument missing
        exit(1);
    }
    startx = x = atof(av[1]);
    maxden = atoi(av[2]);

    /* initialize matrix */
    m[0][0] = m[1][1] = 1;
    m[0][1] = m[1][0] = 0;

    /* loop finding terms until denom gets too big */
    while (m[1][0] *  ( ai = (long)x ) + m[1][1] <= maxden) {
        long t;
        t = m[0][0] * ai + m[0][1];
        m[0][1] = m[0][0];
        m[0][0] = t;
        t = m[1][0] * ai + m[1][1];
        m[1][1] = m[1][0];
        m[1][0] = t;
        if(x==(double)ai) break;     // AF: division by zero
        x = 1/(x - (double) ai);
        if(x>(double)0x7FFFFFFF) break;  // AF: representation failure
    } 

    /* now remaining x is between 0 and 1/ai */
    /* approx as either 0 or 1/m where m is max that will fit in maxden */
    /* first try zero */
    printf("%ld/%ld, error = %e\n", m[0][0], m[1][0],
           startx - ((double) m[0][0] / (double) m[1][0]));

    /* now try other possibility */
    ai = (maxden - m[1][1]) / m[1][0];
    m[0][0] = m[0][0] * ai + m[0][1];
    m[1][0] = m[1][0] * ai + m[1][1];
    printf("%ld/%ld, error = %e\n", m[0][0], m[1][0],
           startx - ((double) m[0][0] / (double) m[1][0]));
}

यह एक "एल्गोरिदम" नहीं है, केवल एक पायथन समाधान: fractions

>>> from fractions import Fraction
>>> Fraction('3.1415926535897932').limit_denominator(1000)
Fraction(355, 113)

यहां जावास्क्रिप्ट में एक त्वरित और गंदे कार्यान्वयन है जो एक ब्रूट फोर्स दृष्टिकोण का उपयोग करता है। बिल्कुल अनुकूलित नहीं, यह भिन्नताओं की पूर्वनिर्धारित सीमा के भीतर काम करता है: http://jsfiddle.net/PdL23/1/

/* This should convert any decimals to a simplified fraction within the range specified by the two for loops. Haven't done any thorough testing, but it seems to work fine.

I have set the bounds for numerator and denominator to 20, 20... but you can increase this if you want in the two for loops.

Disclaimer: Its not at all optimized. (Feel free to create an improved version.)
*/

decimalToSimplifiedFraction = function(n) {

    for(num = 1; num < 20; num++) {  // "num" is the potential numerator
        for(den = 1; den < 20; den++) {  // "den" is the potential denominator
            var multiplyByInverse = (n * den ) / num;

            var roundingError = Math.round(multiplyByInverse) - multiplyByInverse;

            // Checking if we have found the inverse of the number, 
            if((Math.round(multiplyByInverse) == 1) && (Math.abs(roundingError) < 0.01)) {
                return num + "/" + den;
            }
        }
    }
};

//Put in your test number here.
var floatNumber = 2.56;

alert(floatNumber + " = " + decimalToSimplifiedFraction(floatNumber));

यह जेपीएस द्वारा उपयोग किए जाने वाले दृष्टिकोण से प्रेरित है।


रूबी पहले से ही समाधान में बनाया गया है:

0.33.rationalize.to_s # => "33/100"
0.4.rationalize.to_s # => "2/5"

रेल में, ActiveRecord संख्यात्मक विशेषताओं को भी परिवर्तित किया जा सकता है:

product.size = 0.33
product.size.to_r.to_s # => "33/100"

समस्या का एक हिस्सा यह है कि इतने सारे अंश वास्तव में आसानी से भिन्नता के रूप में नहीं माना जाता है। जैसे 0.33 1/3 नहीं है, यह 33/100 है। लेकिन अगर आपको अपना प्राथमिक विद्यालय प्रशिक्षण याद है, तो दशमलव मानों को भिन्नताओं में बदलने की प्रक्रिया है, हालांकि आप जो चाहते हैं उसे देने की संभावना नहीं है क्योंकि अधिकांश समय दशमलव संख्या 0.33 पर संग्रहीत नहीं होती है, लेकिन 0.329 99 99 99 99 99 8 या कुछ ऐसे।

अपने आप को एक पक्ष करो और इससे परेशान न हों, लेकिन अगर आपको इसकी आवश्यकता है तो आप निम्न कार्य कर सकते हैं:

जब तक आप आंशिक भाग को हटा नहीं देते तब तक मूल मान को 10 तक गुणा करें। उस नंबर को रखें, और इसे विभाजक के रूप में उपयोग करें। फिर सामान्य denominators की तलाश करके सरलीकरण की एक श्रृंखला करते हैं।

तो 0.4 4/10 होगा। फिर आप कम मूल्यों, संभवतः प्रमुख संख्याओं से शुरू होने वाले सामान्य divisors की तलाश करेंगे। 2 से शुरू होने पर, आप देखेंगे कि 2 विभाजनकर्ता और denominator दोनों को समान रूप से विभाजित करता है कि क्या विभाजन की मंजिल विभाजन के समान ही है।

floor(5/2) = 2
5/2 = 2.5

तो 5 समान रूप से 2 विभाजित नहीं करता है। तो फिर आप अगले नंबर की जांच करें, 3. कहें। जब तक आप छोटी संख्या के वर्ग रूट पर या ऊपर हिट नहीं करते हैं तब तक आप ऐसा करते हैं।

ऐसा करने के बाद आपको चाहिए


स्टर्न-ब्रोकॉट ट्री सरल संप्रदायों के साथ भिन्न संख्याओं को वास्तविक संख्याओं का अनुमान लगाने के लिए एक काफी प्राकृतिक तरीका प्रदान करती है।


इयान रिचर्ड्स / जॉन केनेडी द्वारा यह एल्गोरिदम न केवल अच्छे अंश देता है, यह गति के मामले में भी बहुत अच्छा प्रदर्शन करता है। यह मेरे द्वारा इस उत्तर से लिया गया सी # कोड है।

यह NaN और +/- अनंतता जैसे विशेष मानों को छोड़कर सभी double मानों को संभाल सकता है, यदि आवश्यक हो तो आपको जोड़ना होगा।

यह एक new Fraction(numerator, denominator) । अपने स्वयं के प्रकार से बदलें।

अधिक उदाहरण मानों और अन्य एल्गोरिदम के साथ तुलना के लिए, यहां जाएं

public Fraction RealToFraction(double value, double accuracy)
{
    if (accuracy <= 0.0 || accuracy >= 1.0)
    {
        throw new ArgumentOutOfRangeException("accuracy", "Must be > 0 and < 1.");
    }

    int sign = Math.Sign(value);

    if (sign == -1)
    {
        value = Math.Abs(value);
    }

    // Accuracy is the maximum relative error; convert to absolute maxError
    double maxError = sign == 0 ? accuracy : value * accuracy;

    int n = (int) Math.Floor(value);
    value -= n;

    if (value < maxError)
    {
        return new Fraction(sign * n, 1);
    }

    if (1 - maxError < value)
    {
        return new Fraction(sign * (n + 1), 1);
    }

    double z = value;
    int previousDenominator = 0;
    int denominator = 1;
    int numerator;

    do
    {
        z = 1.0 / (z - (int) z);
        int temp = denominator;
        denominator = denominator * (int) z + previousDenominator;
        previousDenominator = temp;
        numerator = Convert.ToInt32(value * denominator);
    }
    while (Math.Abs(value - (double) numerator / denominator) > maxError && z != (int) z);

    return new Fraction((n * denominator + numerator) * sign, denominator);
}

इस एल्गोरिदम द्वारा लौटाए गए उदाहरण मान:

Accuracy: 1.0E-3      | Richards                     
Input                 | Result           Error       
======================| =============================
   3                  |       3/1          0         
   0.999999           |       1/1         1.0E-6     
   1.000001           |       1/1        -1.0E-6     
   0.50 (1/2)         |       1/2          0         
   0.33... (1/3)      |       1/3          0         
   0.67... (2/3)      |       2/3          0         
   0.25 (1/4)         |       1/4          0         
   0.11... (1/9)      |       1/9          0         
   0.09... (1/11)     |       1/11         0         
   0.62... (307/499)  |       8/13        2.5E-4     
   0.14... (33/229)   |      16/111       2.7E-4     
   0.05... (33/683)   |      10/207      -1.5E-4     
   0.18... (100/541)  |      17/92       -3.3E-4     
   0.06... (33/541)   |       5/82       -3.7E-4     
   0.1                |       1/10         0         
   0.2                |       1/5          0         
   0.3                |       3/10         0         
   0.4                |       2/5          0         
   0.5                |       1/2          0         
   0.6                |       3/5          0         
   0.7                |       7/10         0         
   0.8                |       4/5          0         
   0.9                |       9/10         0         
   0.01               |       1/100        0         
   0.001              |       1/1000       0         
   0.0001             |       1/10000      0         
   0.33333333333      |       1/3         1.0E-11    
   0.333              |     333/1000       0         
   0.7777             |       7/9         1.0E-4     
   0.11               |      10/91       -1.0E-3     
   0.1111             |       1/9         1.0E-4     
   3.14               |      22/7         9.1E-4     
   3.14... (pi)       |      22/7         4.0E-4     
   2.72... (e)        |      87/32        1.7E-4     
   0.7454545454545    |      38/51       -4.8E-4     
   0.01024801004      |       2/195       8.2E-4     
   0.99011            |     100/101      -1.1E-5     
   0.26... (5/19)     |       5/19         0         
   0.61... (37/61)    |      17/28        9.7E-4     
                      | 
Accuracy: 1.0E-4      | Richards                     
Input                 | Result           Error       
======================| =============================
   0.62... (307/499)  |     299/486      -6.7E-6     
   0.05... (33/683)   |      23/476       6.4E-5     
   0.06... (33/541)   |      33/541        0         
   1E-05              |       1/99999     1.0E-5     
   0.7777             |    1109/1426     -1.8E-7     
   3.14... (pi)       |     333/106      -2.6E-5     
   2.72... (e)        |     193/71        1.0E-5     
   0.61... (37/61)    |      37/61         0         






numbers