Python 의 modf()함수 의 소수 부분 부정 확 한 문 제 를 해결 합 니 다.

math.modf()를 사용 하여 부동 소수점 을 나 눌 때 다음 과 같은 상황 이 자주 발생 합 니 다.
아래 와 같다

import math
print(math.modf(2.4)) #    (0.3999999999999999, 2.0)

우 리 는 2.4 를 나 누 어 얻 은 소수 가 0.4 가 아니 라 는 것 을 알 게 될 것 이다.이것 은 무엇 때 문 일 까?
이것 은 컴퓨터 가 2 진 코드 를 사용 하기 때 문 이 며,2 진 코드 는 계산 상의 오차 로 인해 일부 10 진수 의 소수 부분 을 정확하게 표시 할 수 없 기 때문이다.
구체 적 으로 말씀 드 리 겠 습 니 다.
우 리 는 하나의 십 진수 가 이 진수 로 바 뀌 려 면 두 부분 으로 나 누 어 계산 해 야 한 다 는 것 을 안다.정수 부분 과 소수 부분 이다.
정수 부분 은'제2 취 여 법'을 채택 한다.이 정 수 를 2 로 나 누 어 나머지 를 얻 은 다음 에 상 을 3 으로 나 누 어 상 을 0 이 될 때 까지 얻 은 나머지 를 사진 의 반대 순서에 따라 배열 한다.
소수 부분 은'곱 하기 2 취 정 법'을 사용 하여 이 소 수 를 2 에 곱 하고 새로 얻 은 수의 정수 부분 을 꺼 내 고 2 곱 하기 남 은 소수 부분 을 사용 하여 곱 하기 중의 소수 부분 이 0 이거 나 요구 하 는 정밀도 에 이 를 때 까지 왕복 한다.그리고 꺼 낸 정수 부분 을 꺼 낸 선후 순서에 따라 앞 뒤로 배열 한다.

 123/2=61...1
 61/2=30...1
 30/2=15...0
 15/2=7...1
 7/2=3...1
 3/2=1...1
 1/2=0...1
 (123)10=(1111011)2
0.4*2=0.8...0
0.8*2=1.6...1
0.6*2=1.2...1
0.2*2=0.4...0
0.4*2=0.8...0
0.8*2=1.6...1
0.6*2=1.2...1
(0.4)10=(0.011001100110011001100110...)2
(123.4)2=(1111011.011001100110011...)2

10 진법 의 0.4 가 2 진법 으로 바 뀌 었 을 때'0110'을 반복 순환 하 는 경우 가 있 지만 현재 컴퓨터 저장 부동 점 수 는 전기 와 전자 엔지니어 협회 의 표준(IEEE 754 부동 소수점 저장 형식 기준)에 따라 저장 되 고 있다.
IEEE 규정 단일 정밀도 부동 소수점 최대 32 비트(4 바이트)저장:
31 위 는 기호 자리 다.1.이 수 는 마이너스 이 고 0 은 플러스 임 을 나타 낸다.
30~23 은 지수 비트(-128-127)
22~0 은 끝자리 이 고 끝자리 의 인 코딩 은 보통 소스 코드 와 패 치 입 니 다.
IEEE 표준 은 논리 적 으로 3 원 그룹{S,E,M}으로 하나의 수 를 표시 합 니 다.그림 과 같 습 니 다.

즉,위 에서 0.4 를 변환 한 바 이 너 리 코드 는 23 비트 만 저장 할 수 있 고 데이터 형식 이 double 이 더 라 도 52 비트 만 저장 할 수 있 습 니 다.그러면 문제 가 발생 한 원인 을 알 수 있 습 니 다.23 비트 의 데 이 터 는 분명히 0.4 의 바 이 너 리 데 이 터 를 완전 하 게 표시 할 수 없어 서 오차 가 발생 했다.
그럼 모든 십 진법 소수 가 완전 하 게 표시 되 지 않 습 니까?아니 야,소수 부분 에 2 를 곱 하면 최종 소수 부분 에서 0 을 얻 을 수 있다 면 이런 문제 가 발생 하지 않 을 거 야.예 를 들 어 0.5,0.75.

