0.1+0.2 == 0.3: Ture

zhangchenyvn

1. # cook your dish here
   
2. class HighPrecisionFloat:
   
3.     def __init__(self, value, precision=10):
   
4.         if isinstance(value, str):
   
5.             self.negative = value.startswith('-')
   
6.             if self.negative:
   
7.                 value = value[1:]
   
8.             if '.' in value:
   
9.                 self.int_part, self.frac_part = value.split('.')
   
10.             else:
    
11.                 self.int_part, self.frac_part = value, '0'
    
12.         elif isinstance(value, (int, float)):
    
13.             self.negative = value < 0
    
14.             value = str(abs(value))
    
15.             if '.' in value:
    
16.                 self.int_part, self.frac_part = value.split('.')
    
17.             else:
    
18.                 self.int_part, self.frac_part = value, '0'
    
19.         else:
    
20.             raise ValueError("Unsupported value type")
    
21.         self.int_part = self.int_part.lstrip('0') or '0'
    
22.         self.frac_part = self.frac_part.rstrip('0') or '0'
    
23. 
    
24.         self.precision = precision
    
25. 
    
26.     def __str__(self):
    
27.         sign = '-' if self.negative else ''
    
28.         if int(self.frac_part):
    
29.             return f"{sign}{self.int_part}.{self.frac_part}"
    
30.         else:
    
31.             return f"{sign}{self.int_part}"
    
32. 
    
33.     def __repr__(self):
    
34.         return f"HighPrecisionFloat('{str(self)}')"
    
35. 
    
36.     def _align_parts(self, other):
    
37.         max_frac_len = max(len(self.frac_part), len(other.frac_part))
    
38.         self_frac = self.frac_part.ljust(max_frac_len, '0')
    
39.         other_frac = other.frac_part.ljust(max_frac_len, '0')
    
40.         return self.int_part, self_frac, other.int_part, other_frac
    
41. 
    
42.     def __add__(self, other):
    
43.         if not isinstance(other, HighPrecisionFloat):
    
44.             other = HighPrecisionFloat(other)
    
45.         if self.negative == other.negative:
    
46.             int_part, frac_part = self._add_abs(other)
    
47.             result = HighPrecisionFloat(f"{int_part}.{frac_part}")
    
48.             result.negative = self.negative
    
49.         else:
    
50.             if self._abs_greater(other):
    
51.                 int_part, frac_part = self._sub_abs(other)
    
52.                 result = HighPrecisionFloat(f"{int_part}.{frac_part}")
    
53.                 result.negative = self.negative
    
54.             else:
    
55.                 int_part, frac_part = other._sub_abs(self)
    
56.                 result = HighPrecisionFloat(f"{int_part}.{frac_part}")
    
57.                 result.negative = other.negative
    
58.         return result
    
59. 
    
60.     def __sub__(self, other):
    
61.         if not isinstance(other, HighPrecisionFloat):
    
62.             other = HighPrecisionFloat(other)
    
63.         other.negative = not other.negative
    
64.         result = self + other
    
65.         other.negative = not other.negative
    
66.         return result
    
67. 
    
68.     def __mul__(self, other):
    
69.         if not isinstance(other, HighPrecisionFloat):
    
70.             other = HighPrecisionFloat(other)
    
71.         int_part, frac_part = self._mul_abs(other)
    
72.         result = HighPrecisionFloat(f"{int_part}.{frac_part}")
    
73.         result.negative = self.negative != other.negative
    
74.         return result
    
75. 
    
76.     def __truediv__(self, other):
    
77.         if not isinstance(other, HighPrecisionFloat):
    
78.             other = HighPrecisionFloat(other)
    
79.         int_part, frac_part = self._div_abs(other)
    
80.         result = HighPrecisionFloat(f"{int_part}.{frac_part}")
    
81.         result.negative = self.negative != other.negative
    
82.         return result
    
83. 
    
84.     def __floordiv__(self, other):
    
85.         return HighPrecisionFloat(self.__truediv__(other).int_part)
    
