def raw_div_bits(a: List[Bit], b: List[Bit]) -> List[Bit]:
"""
같은 길이의 Bit List를 나누는 ( / ) 함수
left-shift ( << ) 연산과 add ( + ) 연산, lower-equal ( <= ) 연산을 통해 나눗셈 구현
상위 비트부터 하위 비트까지 값을 빼면서 몫을 구함
:param a: / 앞의 Bit List
:param b: 나눌 Bit List
:return: a / b의 값인 Bit List
"""
if BitOperation.is_empty(b):
raise ZeroDivisionError()
remain = BitOperation.empty_bits(len(a))
res = BitOperation.empty_bits(len(a))
one = BitOperation.fit_bits(BitOperation.num_map['1'], len(a))
for i in range(len(a) - 1, -1, -1):
first_bit = BitOperation.first_bit_index(b)
if first_bit < i:
continue
div = BitOperation.raw_lshift_bits(b, i)
sum_val, overflow = Arithmetic.raw_add_bits(remain, div)
if overflow:
continue
if BitOperation.raw_le_bits(sum_val, a):
remain, _ = Arithmetic.raw_add_bits(remain, div)
quotient = BitOperation.raw_lshift_bits(one, i)
res = BitOperation.raw_or_bits(res, quotient)
return res
def str_to_minor(real: List[Bit], val: str, digit: int,
length: int) -> (List[Bit], int):
"""
소수점 아래의 값을 표현하는 문자열을 읽어 Bit List를 생성하는 함수
:param real: 소수점 위의 값의 Bit List
:param val: 소수점 아래의 값을 표현하는 문자열
:param digit: 소수점 위의 자리수
:param length: 원하는 Bit List의 길이
:return: 문자열 실수값에 해당하는 Bit List, 자리수
"""
real, ten = BitOperation.equalize_bit_length(
real, BitOperation.num_map['10'], length)
base = BitOperation.fit_bits(BitOperation.num_map['1'], length)
twenty = BitOperation.raw_lshift_bits(ten, 1)
remain = BitOperation.empty_bits(length)
shift = 1
index = 0
while True:
if index < len(val) and index < 6:
remain = Arithmetic.raw_mul_bits(remain, twenty)
next_digit = BitOperation.lshift_bits(
BitOperation.num_map[val[index]], shift, length)
remain, _ = Arithmetic.raw_add_bits(remain, next_digit)
index += 1
shift += 1
base = Arithmetic.raw_mul_bits(base, ten)
else:
remain = BitOperation.raw_lshift_bits(remain, 1)
if BitOperation.is_empty(BitOperation.raw_or_bits(
remain, real)):
return real, -127
real = BitOperation.raw_lshift_bits(real, 1)
if BitOperation.raw_ge_bits(remain, base):
real, _ = Arithmetic.add_bits(real, BitOperation.num_map['1'],
length)
remain, _ = Arithmetic.sub_bits(remain, base, length)
if BitOperation.first_bit_index(real) == 0:
remain = BitOperation.raw_lshift_bits(remain, 1)
if BitOperation.raw_ge_bits(remain, base):
real = BitOperation.or_bits(real,
BitOperation.num_map['1'],
length)
break
elif BitOperation.is_empty(real):
digit -= 1
return real, digit
def __add__(self, other: "Float") -> "Float":
"""
Binary Add 연산 ( + )을 위한 operator overloading
exponent를 같은 값으로 만든 후 fraction 덧셈 연산
:param other: Float 타입 가정
:return: 새로운 Float 객체로 return
"""
exp, a_frac, b_frac = Arithmetic.equalize_exponent(self.exponents, self.fractions, other.exponents,
other.fractions)
if BitOperation.raw_ge_bits(a_frac, b_frac):
sign = self.sign
else:
sign = other.sign
if self.sign ^ other.sign:
res, overflow = Arithmetic.sub_bits(a_frac, b_frac, self.fraction_len+1)
if sign:
res = Arithmetic.decomplement_bits(res, self.fraction_len+1)
else:
res, overflow = Arithmetic.add_bits(a_frac, b_frac, self.fraction_len+1)
if overflow:
res.insert(0, overflow)
res = res[:-1]
exp, _ = Arithmetic.add_bits(exp, BitOperation.num_map['1'], self.exponent_len)
first = BitOperation.first_bit_index(res)
if first != 0:
res, _ = Arithmetic.add_bits(res, BitOperation.num_map['1'], self.fraction_len + 1)
exp, _ = Arithmetic.raw_sub_bits(exp, Arithmetic.str_to_integer(str(first), self.exponent_len))
frac = BitOperation.raw_lshift_bits(res, first)[1:]
return Float(exp, frac, sign)
def __truediv__(self, other: "Float") -> "Float":
"""
Binary Div 연산 ( / )을 위한 operator overloading
:param other: Float 타입 가정
:return: 새로운 Float 객체로 return
"""
if other.is_zero():
if self.is_zero():
return self.nan()
if self.sign ^ other.sign:
return -self.inf()
return self.inf()
remain = BitOperation.fraction_bits(self.fractions)
div = BitOperation.fraction_bits(other.fractions)
exp, _ = Arithmetic.sub_bits(self.exponents, other.exponents, self.exponent_len)
bias = Arithmetic.str_to_integer('127', self.exponent_len)
exp, _ = Arithmetic.raw_add_bits(exp, bias)
res = BitOperation.empty_bits(self.fraction_len+1)
one = BitOperation.fit_bits(BitOperation.num_map['1'], self.fraction_len+1)
for i in range(self.fraction_len, -1, -1):
if BitOperation.raw_ge_bits(remain, div):
remain, _ = Arithmetic.raw_sub_bits(remain, div)
quotient = BitOperation.raw_lshift_bits(one, i)
res = BitOperation.raw_or_bits(res, quotient)
remain = BitOperation.raw_lshift_bits(remain, 1)
else:
div = BitOperation.raw_rshift_bits(div, 1)
if BitOperation.first_bit_index(res) != 0:
res = BitOperation.raw_lshift_bits(res, 1)
exp, _ = Arithmetic.sub_bits(exp, BitOperation.num_map['1'], self.exponent_len)
return Float(exp, res[1:], self.sign ^ other.sign)
def raw_mul_bits(a: List[Bit], b: List[Bit]) -> List[Bit]:
"""
같은 길이의 Bit List를 곱하는 ( * ) 함수
b Bit List의 값을 하위 비트부터 상위 비트까지 1인 비트가 있을 때마다 a bit를 left-shift하여 더함
:param a: * 앞의 Bit List
:param b: 곱할 Bit List
:return: a * b의 값인 Bit List
"""
res = BitOperation.empty_bits(len(a))
for i, bit in enumerate(b[::-1]):
if bit:
mul2 = BitOperation.raw_lshift_bits(a, i)
res, _ = Arithmetic.raw_add_bits(res, mul2)
return res
def raw_add_bits(a: List[Bit], b: List[Bit]) -> (List[Bit], Bit):
"""
같은 길이의 Bit List를 더하는 ( + ) 함수
덧셈 결과 overflow 되었는지 여부를 함께 return
and ( & ) 연산, xor ( ^ ) 연산과 left-shift ( << ) 연산을 통해 덧셈을 구현
:param a: 더할 Bit List
:param b: 더할 Bit List
:return: a + b의 값인 Bit List, overflow 된 Bit
"""
if BitOperation.is_empty(b):
return a, Bit()
carry_0 = BitOperation.raw_and_bits(a, b)
remain = BitOperation.raw_xor_bits(a, b)
carry = BitOperation.raw_lshift_bits(carry_0, 1)
res, overflow = Arithmetic.raw_add_bits(remain, carry)
return res, overflow ^ carry_0[0]
def __mul__(self, other: "Float") -> "Float":
"""
Binary Mul 연산 ( * )을 위한 operator overloading
:param other: Float 타입 가정
:return: 새로운 Float 객체로 return
"""
a_frac = BitOperation.fraction_bits(self.fractions)
b_frac = BitOperation.fraction_bits(other.fractions)
exp, _ = Arithmetic.add_bits(self.exponents, other.exponents, self.exponent_len)
bias = Arithmetic.str_to_integer('127', self.exponent_len)
exp, _ = Arithmetic.raw_sub_bits(exp, bias)
extra = BitOperation.empty_bits(self.fraction_len + 1)
mul = a_frac
over = BitOperation.empty_bits(self.fraction_len + 1)
for bit in b_frac[:0:-1]:
if bit:
extra, overflow = Arithmetic.raw_add_bits(extra, mul)
if overflow:
over, _ = Arithmetic.add_bits(over, BitOperation.num_map['1'], self.fraction_len+1)
mul = BitOperation.raw_lshift_bits(mul, 1)
if BitOperation.is_empty(mul):
break
res = BitOperation.empty_bits(self.fraction_len + 1)
mul = a_frac
for bit in b_frac:
if bit:
res, overflow = Arithmetic.raw_add_bits(res, mul)
if overflow:
res = BitOperation.raw_rshift_bits(res, 1)
res[0] = overflow
exp, _ = Arithmetic.add_bits(exp, BitOperation.num_map['1'], self.exponent_len)
mul = BitOperation.raw_rshift_bits(mul, 1)
mul = BitOperation.raw_rshift_bits(mul, 1)
if BitOperation.is_empty(mul):
break
res, _ = Arithmetic.raw_add_bits(res, over)
res = res[1:]
return Float(exp, res, self.sign ^ other.sign)