math/big
패키지 big 은 임의 정밀도 산수(큰 숫자)를 구현한다.
다음의 숫자 유형을 지원해준다.
Int 부호있는 정수
Rat 유리수
Float 부동 소수점 숫자Int, Rat 또는 Float 의 제로 값은 0에 해당한다.
또는 다음과 같은 팩토리 함수를 사용하여 새 값을 할당하고 초기화할 수 있다.
func NewT(v V) *Tsetter, 숫자 연산 및 술어는 다음 형식의 메소드로 표시된다.
func (z *T) SetV(v V) *T // z = v
func (z *T) Unary(x *T) *T // z = unary x
func (z *T) Binary(x, y *T) *T // z = x binary y
func (x *T) Pred() P // p = pred(x)위의 경우엔 피연산자 x 또는 y 중 하나이면 안전하게 덮어 쓸 수 있다. (메모리 재사용)
산술 표현식은 개별 메소드 호출의 시퀀스로 작성되어 각 호출은 작업에 해당된다.
수신자는 결과를 나타내고 메소드 인수는 피연산자이다.
예로, 세 개의 *Int 값 a, b 및 c 가 주어진다면
c.Add(a, b)합계 a + b 를 계산하고 결과를 c 에 저장하여 이전 c 의 값을 덮어 쓴다.
달리 지정하지 않는 한 매개 변수를 다음과 같이 사용할 수 있다.
sum.Add(sum, x)상수
const (
MaxExp = math . MaxInt32 // 지원되는 가장 큰 지수
MinExp = math . MinInt32 // 지원되는 가장 작은 지수
MaxPrec = math . MaxUint32 // 지원되는 가장 큰 (이론적으로) 정밀도; 메모리 제한 가능성이 높음
)함수
func Jacobi(x, y *int) intJacobi 기호 (x / y), +1, -1 또는 0 을 반환합니다.
y 인수는 홀수 정수여야 한다.
타입
Accuarcy
Accuracy 는 정확한 값을 기준으로 Float 값을 생성한 가장 최근 작업에서 생성된 반올림 오류를 설명한다.
type Accuracy int8Float 의 정확도를 설명하는 상수들이다.
const (
Below Accuracy = -1
Exact Accuracy = 0
Above Accuracy = +1
)ErrNaN
ErrNaN 패닉은 NaN 으로 이어지는 Float 작업에 의해 발생한다.
ErrNaN 은 오류 인터페이스를 구현한다.
type ErrNaN struct {
// 필터링되거나 내보내지지 않은 필드 포함
}func (err ErrNaN) Error() stringFloat
0 이 아닌 Float 은 다정밀도 부동 소수점 수를 나타낸다.
기호 X 가수 X 2**지수정밀도는 값을 나타내는데 사용할 수 있는 최대 가수 비트 수이다.
반올림 모드는 가수 비트에 맞게 결과를 반올림하는 방법을 지정한다.
정확도는 정확한 결과에 대한 반올림 오류를 설명한다.
제공된 결과 정밀도가 0 이면 반올림이 발생하기 전에 정밀도 값이 가장 큰 인수의 정밀도로 설정되고 반올림 모드는 변경되지 않는다.
연산은 항상 Float 값이 아닌 포인터 인수를 사용하며 각 고유 Float 값엔 고유한 *Float 포인터가 필요하다.
Float 값을 복사하려면 기존 Float 을 Float.Set 메소드를 사용하여 새 값으로 설정해야 한다.
type Float struct {
// 필터링되거나 내보내지지 않은 필드 포함
}func NewFloat(x float64) *Float정밀도 53 및 반올림 모드 ToNearestEven 을 사용하여 x 로 새 Float 을 할당하고 반환한다.
x 가 NaN 이면 패닉이 ErrNaN 으로 표시된다.
func ParseFloat(s string, base int, prec uint, mode RoundingMode)
(f *Float, b int, err error)f.Parse(s, base) 와 비슷하며 f 는 주어진 정밀도와 반올림 모드로 설정된다.
func (z *Float) Abs(x *Float) *Floatz 를 반올림된 값으로 설정한다.
func (x *Float) Acc() Accuracy해당 작업에서 별도로 명시적으로 문서화하지 않는 한 가장 최근 작업에서 생성된 x 의 정확도를 반환한다.
func (z *Float) Add(x, y *Float) *Floatx + y 에 세트 z 를 더하고 반환한다.
z 정밀도가 0 이면 연산 전에 x 또는 y 의 정밀도 중 더 큰 정밀도로 변경된다.
func (x *Float) Append(buf []byte, fmt byte, prec int) []bytex.Text 에 의해 생성된 부동 소수점 숫자 x 의 문자열 형식을 buf 에 추가하고 확장된 버퍼를 반환한다.
fuc (x *Float) Cmp(y *Float) intx 와 y 를 비교하고 다음을 반환한다.
-1 if x < y
0 if x == y (incl. -0 == 0, -Inf == -Inf, and +Inf == +Inf)
+1 if x > yfunc (z *Float) Copy(x *Float) *Floatx 로 동일한 정밀도, 반올림 모드 및 정확도로 z 를 x 로 복사하고 z 를 반환한다.
x 는 z 와 x 가 동일해도 변경되지 않는다.
func (x *Float) Float32() (float32, Accuracy)
func (x *Float) Float64() (float64, Accuracy)x 에 가장 가까운 [float32 | float64] 를 반환한다.
func (x *Float) Format(s fmt.State, format rune)fmt.Formatter 를 구현한다.
부동 소시점에 대한 모든 일반 형식을 허용한다.
func (z *Float) GobDecode(buf []byte) errorgob.GobDecoder 인터페이스를 구현한다.
결과는 z 의 정밀도가 0 이 아닌 경우 z 의 정밀도 및 반올림 모드에 따라 반올림된다.
이 경우 z 는 디코딩된 값으로 정확히 설정된다.
func (x *Float) GobEncode() ([]byte, error)gob.GobEndoer 인터페이스를 구현한다.
Float 값과 모든 속성은 정렬된다.
func (x *Float) Int(z *Int) (*Int, Accuracy)
func (x *Float) Int64() (int64, Accuracy)Int 는 x 를 0 으로 절삭한 결과를 반환한다.
x 가 무한대이면 nil 을 반환한다.
nil 이 아닌 *Int 인수 z 가 제공되면 새 Int 를 할당하는 대신 결과를 z 에 저장한다.
func (x *Float) IsInf() boolx 가 +Inf 인지 -Inf 인지 여부를 반환한다.
func (x *Float) IsInt() boolx 가 정수인지 아닌지를 반환한다.
+-Inf 값은 정수가 아니다.
func (x *Float) MantExp(mant *Float) (exp int)x 를 가수와 지수 성분으로 나누고 지수를 반환한다.
nil 이 아닌 mant 인수가 제공되면 값은 x 와 동일한 정밀도 및 반올림 모드를 사용하여 x 의 가수로 설정된다.
nil 인수로 MantExp 를 호출하는 것은 수신자의 지수를 얻는 효율적인 방법이다.
특별한 경우는 다음과 같다.
(± 0) .MantExp (mant) = 0, mant가 ± 0으로 설정 됨
(± Inf) .MantExp (mant) = 0, mant가 ± Inf로 설정 됨func (x *Float) MarshalText() (text []byte, err error)encoding.TextMarshaler 인터페이스를 구현한다.
Float 값만 정렬되고 정밀도 또는 정확도와 같은 다른 속성은 무시된다.
func (x *Float) MinPrec() unitx 를 정확하게 표현하는 데 필요한 최소 정밀도를 반환한다.
func (x *Float) Mode() RoundingModex 의 반올림 모드를 반환한다.
func (z *Float) Mul(x, y *Float) *Floatz 를 반올림된 곱 x * y 로 설정하고 z 를 반환한다.
정밀도, 반올림 밑 정확도 여부는 더하기와 같다.
연산자가 0 이고 다른 피연산자가 무한대이면 ErrNaN 과 함께 다중 패닉이 발생한다.
이 경우 z 의 값은 정의되지 않는다.
func (z *Float) Neg(x *Float) *Floatz 를 부호가 없는 x 의 반올림 가능한 값으로 설정한다.
그리고난 후 z 를 리턴한다.
func (z *Float) Parse(s string, base int) (f *Float, b int, err error)주어진 변환 기준을 통해 또는 무한 값을 나타내는 문자열로 가수가 있는 부동 소수점 숫자의 텍스트 표현을 포함해야 하는 s 를 구문 분석한다.
func (x *Float) Prec() uintx 비트의 가수 정밀도를 반환한다.
해당 결과는 |x| == 0 그리고 |x| == Inf 나 0 일 수 있다.
func (z *Float) Quo(x ,y *Float) *Floatz 를 반올림된 몫 x/y 로 설정하고 z 를 반환한다.
정밀도, 반올림, 정확도 여부는 더하기와 같다.
그리고 만약 두 연산이 0 또는 무한이라면 ErrNaN 패닉이 된다.
func (x *Float) Rat(z *Rat) (*Rat, Accuracy)x 에 대한 유리수를 반환하거나 x 가 무한대이면 nil 을 반환한다.
이 결과는 x 가 Inf가 아니라면 정확할 것이다.
nil 이 아닌 *Rat 인수 z 가 제공된다면 새 Rat 을 할당하는 대신 z 를 결과로 저장한다.
func (z *Float) Scan(s fmt.ScanState, ch rune) errorScan 은 fmt.Scanner 을 위한 루틴을 도와준다.
z 를 스캔한 숫자의 값으로 설정한다. 그리고 fmt 에서 지원하는 동사의 형식을 허용한다.
func (z *Float) SetFloat64(x float64) *Floatz 를 반올림된 x 값으로 설정하고 z 를 반환한다.
z 의 정밀도가 0 이면 53 으로 변경된다. (반올림은 효과가 없음)
func (z *Float) SetInf(signbit bool) *Float부호 비트가 설정된 경우 z 를 무한 부동 소수점 -Inf 로 설정하고 부호 비트가 설정되지 않은 경우 +Inf 를 설정하고 z 를 반환한다.
z 의 정밀도는 변경되지 않고 결과는 항상 정확하다.
func (z *Float) SetInt(x int) *Float
func (z *Float) SetInt64(x int64 *Floatz 를 반올림된 값 x 로 설정하고 z 를 반환한다.
func (z *Float) SetMantExp(mant *Float, exmp int) *Floatz 를 mant x 2**exp 로 설정하고 z 를 반환한다.
결과 z 는 mant 와 동일한 정밀도 및 반올림 모드를 갖는다.
특별한 경우는 다음과 같다.
z.SetMantExp (± 0, exp) = ± 0
z.SetMantExp (± Inf, exp) = ± Inffunc (z * Float) SetMode(mode RoundingMode) *Floatz 의 반올림 모드를 mode 로 설정하고 정확한 z 를 반환한다.
그렇지 않으면 변경되지 않는다.
func (z * Float) SetPrec(prec uint) *Floatz 의 정밀도를 prec 로 설정하고 반올림된 z 값을 반환한다.
거수가 정밀도 손실없이 prec 비트로 표현될 수 없을 경우는 z 의 반올림 모드에 따라 발생한다.
func (z * Float) SetRat(x *Rat) *Floatz 를 반올림된 값 x 로 설정하고 z 를 반환한다.
z 의 정밀도가 0 이면 a.BitLen() , b.BitLen() 또는 64 중 가장 큰 값으로 변경된다.
func (z * Float) SetString(s string) (*Float, bool)z 를 s 값으로 설정하고 z 와 성공을 나타내는 부울을 반환한다.
s 는 기본 인수 0 을 사용하여 Parse 에서 허용하는 것과 동일한 형식의 부동 소수점 숫자여야 한다.
전체 문자열은 성공을 위해 유효해야하며 작업 실패 시 z 값은 정의되지 않지만 반환 값은 nil 이다.
func (z * Float) SetUint64(x uint64) *Floatz 를 반올림된 x 로 설정하고 z 의 정밀도가 0이면 64로 변경한다.
func (z * Float) Sign() int기호를 반환한다.
x <000이면 -1
x가 ± 0이면
+1 x> 0 이면 +1func (x * Float) Signbit() boolx 가 음수인지 아닌지를 반환한다
func (x * Float) Sqrt(x *Float) *Floatz 를 x 의 반올림 제곱근으로 설정하고 이를 반환한다.
func (x * Float) String() stringx.Text('g', 10) 와 같은 문자열 형식 x 를 반환한다.
func (x * Float) Sub(x, y *Float) *Floatz 를 반올림 된 차이 xy 로 설정하고 z 를 반환한다.
func (x * Float) Text(format byte, prec int) string텍스트는 주어진 형식 및 정밀도로 prec 에 따라 부동 소수점 숫자 x 를 문자열로 변환한다.
형식은 다음과 같다.
'e'-d.dddde ± dd, 십진수 지수, 최소 두 자리 (0) 지수
'E'-d.ddddE ± dd, 십진수 지수, 최소 두 자리 (0) 지수
'f'-ddddd. dddd,
큰 지수의 경우 'e'와 같은 지수 'g', 그렇지 않으면 'f
'와 같은 'G' , 큰 지수의 경우 'E'와 같고 'f'와 같지 않으면
'x'-0xd.dddddp ± dd, 16 진수 가수, 십진수 두 지수
'p'의 거듭 제곱 -0x.dddp ± dd, 16 진수 가수, 두 지수의 소수 거듭 제곱 (비표준)
'b' - ddddddp ± dd, 십진수 가수, 두 지수의 소수 제곱 (비표준func (z *Float) UnmarshalText(text []byte) errorencoding.TextUnmarshaler 인터페이스를 구현한다.
결과는 z 정밀도 및 반올림에 따라 반올림된다.
Int
Int 는 부호있는 다 정밀도 정수를 나타낸다.
type Int struct {
// 필터링 되거나 내보내지지 않은 필드 포함
}연산은 항상 Int 값이 아닌 포인터 인수 (Int) 를 취하며 각 고유 Int 값에는 고유한 Int 포인터가 필요하다.
Int 값을 복사하라면 기존 Int 를 Int.Set 메소드를 통해 새 값으로 설정해야 한다.
Int 는 얕은 복사본은 지원되지 않으며 오류가 발생할 수 있다.
func NewInt(x int64) *Intx 로 설정된 새 Int 를 할당하고 반환한다.
func (z *Int) Abs(x *Int) *Intz 를 |x| 로 설정하여 x 의 절대 값을 반환한다.
func (z *Int) Add(x, y *Int) *Intz 를 합계 x + y 에 더하고 z 를 반환한다.
func (z *Int) And(x, y *Int) *Intz = x & y 를 설정하고 z 를 반환한다.
func (z *Int) AndNot(x, y *Int) Intz = x & ^ y 를 설정하고 z 를 반환하다.
func (x *Int) Append(buf []byte, base int) []bytex.Text(base) 에 의해 생성된 x 의 문자열 표현을 buf 에 추가하고 확장된 버퍼를 반환한다.
func (z *Int) Binomial (n, k int64) *Intz 를 (n, k) 의 이항 계수로 설정하고 z 를 반환한다.
func (x *Int) bit(i int) uintx 의 i 번째 비트 값을 반환한다.
func (x *Int) BitLen() intx 의 절대값 길이를 비트 단위로 반환한다.
0 의 비트 길이는 0이다.
func (x *Int) Bits() []Word절대값을 Word 조각으로 반환하여 x 에 대한 원시 액세스를 제공한다.
func (x *Int) Bytes() []bytex 의 절대값을 빅 엔디안 바이트 조각으로 반환한다.
func (x *Int) Cmp(y *Int) (r int)x 와 y 를 비교하고 다음을 반환한다.
x < y 인 경우 0 x == y 인
경우 +1 x> y 인 경우 +1func (x *Int) CmpAbs(y *Int) intx 와 y 의 절대값을 비교하고 다음을 반환한다.
| x | 인 경우 -1 <| y |
| x | 인 경우 0 == | y |
| x |이면 +1 > | y |func (z *Int) Div(x, y *Int) *Intz 를 y != 0 에 대한 몫 x / y 로 설정하고 z 를 반환한다.
y == 0 이면 0 으로 나누기 때문에 런타임 패닉이발생한다.
func (z *Int) DivMode(x, y, m *Int) (*Int, *Int)z 를 몫 x div y 로 설정하고 m 을 계수 x mod y 로 설정하고 y != 0 에 대한 쌍 (z, m) 을 반환한다.
Div 와 마찬가지로 y 가 0 이면 패닉이 발생한다.
func (z *Int) Exp(x, y, m *Int) *Intz = x ** y mod |m|, z 를 반환한다.
func (x *Int) FillBytes(buf []byte) []bytebuf 를 x 의 절대값으로 설정하여 확장 빅 엔디안 바이트 슬라이스로 저장하고 buf 를 반환한다.
x 의 절대 값이 buf 에 맞지 않으면 패닉 상태가 된다.
func (x *Int) Format(s fmt.State, ch rune)fmt.Formatter 를 구현한다.
func (z *Int) GCD(x, y, a, b *Int) *IntGCD 는 z 를 a 와 b 의 최대 공약수로 설정하고 z 를 반환한다.
x 또는 y 가 nil 이 아니면 GCD 는 z = a * x + b * y 가 되도록 값을 설정한다.
a 와 b 는 양수, 0 또는 음수일 수 있다. 이 둘의 부호와 관계없이 z 는 항상 양수이다.
a == b == 0 이면 GCD 는 z = x = y = 0 을 설정한다.
a == 0 이고 b != 0 이면 GCD는 z = | b |, x = 0, y = sign (b) * 1 을 설정합니다.
a != 0 및 b == 0 이면 GCD는 z = | a |, x = sign (a) * 1, y = 0을 설정합니다.
func (z *Int) GobDecode(buf []byte) errorgob.GobDecode 인터페이스를 구현한다.
func (x *Int) GobEncode() ([]byte, error)gob.GobEncode 인터페이스를 구현한다.
func (x *Int) Int64() int64x 의 int64 표현을 반환한다.
func (x *Int) IsInt64() boolx 가 int64로 표현될 수 있는지 여부를 반환한다.
func (x *Int) IsUint64() boolx 가 uint64 로 표현될 수 있는지 여부를 반환한다.
func (z *Int) Lsh(x *Int, n uint) *Intz = x << n 을 설정하고 z 를 반환한다.
func (x *Int) MarshalJSON() ([]byte, error)json.Marshaler 인터페이스를 구현한다.
func (x *Int) MarshalText() (text []byte, err error)encoding.TextMarshaler 인터페이스를 구현한다.
func (z *Int) Mod(x, y *Int) *Intz 를 y != 0 에 대한 계수 x % y 로 설정하고 z 를 반환한다.
y == 0 이면 0 으로 나누기 런타임 패닉이 발생한다.
func (x *Int) ModInverse(g, n *Int) *Intz 를 g 의 곱셈 역으로 설정하고 z 를 반환한다.
func (x *Int) ModSqrt(x, p *Int) *Int제곱근이 있는 경우 z 를 x mod p 의 제곱근으로 설정하고 z 를 반환한다.
모듈러스 p 는 홀수 소수여야 한다.
x 가 제곱 mod p 가 아니면 z 를 변경하지 않고 nil 을 반환한다.
func (z *Int) Mul(x, y *Int) *Intz 를 x * y 로 설정하고 z 를 반환한다.
func (z *Int) MulRange(a, b int64) *Intz 를 [a, b] 범위에 있는 모든 정수 곱으로 설정하고 z 를 반환한다.
func (z *Int) Neg(x *Int) *Intz 를 -x 로 설정하고 z 를 반환한다.
func (z *Int) Not(x *Int) *Intz = ^ x 를 설정하지 않고 z 를 반환한다.
func (z *Int) Or (x, y *Int) *Intz = x | y 를 설정하고 z 를 반환한다.
func (x *Int) ProbablyPrime(n int) boolx 가 소수인지 여부를 보고하고 Baillie-PSW(소수 판별법) 테스트 뿐만 아니라 의사 난수로 선택한 n 개의 염기를 사용하여 Miller-Rabin(소수 판별법) 테스트를 적용한다.
x 가 소수면 true 를 반환한다. 아니면 false 를 반환한다.
func (z *Int) Quo(x, y *Int) *Intz 를 y != 0 에 대한 몫 x / y 로 설정하고 z 를 반환한다.
y == 0 이면 0 으로 나누기 때문에 패닉이 발생한다.
func (z *Int) QuoRem(x, y, r *Int) (*Int, *Int)z 를 몫 x / y 로 설정하고 r 을 나머지 x % y 로 설정하고 y != 0 에 대한 쌍 (z, r) 를 반환한다.
y == 0 이면 0 으로 나누기 때문에 패닉이 발생한다.
func (z *Int) Rand(rnd *rand.Rand, n *Int) *Intz 를 0 ~ n 의 난수로 설정하고 z 를 반환한다.
func (z *Int) Rem(x, y *Int) *Inty != 0 에 대해 z 를 나머지 x % y 로 설정하고 z 를 반환한다.
y == 0 이면 0 으로 나누기 때문에 패닉이 발생한다.
func (z *Int) Rsh(x *Int, n uint) *Intz = x >> n 을 설정하고 z 를 반환한다.
func (z *Int) Scan(s fmt.ScanState, ch rune) errorfmt.Scanner 을 위한 루틴을 지원한다.
z 를 스캔한 숫자의 값으로 설정한다.
func (z *Int) Set(x *Int) *Intz 를 x 로 설정하고 z 를 반환한다.
func (z *Int) SetBit(x *Int, i int, b uint) *Intz 를 x 로 설정하고 x 의 i 번째 비트는 b 설정한다.
func (z *Int) SetBits (abs []Word) *Int값을 abs 로 설정하고 little-endian Word 슬라이스로 해석하고 z 를 반환하여 z 에 대한 원시 액세스를 제공한다.
func (z *Int) SetBytes(buf []byte) *Intbuf 를 부호없는 빅 엔디안 정수의 바이트를 해석하고z 를 해당 값으로 설정하고 z 를 반환한다.
func (z *Int) SetInt64 (x int64) *Intz 를 x 로 설정하고 z 를 반환한다.
func (z *Int) SetString(s string, base int) (*Int, bool)z 를 s 의 값으로 설정하고 주어진 기수로 해석되고 z 와 성공을 나타내는 부울을 반환한다.
func (z *Int) SetUint64 (x uint64) *Intz 를 x 로 설정하고 z 를 반환한다.
func (x *Int) Sign() int다음 기호를 반환한다.
x <000 인 경우 -1
x == 0 인
경우 +1 x> 0 인 경우func (z *Int) Sqrt (x *Int) *Intz 를 z² ≤ x 가 되는 큰 정수인 √x 로 설정하고 z 를 반환한다.
x 가 음수이면 패닉이된다.
func (x *Int) String() stringx.Text(10) 에 의해 생성된 x 의 10 진수 표현을 반환한다.
func (z *Int) Sub(x, y *Int) *Intz 를 차이 xy 로 설정하고 z 를 반환한다.
func (x *Int) Text(base int) string주어진 밑수에 있는 x 의 문자열 표현을 반환한다.
밑은 2 ~ 62 사이여야 한다.
결과는 숫자 10 ~ 35 에 대해 소문자 'a' ~ 'z' 를 사용하고, 숫자 값 36 ~ 61 에 대해 대문자 'A' ~ 'Z' 를 사용해야 한다.
func (x *Int) TrailingZeroBits() uint|x| 의 연속 최하위 0 비트 수를 반환한다.
func (x *Int) Uint64() uint64x 의 uint64 표현을 반환한다.
x 를 uint64 로 나타낼 수 없는 경우 결과는 정의되지 않는다.
func (z *Int) UnmarshalText(text []byte) errorencoding.TextUnmarshaler 인터페이스를 구현한다.
func (z *Int) Xor(x, y *Int) *Intz = x ^ y 로 설정하여 z 를 리턴한다.
Rat
연산은 Rat 값이 아닌 포인터 인수 (Rat) 을 사용하여 각 고유 Rat 값에는 고유한 Rat 포인터가 필요하다.
Rat 값을 복사하려면 기존 Rat 을 Rat.Set 메소드를 사용하여 새 값으로 설정해야 한다.
얕은 복사본은 지원되지 않아 오류를 발생할 수 있다.
type Rat struct {
// 필터링되거나 내보내지지 않은 필드 포함
}func NewRat(a, b int64) *Rat분자 a 와 분모 b 와 함께 새로운 Rat 을 만든다.
func (z *Rat) Abs(x *Rat) *Ratz 를 |x| 로 설정하고 z 를 리턴한다.
func (z *Rat) Add(x, y *Rat) *Ratz 를 x + y 의 합으로 설정하여 z 를 반환한다.
func (x *Rat) Cmp(y *Rat) intx 와 y 를 비교하여 다음을 반환한다.
x < y 이면 -1
x == y 이면 0
x > y 이면 +1func (x *Rat) Denom() *Intx 의 분모를 반환한다.
x 가 초기화되지 않은(0) 경우 x 의 분모에 대한 참조이다.
이 경우 결과는 값 1 의 새 Int 이다.
func (x *Rat) Float32() (f float32, exact bool)
func (x *Rat) Float64() (f float64, exact bool)x 에 대해 가장 가까운 [float32 | float64] 값과 f 가 x 를 정확히 나타내는지 여부를 반환한다.
func (x *Rat) FloatString(prec int) string기수 포인트 뒤에 정밀도의 정확한 자릿수가 있는 십진수 형식의 x 문자열 표현을 반환한다.
마지막 숫자는 가장 가까운 숫자로 반올림되고 반은 0에서 멀어진다.
func (x *Rat) GobDecode(buf []byte) error
func (x *Rat) GobEncode() ([]byte, error)각각 gob 의 GobDecoder, GobEncoder 인터페이스를 구현한다.
func (x *Rat) Inv(x *Rat) *Ratz 를 1 / x 로 설정하고 z 를 반환한다.
x == 0 이면 패닉이 발생한다.
func (x *Rat) IsInt() boolx 의 분모가 1 인지 여부를 보고한다.
func (x *Rat) MarshalText() (text []byte, err error)encoding.TextMarshaler 인터페이스를 구현한다.
func (x *Rat) Mul(x, y *Rat) *Ratz 를 x * y 로 설정하고 z 를 반환한다.
func (x *Rat) Neg(x *Rat) *Ratz 를 -x 로 설정하고 z 를 반환한다.
func (x *Rat) Num() *Intx 의 분자를 반환한다. 0 이하일 수 있다.
결과는 x 의 분자에 대한 참조이다.
func (x *Rat) Quo(x, y *Rat) *Ratb != 1 이면 a / b 형식으로 x 의 문자열 표현을 반환하고 b == 1 이면 a 형식으로 반환한다.
func (x *Rat) Scan(s fmt.ScanState, ch rune) errorfmt.Scanner 에 대한 루틴을 지원한다.
func (x *Rat) Set(x *Rat) *Rat(x 의 복사본을 만들어)z 를 x 로 설정하고 z 를 반환한다.
func (x *Rat) SetFloat64(f float64) *Ratz 를 정확히 f 로 설정하고 z 를 반환한다.
f 가 유한하지 않으면 nil 을 반환한다.
func (z *Rat) SetFrac(a, b *Int) *Rat
func (z *Rat) SetFrac64(a, b int64) *Ratz 를 a / b 로 설정하고 z 를 반환한다.
b == 0 이면 패닉이 발생한다.
func (z *Rat) SetInt(x *Int) *Rat
func (z *Rat) SetInt64(x int64) *Ratz 를 x 로 설정(x 를 복사)하고 z 를 반환한다.
func (z *Rat) SetString(s string) (*Rat, bool)z 를 s 값으로 설정하고 z 와 성공을 나타내는 부울을 반환한다.
s 는 분수 a / b 로 주어지거나, 선택적으로 지수 뒤에 오는 부동 소수점 숫자로 주어질 수 있다.
func (z *Rat) SetUint64(x uint64) *Ratz 를 x 로 설정하고 z 를 반환한다.
func (x *Rat) Sign() int다음과 같은 기호를 반환한다.
x < 0 인 경우 -1
x == 0 인 경우 0
x > 0이면 +1func (x *Rat) String() stringa / b 형식으로 x 의 문자열 표현을 반환한다.
func (z *Rat) Sub(x, y *Rat) *Ratz 를 xy 로 설정하고 z 를 반환한다.
func (z *Rat) UnmarshalText(text []byte) errorencoding.TextUnmarshaler 인터페이스를 구현한다.
RoundingMode
Float 값이 원하는 정밀도로 반올림되는 방법을 결정한다.
반올림은 Float 값을 변경할 수 있다.
type RoundingMode byte이 상수들은 지원되는 roundingMode 를 정의한다.
const (
ToNearestEven RoundingMode = iota // == IEEE 754-2008 roundTiesToEven
ToNearestAway // == IEEE 754-2008 roundTiesToAway
ToZero // == IEEE 754-2008 roundTowardZero
AwayFromZero // no IEEE 754-2008 equivalent
ToNegativeInf // == IEEE 754-2008 roundTowardNegative
ToPositiveInf // == IEEE 754-2008 roundTowardPositive
)Word
다중 정밀도에서 부호없는 정수의 단일 숫자를 나타낸다.
type Word uintmath/bits
미리 선언된 부호없는 정수 유형에 대한 비트 계수 및 조작 기능을 구현한다.
상수
UintSize 는 비트 단위의 단위 크기이다.
const UintSize = uintSize함수
func Add(x, y, carry uint) (sum, carryOut uint)
func Add(x, y, carry uint32) (sum, carryOut uint32)
func Add(x, y, carry uint64) (sum, carryOut uint64)x , y 및 캐리의 합계를 반환한다.
func Div32(hi, lo, y uint32) (quo, rem uint32)
func Div64(hi, lo, y uint64) (quo, rem uint64)(hi, lo) 의 몫과 나머지를 y 로 나눈 값을 반환한다.
func LeadingZeros(x uint) int
func LeadingZeros16(x uint16) int
func LeadingZeros32(x uint32) int
func LeadingZeros64(x uint64) int
func LeadingZeros8(x uint8) intx 에서 선행 0 비트 수를 반환한다.
func Len(x uint) int
func Len16(x uint16) int
func Len32(x uint32) int
func Len64(x uint64) int
func Len8(x uint8) intx 를 나타내는데 필요한 최소 비트 수를 반환한다.
func Mul(x, y uint) (hi, lo uint)
func Mul32(x, y uint) (hi, lo uint32)
func Mul64(x, y uint) (hi, lo uint64)x 와 y 의 곱을 반환한다.
func OnesCount(x uint) int
func OnesCount16(x uint16) int
func OnesCount32(x uint32) int
func OnesCount64(x uint64) int
func OnesCount8(x uint8) intx 에서 1 비트 수를 반환한다.
func Rem(hi, lo, y uint) uint
func Rem32(hi, lo, y uint) uint32
func Rem64(hi, lo, y uint) uint64(hi, lo) 의 나머지를 y 로 나눈 값을 반환한다.
func Reverse(x uint) uint
func Reverse16(x uint) uint16
func Reverse32(x uint) uint32
func Reverse64(x uint) uint64
func Reverse8(x uint) uint8비트를 역순으로 x 값을 반환한다.
func ReverseBytes16(x uint16) uint16
func ReverseBytes32(x uint16) uint32
func ReverseBytes64(x uint16) uint64역순으로 바이트와 함께 x 값을 반환한다.
func RotateLeft(x uint, k int) uint
func RotateLeft16(x uint, k int) uint16
func RotateLeft32(x uint, k int) uint32
func RotateLeft64(x uint, k int) uint64
func RotateLeft8(x uint, k int) uint8k mod 비트 비트 만큼 왼쪽으로 회전된 x 값을 반환한다.
func Sub(x, y, borrow uint) (diff, borrowOut uint)
func Sub32(x, y, borrow uint) (diff, borrowOut uint)
func Sub64(x, y, borrow uint) (diff, borrowOut uint)x , y 및 차입의 차이를 반환한다.
func TrailingZero(x uint) int
func TrailingZero16(x uint) int16
func TrailingZero32(x uint) int32
func TrailingZero64(x uint) int64
func TrailingZero8(x uint) int8x 의 후행 0 비트 수를 반환한다.