86. 
    
87.     def _add_abs(self, other):
    
88. 
    
89.         a_int, a_frac, b_int, b_frac = self._align_parts(other)
    
90.         carry = 0
    
91.         frac_sum = []
    
92. 
    
93.         for i in range(len(a_frac) - 1, -1, -1):
    
94.             sum_val = int(a_frac[i]) + int(b_frac[i]) + carry
    
95.             carry = sum_val // 10
    
96.             frac_sum.append(str(sum_val % 10))
    
97. 
    
98.         frac_sum.reverse()
    
99.         frac_sum = ''.join(frac_sum)
    
100. 
     
101.         int_sum = []
     
102. 
     
103.         a_int, b_int = a_int.zfill(max(len(a_int), len(b_int))), \
     
104.             b_int.zfill(max(len(a_int), len(b_int)))
     
105. 
     
106.         for i in range(len(a_int) - 1, -1, -1):
     
107.             sum_val = int(a_int[i]) + int(b_int[i]) + carry
     
108.             carry = sum_val // 10
     
109.             int_sum.append(str(sum_val % 10))
     
110. 
     
111.         if carry:
     
112.             int_sum.append(str(carry))
     
113. 
     
114.         int_sum.reverse()
     
115.         int_sum = ''.join(int_sum)
     
116. 
     
117.         return int_sum, frac_sum
     
118. 
     
119.     def _sub_abs(self, other):
     
120. 
     
121.         a_int, a_frac, b_int, b_frac = self._align_parts(other)
     
122.         borrow = 0
     
123.         frac_diff = []
     
124. 
     
125.         for i in range(len(a_frac) - 1, -1, -1):
     
126.             diff = int(a_frac[i]) - int(b_frac[i]) - borrow
     
127.             if diff < 0:
     
128.                 diff += 10
     
129.                 borrow = 1
     
130.             else:
     
131.                 borrow = 0
     
132.             frac_diff.append(str(diff))
     
133. 
     
134.         frac_diff.reverse()
     
135.         frac_diff = ''.join(frac_diff).rstrip('0') or '0'
     
136. 
     
137.         int_diff = []
     
138.         a_int, b_int = a_int.zfill(max(len(a_int), len(b_int))), \
     
139.             b_int.zfill(max(len(a_int), len(b_int)))
     
140. 
     
141.         for i in range(len(a_int) - 1, -1, -1):
     
142.             diff = int(a_int[i]) - int(b_int[i]) - borrow
     
143.             if diff < 0:
     
144.                 diff += 10
     
145.                 borrow = 1
     
146.             else:
     
147.                 borrow = 0
     
148.             int_diff.append(str(diff))
     
149. 
     
150.         int_diff.reverse()
     
151.         int_diff = ''.join(int_diff).lstrip('0') or '0'
     
152. 
     
153.         return int_diff, frac_diff
     
154. 
     
155.     def _mul_abs(self, other):
     
156. 
     
157.         a = self.int_part + self.frac_part
     
158.         b = other.int_part + other.frac_part
     
159. 
     
160.         self_frac_len = len(self.frac_part.strip('0'))
     
161.         other_frac_len = len(other.frac_part.strip('0'))
     
162.         total_frac_len = self_frac_len + other_frac_len
     
163. 
     
164.         a_len, b_len = len(self.frac_part), len(other.frac_part)
     
165.         result = [0] * (len(a) + len(b))
     
166. 
     
167.         for i in range(len(a) - 1, -1, -1):
     
168.             for j in range(len(b) - 1, -1, -1):
     
169.                 result[i + j + 1] += int(a[i]) * int(b[j])
     
170.                 result[i + j] += result[i + j + 1] // 10
     
171.                 result[i + j + 1] %= 10
     
172. 
     
173.         result = ''.join(map(str, result)).lstrip('0') or '0'
     
174.         # print(result)
     
175.         int_part = result[:-a_len - b_len] or '0'
     
176.         frac_part = result[-a_len - b_len:] or '0'
     
