go 원본 읽기 노트(math.3)

go 원본 읽기 노트(math.3)
dim.go

package math

// Dim returns the maximum of x-y or 0.
//
// Special cases are:
// Dim(+Inf, +Inf) = NaN
// Dim(-Inf, -Inf) = NaN
// Dim(x, NaN) = Dim(NaN, x) = NaN
func Dim(x, y float64) float64

func dim(x, y float64) float64 {
    return max(x-y, 0)
}

func dim(x, y float64)float64, x-y와 0의 큰 자 반환
여기서 알 수 있듯이 호출된 함수 max()는 각종 이상 판단을 했기 때문에dim 함수에서는 각종 이상 판단이 필요하지 않습니다. 여기는 약간의 경험으로 삼을 수 있습니다.

// Max returns the larger of x or y.
//
// Special cases are:
// Max(x, +Inf) = Max(+Inf, x) = +Inf
// Max(x, NaN) = Max(NaN, x) = NaN
// Max(+0, ±0) = Max(±0, +0) = +0
// Max(-0, -0) = -0
func Max(x, y float64) float64

func max(x, y float64) float64 {
    // special cases
    switch {
    case IsInf(x, 1) || IsInf(y, 1):
        return Inf(1)
    case IsNaN(x) || IsNaN(y):
        return NaN()
    case x == 0 && x == y:
        if Signbit(x) {
            return y
        }
        return x
    }
    if x > y {
        return x
    }
    return y
}

여기서는 왜 판단해야 하는지 잘 모르겠다case x == 0 && x == y:. 아마도 나는 Signbit()라는 함수가 무엇에 쓰이는지 보아야 할 것 같다.

// Min returns the smaller of x or y.
//
// Special cases are:
// Min(x, -Inf) = Min(-Inf, x) = -Inf
// Min(x, NaN) = Min(NaN, x) = NaN
// Min(-0, ±0) = Min(±0, -0) = -0
func Min(x, y float64) float64

func min(x, y float64) float64 {
    // special cases
    switch {
    case IsInf(x, -1) || IsInf(y, -1):
        return Inf(-1)
    case IsNaN(x) || IsNaN(y):
        return NaN()
    case x == 0 && x == y:
        if Signbit(x) {
            return x
        }
        return y
    }
    if x < y {
        return x
    }
    return y
}

이것 괜찮아요?
남겨진 문제
뭘 판단해야 돼case x == 0 && x == y:,Signbit()라는 함수가 무슨 용도로 쓰이는지 봐야겠어?
floor.go
floor.go는 주로 한 수의 상계 또는 하계를 구한다

package math

// Floor returns the greatest integer value less than or equal to x.
//
// Special cases are:
// Floor(±0) = ±0
// Floor(±Inf) = ±Inf
// Floor(NaN) = NaN
func Floor(x float64) float64

func floor(x float64) float64 {
    if x == 0 || IsNaN(x) || IsInf(x, 0) {
        return x
    }
    if x < 0 {
        d, fract := Modf(-x)
        if fract != 0.0 {
            d = d + 1
        }
        return -d
    }
    d, _ := Modf(x)
    return d
}

func floor (x float64) float64, x보다 작은 최대 정수 반환
Modf () 함수는 무엇에 사용합니까?이 함수를 먼저 살펴보겠습니다.

// Modf returns integer and fractional floating-point numbers
// that sum to f. Both values have the same sign as f.
//
// Special cases are:
// Modf(±Inf) = ±Inf, NaN
// Modf(NaN) = NaN, NaN
func Modf(f float64) (int float64, frac float64)

func modf(f float64) (int float64, frac float64) {
    if f < 1 {
        switch {
        case f < 0:
            int, frac = Modf(-f)
            return -int, -frac
        case f == 0:
            return f, f // Return -0, -0 when f == -0
        }
        return 0, f
    }

    x := Float64bits(f)
    e := uint(x>>shift)&mask - bias

    // Keep the top 12+e bits, the integer part; clear the rest.
    if e < 64-12 {
        x &^= 1<<(64-12-e) - 1
    }
    int = Float64frombits(x)
    frac = f - int
    return
}

그러나, 나는 한참을 보았지만 여전히 이해하지 못했다. 나는 자세히 연구한 후, 이해한 후에 다시 설명하겠다
그럼에도 불구하고 위 코드를 통해 알 수 있듯이 Modf()는 하나의 수를 입력한 다음에 이 수의 정수 부분과 소수 부분을 되돌려준다. 예를 들어 1.5는 1.0과 0.5를 되돌려주고, -1.5는 -1.0과 -0.5를 되돌려준다.

// Ceil returns the least integer value greater than or equal to x.
//
// Special cases are:
// Ceil(±0) = ±0
// Ceil(±Inf) = ±Inf
// Ceil(NaN) = NaN
func Ceil(x float64) float64

func ceil(x float64) float64 {
    return -Floor(-x)
}

funcceil(xfloat64)float64, 묘하게 썼습니다. 참고할 수 있습니다. 대개 - x의 하계는 사실 x상계의 상반수입니다.
math 이 장은 기본적으로 수학 기교인 것 같아요.

// Trunc returns the integer value of x.
//
// Special cases are:
// Trunc(±0) = ±0
// Trunc(±Inf) = ±Inf
// Trunc(NaN) = NaN
func Trunc(x float64) float64

func trunc(x float64) float64 {
    if x == 0 || IsNaN(x) || IsInf(x, 0) {
        return x
    }
    d, _ := Modf(x)
    return d
}

func trunc(x float 64)float64는 f의 정수 부분을 되돌려줍니다