import math
print(math.modf(1.5))  #    （0.5,1.0）

0.5*2=1...1
(0.5)10=(0.1)2
0.75*2=1.5...1
0.5*2=1...1
(0.75)10=(0.11)2

질문
1.초심:
때때로 우 리 는 페이지 를 나 누 어 데 이 터 를 보 여줄 때 페이지 수 를 계산 해 야 한다.일반적으로 counts=205 pageCouts=20,pages=11 페이지 등 을 위로 올 리 는 것 이 일반적이다.
일반적인 나눗셈 은 정수 부분 만 취하 고 요구 에 이 르 지 못 한다.
2.방법:
1.통용 나눗셈:

UP(A/B) = int((A+B-1)/B)

임계값 을 취하 고 A+B-1 의 범 위 를 계산 하면 OK.
2.Python 나눗셈:
우선 python 의 나눗셈 연산 을 말 해 야 합 니 다.
x/y 형식 으로 나 누 기 연산 을 할 때 이른바 true 나 누 기 를 한다.예 를 들 어 2.0/3 의 결 과 는 0.6666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666666
다른 나눗셈 은 x/y 의 형식(아래로 추출)을 사용 하 는 것 이다.그러면 여기 서 사용 하 는 것 은 이른바 floor 나눗셈,즉 결과 보다 크 지 않 은 최대 정수 치 를 얻 는 것 이다.이 연산 은 조작 수 와 무관 하 다.예 를 들 어 2//3 의 결 과 는 0,-2//3 의 결 과 는-1,-2.0//3 의 결 과 는-1.0 이다.
python 3.0 에서 x/y 는 true 나눗셈 만 실행 하고 조작 수 와 무관 합 니 다.x//y 는 floor 나 누 기 를 실행 합 니 다.
Python 연산 상 향 조정 방법:(A+B-1)/B
3、Python match.ceil 함수 np.ceil 함수
ceil(x)함 수 는 위로 정 리 를 하 는 것 입 니 다.즉,x 와 같은 가장 가 까 운 정수 입 니 다.

import math 
math.ceil(float(205)/20) 
import numpy as np
np.ceil(float(205)/20)

Python 상 향 조정 알고리즘
1.보통 floor 나 누 기(np.floor()또는 math.floor()를 사용 합 니 다.

import numpy as np 
n = np.array([-1.7, -2.5, -0.2, 0.6, 1.2, 2.7, 11]) 
floor = np.floor(n)
print(floor)  # [ -2.  -3.  -1.   0.   1.   2.  11.]

2.일반 나눗셈/

A=100
B=16
c=100//16
(c=6)

3.round()반올림 함수.
np.around 는 반올림 후의 값 을 되 돌려 주 고 정 도 를 지정 할 수 있 습 니 다.

around(a, decimals=0, out=None)

a 입력 배열
decimals 가 반올림 할 소수 자릿수.기본 값 은 0 입 니 다.만약 마이너스 라면,정 수 는 소수점 왼쪽 의 위치 로 반올림 할 것 이다.

import numpy as np 
n = np.array([-0.746, 4.6, 9.4, 7.447, 10.455, 11.555])
 
around1 = np.around(n)
print(around1)  # [ -1.   5.   9.   7.  10.  12.]
 
around2 = np.around(n, decimals=1)
print(around2)  # [ -0.7   4.6   9.4   7.4  10.5  11.6]
 
around3 = np.around(n, decimals=-1)
print(around3)  # [ -0.   0.  10.  10.  10.  10.]

Python 에서 각각 추출 한 알고리즘
math 모듈 의 modf()방법
정수 부분 과 소수 부분 을 각각 꺼 내 math 모듈 의 modf()방법 을 사용 할 수 있 습 니 다.
예 를 들 면:

>>> math.modf(4.25)
(0.25, 4.0)
>>> math.modf(4.33)

이상 은 개인 적 인 경험 이 므 로 여러분 에 게 참고 가 되 기 를 바 랍 니 다.여러분 들 도 저 희 를 많이 응원 해 주시 기 바 랍 니 다.