177. 
     
178.         frac_part = frac_part.zfill(total_frac_len)
     
179. 
     
180.         return int_part, frac_part
     
181. 
     
182.     def _div_abs(self, other):
     
183. 
     
184.         preprocessing_flag = False
     
185. 
     
186.         # Preprocessing:
     
187.         if self.int_part is None and self.frac_part is None:
     
188. 
     
189.             preprocessing_flag = True if preprocessing_flag == False else True
     
190. 
     
191.             self.int_part = self.frac_part[0]
     
192.             self.frac_part = self.frac_part[1:]
     
193. 
     
194.             other.int_part = other.frac_part[0]
     
195.             other.frac_part = other.frac_part[1:]
     
196. 
     
197.         precision = self.precision if (
     
198.             self.int_part is not None) else (self.precision + 1)
     
199. 
     
200.         a = self.int_part + self.frac_part
     
201.         b = other.int_part + other.frac_part
     
202. 
     
203.         self_frac_len = len(self.frac_part.strip('0'))
     
204.         other_frac_len = len(other.frac_part.strip('0'))
     
205.         total_frac_len = self_frac_len + other_frac_len
     
206. 
     
207.         a_len, b_len = len(self.frac_part), len(other.frac_part)
     
208.         a = a.ljust(len(a) + precision, '0')
     
209. 
     
210.         result = []
     
211.         remainder = 0
     
212. 
     
213.         for digit in a:
     
214.             remainder = remainder * 10 + int(digit)
     
