Hướng dẫn continued fractions in python

Without further information, it's probably a Good Idea™ to use the simple continued fraction expansion of e, as shown in Wikipedia:

e = [2; 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8, 1, 1, 10, 1, 1, 12, 1, 1, ...]

This sequence can easily be created using a simple list comprehension.

To evaluate a simple continued fraction expansion we can process the list in reversed order.

The following code will work on Python 2 or Python 3.

#!/usr/bin/env python

''' Calculate e using its simple continued fraction expansion

    See //stackoverflow.com/q/36077810/4014959

    Also see
    //en.wikipedia.org/wiki/Continued_fraction#Regular_patterns_in_continued_fractions

    Written by PM 2Ring 2016.03.18
'''

from __future__ import print_function, division
import sys

def contfrac_to_frac[seq]:
    ''' Convert the simple continued fraction in `seq` 
        into a fraction, num / den
    '''
    num, den = 1, 0
    for u in reversed[seq]:
        num, den = den + num*u, num
    return num, den

def e_cont_frac[n]:
    ''' Build `n` terms of the simple continued fraction expansion of e
        `n` must be a positive integer
    '''
    seq = [2 * [i+1] // 3 if i%3 == 2 else 1 for i in range[n]]
    seq[0] += 1
    return seq

def main[]:
    # Get the the number of terms, less one
    n = int[sys.argv[1]] if len[sys.argv] > 1 else 11
    if n < 0:
        print['Argument must be >= 0']
        exit[]

    n += 1
    seq = e_cont_frac[n]
    num, den = contfrac_to_frac[seq]

    print['Terms =', n]
    print['Continued fraction:', seq]
    print['Fraction: {0} / {1}'.format[num, den]]
    print['Float {0:0.15f}'.format[num / den]]

if __name__ == '__main__':
    main[]

output

Terms = 12
Continued fraction: [2, 1, 2, 1, 1, 4, 1, 1, 6, 1, 1, 8]
Fraction: 23225 / 8544
Float 2.718281835205993

Pass the program an argument of 20 to get the best approximation possible using Python floats: 2.718281828459045

As Rory Daulton [& Wikipedia] mention, we don't need to reverse the continued fraction list. We can process it in the forward direction, but we need 2 more variables because we need to track 2 generations of numerators and denominators. Here's a version of contfrac_to_frac which does that.

def contfrac_to_frac[seq]:
    ''' Convert the simple continued fraction in `seq`
        into a fraction, num / den
    '''
    n, d, num, den = 0, 1, 1, 0
    for u in seq:
        n, d, num, den = num, den, num*u + n, den*u + d
    return num, den

Algorithm: Continued Fraction [Python]

Known time/storage complexity and/or correctness

The continued fraction of a real number $x\in\mathbb R$ can be computed by the following algorithm.1

1 Because floating point arithmetic IEEE-754 “double precision”, python doubles contain 53 bits of precision. Therefore, the algorithm not always computes the write values of the continued fraction. The algorithm also limits the computation to 20 values of the continued fraction, since some continued fractions are not finite.

Short Name

$\operatorname{contFrac}$

Input Parameters

real number $x\in\mathbb R$

Output Parameters

continued fraction $[x_0;x_1,x_2,\ldots]$

Python Code

import math

def contFrac[x, k]:
    cf = []
    q = math.floor[x]
    cf.append[q]
    x = x - q
    i = 0
    while x != 0 and i < k:
        q = math.floor[1 / x]
        cf.append[q]
        x = 1 / x - q
        i = i + 1
    return cf

# Usage
print[contFrac[math.sqrt[2]]]

# will output 
# [1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2]

1.Proof: [related to "Continued Fraction [Python]"]

[sign] numerator ['/' denominator]

>>> from fractions import Fraction
>>> Fraction[16, -10]
Fraction[-8, 5]
>>> Fraction[123]
Fraction[123, 1]
>>> Fraction[]
Fraction[0, 1]
>>> Fraction['3/7']
Fraction[3, 7]
>>> Fraction[' -3/7 ']
Fraction[-3, 7]
>>> Fraction['1.414213 \t\n']
Fraction[1414213, 1000000]
>>> Fraction['-.125']
Fraction[-1, 8]
>>> Fraction['7e-6']
Fraction[7, 1000000]
>>> Fraction[2.25]
Fraction[9, 4]
>>> Fraction[1.1]
Fraction[2476979795053773, 2251799813685248]
>>> from decimal import Decimal
>>> Fraction[Decimal['1.1']]
Fraction[11, 10]

>>> from fractions import Fraction
>>> Fraction['3.1415926535897932'].limit_denominator[1000]
Fraction[355, 113]

>>> from math import pi, cos
>>> Fraction[cos[pi/3]]
Fraction[4503599627370497, 9007199254740992]
>>> Fraction[cos[pi/3]].limit_denominator[]
Fraction[1, 2]
>>> Fraction[1.1].limit_denominator[]
Fraction[11, 10]

How do you round in math in Python?

Python has a built-in round[] function that takes two numeric arguments, n and ndigits , and returns the number n rounded to ndigits . The ndigits argument defaults to zero, so leaving it out results in a number rounded to an integer.

Do fractions work in Python?

In Python the Fraction module supports rational number arithmetic. Using this module, we can create fractions from integers, floats, decimal and from some other numeric values and strings. There is a concept of Fraction Instance. It is formed by a pair of integers as numerator and denominator.

How do you round a decimal number in Python?

Python round[] Function The round[] function returns a floating point number that is a rounded version of the specified number, with the specified number of decimals. The default number of decimals is 0, meaning that the function will return the nearest integer.