连分式
连分式(continued fraction)由和与倒数的多层嵌套构成,可以是有限的,也可以是无限的。
表达式:
或
import math
def fraction_to_continued_fraction(numerator, denominator, max_terms):
"""
计算一个分数的连分式表示。
参数:
numerator (int): 分数的分子。
denominator (int): 分数的分母。
max_terms (int): 连分式表示的最大项数。
返回:
list: 连分式的部分分母组成的列表。
"""
coefficients = []
current_numerator = numerator
current_denominator = denominator
while current_denominator != 0 and len(coefficients) < max_terms:
quotient = current_numerator // current_denominator
coefficients.append(quotient)
remainder = current_numerator % current_denominator
current_numerator, current_denominator = current_denominator, remainder
return coefficients
def continued_fraction_to_decimal(coefficients):
"""
将连分式转换为十进制表示的数字。
参数:
coefficients (list): 连分式的部分分母组成的列表。
返回:
float: 连分式对应的十进制数。
"""
if not coefficients:
return 0.0
decimal_value = coefficients[-1]
for coefficient in reversed(coefficients[:-1]):
decimal_value = 1 / decimal_value + coefficient
return decimal_value
def real_number_to_continued_fraction(x, error_tolerance, max_terms):
"""
计算一个实数的连分式表示,考虑误差容忍度和最大项数。
参数:
x (float): 要表示的实数。
error_tolerance (float): 允许的误差范围。
max_terms (int): 连分式表示的最大项数。
返回:
list: 连分式的部分分母组成的列表。
"""
coefficients = []
integer_part = int(x)
fractional_part = x - integer_part
coefficients.append(integer_part)
while fractional_part > error_tolerance and len(coefficients) < max_terms:
reciprocal = 1 / fractional_part
next_term = int(reciprocal)
coefficients.append(next_term)
fractional_part = reciprocal - next_term
current_decimal = continued_fraction_to_decimal(coefficients)
if abs(current_decimal - x) < error_tolerance:
break
return coefficients
if __name__ == '__main__':
fraction_test = fraction_to_continued_fraction(105, 33, 10)
print('该测试分数的连分式表示:', fraction_test)
print('测试分数的分布式转十进制数为:', continued_fraction_to_decimal(fraction_test))
# 计算小数3.1415926的连分式表示
pi_value = 3.1415926 # 近似π值
error_tolerance = 1e-5 # 误差容忍度
max_terms = 10 # 连分式的最大项数
pi_fraction_real = real_number_to_continued_fraction(pi_value, error_tolerance, max_terms)
print("小数3.1415926的连分式表示:", pi_fraction_real)
该测试分数的连分式表示: [3, 5, 2]
测试分数的分布式转十进制数为: 3.1818181818181817
小数3.1415926的连分式表示: [3, 7, 15, 1]
无穷连根式
表达式:
![]()
import math
def infinite_nested_radical_recursive(a, n):
"""
递归计算无穷连根式的近似值。
参数:
a (float): 连根式中的常数。
n (int): 递归深度,用于近似计算。
返回:
float: 无穷连根式的近似值。
"""
if n == 1:
return math.sqrt(a)
return math.sqrt(a + infinite_nested_radical_recursive(a, n - 1))
# 示例:计算 a = 2 的无穷连根式近似值
a = 2
recursion_depth = 10
approximation_recursive = infinite_nested_radical_recursive(a, recursion_depth)
print(f"a = {a} 的无穷连根式近似值 (递归深度 {recursion_depth}): {approximation_recursive}")
a = 2 的无穷连根式近似值 (递归深度 10): 1.9999976469034038
平方根
可以使用巴比伦算法求数字的平方根。
假设数字为
,步骤如下:
- 猜测
,作为
的猜测值
- 计算
- 将
和
的平均值当作新的猜测值
- 重复步骤2和3,直到
足够小
import math
def babylonian_sqrt(value, initial_guess, tolerance):
"""
使用巴比伦算法计算平方根的近似值。
参数:
value (float): 要求平方根的数。
initial_guess (float): 初始猜测值。
tolerance (float): 误差容忍度。
返回:
float: 近似的平方根值。
"""
current_error = tolerance * 2 # 初始设置一个较大的误差值
guess = initial_guess
while current_error > tolerance:
quotient = value / guess
new_guess = (guess + quotient) / 2
current_error = abs(new_guess**2 - value)
guess = new_guess
return guess
# 测试平方根计算
value_to_sqrt = 5
initial_guess = 1
tolerance = 1e-15
approx_sqrt = babylonian_sqrt(value_to_sqrt, initial_guess, tolerance)
print(f"使用巴比伦算法计算的 {value_to_sqrt} 的平方根近似值: {approx_sqrt}")
print(f"math.sqrt({value_to_sqrt}) 的结果: {math.sqrt(value_to_sqrt)}")
标签:根式,value,current,sqrt,fraction,平方根,coefficients,分式 From: https://blog.csdn.net/weixin_74254879/article/details/140781660使用巴比伦算法计算的 5 的平方根近似值: 2.23606797749979
math.sqrt(5) 的结果: 2.23606797749979