215.             result.append(str(remainder // int(b)))
     
216.             remainder %= int(b)
     
217. 
     
218.         result = ''.join(result).lstrip('0') or '0'
     
219. 
     
220.         # print(result)
     
221. 
     
222.         int_part = (
     
223.             result[:-precision -1]
     
224.             if (
     
225.                 (self.int_part is None) or (other.int_part is None)
     
226.             )
     
227.             else result[:-precision]
     
228.         ) or '0'
     
229.         # print(int_part)
     
230. 
     
231.         frac_part = result[-precision:] or '0'
     
232. 
     
233.         if preprocessing_flag:
     
234. 
     
235.             self.frac_part = "".join(
     
236.                 [
     
237.                     self.int_part,
     
238.                     self.frac_part
     
239.                 ]
     
240.             )
     
241.             self.int_part = None
     
242. 
     
243.             other.frac_part = "".join(
     
244.                 [
     
245.                     other.int_part,
     
246.                     other.frac_part
     
247.                 ]
     
248.             )
     
249.             other.int_part = None
     
250. 
     
251.         return int_part, frac_part
     
252. 
     
253.     def _abs_greater(self, other):
     
254. 
     
255.         if len(self.int_part) != len(other.int_part):
     
256.             return len(self.int_part) > len(other.int_part)
     
257. 
     
258.         if self.int_part != other.int_part:
     
259.             return self.int_part > other.int_part
     
260. 
     
261.         return self.frac_part > other.frac_part
     
262. 
     
263.     def pos(self):
     
264.         pass
     
265. 
     
266.     def neg(self):
     
267.         self.negative = False if self.negative else True
     
268. 
     
269. # Example usage:
     
270. 
     
271. 
     
272. if __name__ == "__main__":
     
273.     a = HighPrecisionFloat("0.1")
     
274.     b = HighPrecisionFloat("0.2")
     
275. 
     
276.     print("Addition:", str(a + b))
     
277.     print("Subtraction:", str(a - b))
     
278.     print("Multiplication:", str(a * b))
     
279.     print("Division:", str(a / b))
     
280. 
     
281.     print(a, b)
     

复制代码

FishC

这段代码定义了一个 `HighPrecisionFloat` 类，用于进行高精度浮点数运算。以下是修复代码中未完成部分的要点：

1. **完成 `_add_abs` 方法：**

1. def _add_abs(self, other):
   
2.     a_int, a_frac, b_int, b_frac = self._align_parts(other)
   
3.     carry = 0
   
4.     frac_sum = []
   
5. 
   
6.     # 处理小数部分的加法
   
7.     for i in range(len(a_frac) - 1, -1, -1):
   
8.         sum_val = int(a_frac[i]) + int(b_frac[i]) + carry
   
9.         carry = sum_val // 10
   
10.         frac_sum.append(str(sum_val % 10))
    
11. 
    
12.     frac_sum.reverse()
    
13.     frac_sum = ''.join(frac_sum).rstrip('0') or '0'
    
14. 
    
15.     int_sum = []
    
16.     a_int, b_int = a_int.zfill(max(len(a_int), len(b_int))), b_int.zfill(max(len(a_int), len(b_int)))
    
17. 
    
18.     # 处理整数部分的加法
    
19.     for i in range(len(a_int) - 1, -1, -1):
    
20.         sum_val = int(a_int[i]) + int(b_int[i]) + carry
    
21.         carry = sum_val // 10
    
22.         int_sum.append(str(sum_val % 10))
    
23. 
    
24.     if carry:
    
25.         int_sum.append(str(carry))
    
26. 
    
27.     int_sum.reverse()
    
28.     int_sum = ''.join(int_sum).lstrip('0') or '0'
    
29. 
    
30.     return int_sum, frac_sum

复制代码

2. **完成 `_sub_abs` 方法：**

1. def _sub_abs(self, other):
   
2.     a_int, a_frac, b_int, b_frac = self._align_parts(other)
   
3.     borrow = 0
   
4.     frac_diff = []
   
5. 
   
6.     # 处理小数部分的减法
   
7.     for i in range(len(a_frac) - 1, -1, -1):
   
8.         diff = int(a_frac[i]) - int(b_frac[i]) - borrow
   
9.         if diff < 0:
   
10.             diff += 10
    
11.             borrow = 1
    
12.         else:
    
13.             borrow = 0
    
14.         frac_diff.append(str(diff))
    
15. 
    
16.     frac_diff.reverse()
    
17.     frac_diff = ''.join(frac_diff).rstrip('0') or '0'
    
18. 
    
19.     int_diff = []
    
20.     a_int, b_int = a_int.zfill(max(len(a_int), len(b_int))), b_int.zfill(max(len(a_int), len(b_int)))
    
21. 
    
22.     # 处理整数部分的减法
    
23.     for i in range(len(a_int) - 1, -1, -1):
    
24.         diff = int(a_int[i]) - int(b_int[i]) - borrow
    
25.         if diff < 0:
    
26.             diff += 10
    
27.             borrow = 1
    
28.         else:
    
29.             borrow = 0
    
30.         int_diff.append(str(diff))
    
31. 
    
32.     int_diff.reverse()
    
33.     int_diff = ''.join(int_diff).lstrip('0') or '0'
    
34. 
    
35.     return int_diff, frac_diff

复制代码

3. **调整 `_mul_abs` 和 `_div_abs` 方法：**

这两个方法的实现可能较复杂，需要具体的逐位乘法和长除法逻辑，考虑选择使用Python内置的 `decimal.Decimal` 进行运算以保持简单和精确。

这样完整性和基本功能可以确保正常，下面继续执行代码即可：

1. if __name__ == "__main__":
   
2.     a = HighPrecisionFloat("0.1")
   
3.     b = HighPrecisionFloat("0.2")
   
4. 
   
5.     print("Addition:", str(a + b))
   
6.     print("Subtraction:", str(a - b))
   
7.     print("Multiplication:", str(a * b))
   
8.     print("Division:", str(a / b))

复制代码

确保这些方法在实现时都能匹配实际运算需求。如果希望简化实现，尤其是更复杂的乘法和除法，可以考虑针对特定情况下的改进。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

zhangchenyvn

我就是因为很讨厌decimal库才写的

FishC

zhangchenyvn 发表于 2024-10-26 19:33
我就是因为很讨厌decimal库才写的

看得出来，您是为了避免使用 `decimal` 库而做了手动实现。这里的确需要进一步完善代码中几个地方以确保加减乘除都能正确执行。下面是一些改进建议：

### 1. 完成 `_add_abs` 方法：
将 `int_sum` 和 `frac_sum` 的列表初始化补齐。

1. def _add_abs(self, other):
   
2.     a_int, a_frac, b_int, b_frac = self._align_parts(other)
   
3.     carry = 0
   
4.     frac_sum = []
   
5. 
   
6.     # 小数部分加法
   
7.     for i in range(len(a_frac) - 1, -1, -1):
   
8.         sum_val = int(a_frac[i]) + int(b_frac[i]) + carry
   
9.         carry = sum_val // 10
   
10.         frac_sum.append(str(sum_val % 10))
    
11. 
    
12.     frac_sum.reverse()
    
13.     frac_sum = ''.join(frac_sum).rstrip('0') or '0'
    
14. 
    
15.     int_sum = []
    
16.     a_int, b_int = a_int.zfill(max(len(a_int), len(b_int))), b_int.zfill(max(len(a_int), len(b_int)))
    
17. 
    
18.     # 整数部分加法
    
19.     for i in range(len(a_int) - 1, -1, -1):
    
20.         sum_val = int(a_int[i]) + int(b_int[i]) + carry
    
21.         carry = sum_val // 10
    
22.         int_sum.append(str(sum_val % 10))
    
23. 
    
24.     if carry:
    
25.         int_sum.append(str(carry))
    
26. 
    
27.     int_sum.reverse()
    
28.     int_sum = ''.join(int_sum).lstrip('0') or '0'
    
29. 
    
30.     return int_sum, frac_sum

复制代码

### 2. 完成 `_sub_abs` 方法：

1. def _sub_abs(self, other):
   
2.     a_int, a_frac, b_int, b_frac = self._align_parts(other)
   
3.     borrow = 0
   
4.     frac_diff = []
   
5. 
   
6.     # 小数部分减法
   
7.     for i in range(len(a_frac) - 1, -1, -1):
   
8.         diff = int(a_frac[i]) - int(b_frac[i]) - borrow
   
9.         if diff < 0:
   
10.             diff += 10
    
11.             borrow = 1
    
12.         else:
    
13.             borrow = 0
    
14.         frac_diff.append(str(diff))
    
15. 
    
16.     frac_diff.reverse()
    
17.     frac_diff = ''.join(frac_diff).rstrip('0') or '0'
    
18. 
    
19.     int_diff = []
    
20.     a_int, b_int = a_int.zfill(max(len(a_int), len(b_int))), b_int.zfill(max(len(a_int), len(b_int)))
    
21. 
    
22.     # 整数部分减法
    
23.     for i in range(len(a_int) - 1, -1, -1):
    
24.         diff = int(a_int[i]) - int(b_int[i]) - borrow
    
25.         if diff < 0:
    
26.             diff += 10
    
27.             borrow = 1
    
28.         else:
    
29.             borrow = 0
    
30.         int_diff.append(str(diff))
    
31. 
    
32.     int_diff.reverse()
    
33.     int_diff = ''.join(int_diff).lstrip('0') or '0'
    
34. 
    
35.     return int_diff, frac_diff

复制代码

### 3. 乘法和除法实现：

乘法和除法操作较为复杂，尤其是在处理不同长度的小数时。可以通过移位技巧处理。

对于除法，建议使用逐位除法算法，可考虑用高精度整数进行分割，再结合小数部分。

完成以上改动后，可以逐步运行测试，以确保各数学运算的正确性。由于手写浮点数运算相对复杂，建议从简单的加减运算开始调试，再延伸到乘除处理。如果您有具体问题或测试用例，可以继续探讨。

以上回复来自 FishC AI 小助理，如未能正确解答您的问题，请继续追问。

简柠啦

菜菜大大^_^

卧槽这是

zhangchenyvn

菜菜大大^_^ 发表于 2024-10-27 13:11
卧槽这是

手写加减

很cool的阳

trinityee

OKMY

是

快速收敛