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)