我的程序(6):分數小數互相轉換

# -*- coding: utf-8 -*-
#author : wayne   http://blog.csdn.net/wayne92/
#email:[email protected]

import time

def decimal_to_fraction(value,radix):
    '''
        把小數轉換爲分數。
        方法：比如輸入0.21，radix爲2.那麼0.21=21/100，因爲要求分母爲
        2位，所以分母要變小，所以分子也要隨着變小。分子的範圍就是[1,21].
        根據每個分子的不同，int(分母)=分子/0.23, 再由分子/分母得出一個近似值。
        只要找出誤差最小的那個就可以了。
        Args:
            value:小數的值。
            radix：分母的位數。
        Returns：
            返回tuple：(正負號，整數部分，分子，分母，
            (分子/分母)的值，(分子/分母)表示的循環小數，誤差)
    '''
    #if str(value) == repr(value): 
    #    return None
    
    if value < 0:    #把負數轉換爲正數
        sign = '-'
        value = abs(value)
    else:
        sign = '+'
        
    base = 10**radix   
    integer = int(str(value).split('.')[0])   #整數部分
    value = value - integer                   #小數部分
    min_error = 1                             #最小誤差
    best = None                               #返回tuple
    circulator = 0                            #得到分數的循環小數
    
    int_numerator = int(value*base)          #int_numerator爲分子的最大值
    
    
    for numerator in range(int_numerator,0,-1):
        result = numerator / value
        denominator = int(result+0.5)
        if denominator == base:
            continue
        
        my_value = float(numerator)/denominator
        error = abs(my_value - value)
        
        if min_error > error:
            min_error = error
            circulator = fraction_to_circulator(numerator,denominator)
            best = (sign,integer,numerator,denominator,my_value,circulator,min_error)
            if min_error == 0:  #找到第一個誤差爲0的值，就退出.如果不這樣處理，效率會低很多。 
                break
          
    return best

def fraction_to_circulator(dividend, divisor, precision=1000): 
    '''
        把分數轉換爲循環小數。
        理論依據：任何分數都可以轉換爲有限小數或者無限循環小數。
        Args:
            dividend： 被除數
            divisor：  除數
            precision：精度。即計算循環小數時，最多計算到的小數點後多少位
        Returns:
            循環小數(字符串)。格式爲：1.2(34)。括號中的是循環體。
    '''
    pos = 0
    modDict = {}
    frac = []
    is_circulator = False       #是否存在循環
    
    div, mod= divmod(dividend, divisor) 
    intPart = str(div) + '.' 
    
    #模擬手算的過程，發現有相同的餘數就說明發現循環
    while pos < precision and mod != 0 : 
        modDict[mod] = pos 
        mod *= 10 
        div, mod = divmod (mod, divisor) 
        frac.append(str(div)) 
        if mod in modDict.keys():
            is_circulator = True
            break 
        pos += 1 
        
    if is_circulator:                       # 發現循環 
        frac.insert(modDict[mod],'(') 
        frac.append(')') 
    return intPart + ''.join(frac) 

  
def circulator_to_fraction(circulator):
    '''
        把循環小數轉換爲分數。
        理論依據：每個循環小數都可以很精確的用一個分數來表示。
        方法：比如輸入0.23(45).先記錄循環體的位置，再轉換爲0.2345。
        0.2345... × 100   = 23.45...  （1）
        0.2345... × 10000 = 2345.45... (2) #這裏100和10000是算出來的，不是亂寫的
        用(2) - (1),得：
            0.2345... * 9900 = 2345 - 23 = 2322
        所以0.2345... 的分數表示就是 2322/9900.
        Args:
            circulator：循環小數(字符串)。格式爲：1.2(34)。括號中的是循環體。
        Returns：
            如果格式輸入有錯誤，顯示提示，返回None。
            否則返回tuple(分子，分母)。
    '''
    dot = circulator.find('.')
    left_p = circulator.find('(')
    rigth_p = circulator.find(')')

    if dot == -1 or left_p == -1 or rigth_p == -1:
        print u'輸入循環小數格式錯誤'
        print u'輸入格式爲 1.23(45)，其中45爲循環體'
        return None
    
    true_circulator = float(circulator[:left_p] + circulator[left_p+1:-1])

    first_shift = left_p-dot-1
    second_shift = rigth_p-left_p-1+first_shift
    
    first_base = 10**first_shift
    second_base = 10**second_shift

    denominator = second_base - first_base  #分母
    numerator = int(true_circulator*second_base) 
                - int(true_circulator*first_base)  #分子
                
    return (numerator,denominator)

if __name__ == '__main__':
    
    begin = time.time()
    
    print decimal_to_fraction(0.0629226211751451,2)
    #print fraction_to_circulator(24,999) 
    #print circulator_to_fraction('0.78(0234)')
    
    end = time.time()
    print 'cost time is %f'%(end - begin)
    

 
利用這種方法實現分數小數的互相轉換，發現比ET要準確。ET下一個版本用我的算法吧，呵呵