Максимальное значение для типа int в Go

Как указать максимальное значение, представляемое для unsignedцелочисленного типа?

Я хотел бы знать, как инициализировать minв цикле ниже, который итеративно вычисляет минимальную и максимальную длину из некоторых структур.

var minLen uint = ???
var maxLen uint = 0
for _, thing := range sliceOfThings {
  if minLen > thing.n { minLen = thing.n }
  if maxLen < thing.n { maxLen = thing.n }
}
if minLen > maxLen {
  // If there are no values, clamp min at 0 so that min <= max.
  minLen = 0
}

так что в первый раз через сравнение minLen >= n.

https://groups.google.com/group/golang-nuts/msg/71c307e4d73024ce?pli=1

Немецкая часть:

Поскольку целочисленные типы используют арифметику дополнения до двух, вы можете вывести константы min / max для intи uint. Например,

const MaxUint = ^uint(0) 
const MinUint = 0 
const MaxInt = int(MaxUint >> 1) 
const MinInt = -MaxInt - 1

Согласно комментарию @ CarelZA:

uint8  : 0 to 255 
uint16 : 0 to 65535 
uint32 : 0 to 4294967295 
uint64 : 0 to 18446744073709551615 
int8   : -128 to 127 
int16  : -32768 to 32767 
int32  : -2147483648 to 2147483647 
int64  : -9223372036854775808 to 9223372036854775807

https://golang.org/ref/spec#Numeric_types для ограничений физического типа.

Максимальные значения определены в математическом пакете, поэтому в вашем случае: math.MaxUint32

Следите за тем, чтобы не было переполнения - приращение выше максимума вызывает циклический переход.

Я бы использовал mathпакет для получения максимального значения и минимального значения:

func printMinMaxValue() {
    // integer max
    fmt.Printf("max int64 = %+v\n", math.MaxInt64)
    fmt.Printf("max int32 = %+v\n", math.MaxInt32)
    fmt.Printf("max int16 = %+v\n", math.MaxInt16)

    // integer min
    fmt.Printf("min int64 = %+v\n", math.MinInt64)
    fmt.Printf("min int32 = %+v\n", math.MinInt32)

    fmt.Printf("max flloat64= %+v\n", math.MaxFloat64)
    fmt.Printf("max float32= %+v\n", math.MaxFloat32)

    // etc you can see more int the `math`package
}

Выход:

max int64 = 9223372036854775807
max int32 = 2147483647
max int16 = 32767
min int64 = -9223372036854775808
min int32 = -2147483648
max flloat64= 1.7976931348623157e+308
max float32= 3.4028234663852886e+38

Первоначально я использовал код, взятый из ветки обсуждения, которую @nmichaels использовал в своем ответе. Сейчас я использую несколько иной расчет. Я добавил несколько комментариев на случай, если у кого-то еще есть тот же запрос, что и у @Arijoon

const (
    MinUint uint = 0                 // binary: all zeroes

    // Perform a bitwise NOT to change every bit from 0 to 1
    MaxUint      = ^MinUint          // binary: all ones

    // Shift the binary number to the right (i.e. divide by two)
    // to change the high bit to 0
    MaxInt       = int(MaxUint >> 1) // binary: all ones except high bit

    // Perform another bitwise NOT to change the high bit to 1 and
    // all other bits to 0
    MinInt       = ^MaxInt           // binary: all zeroes except high bit
)

Последние два шага работают из-за того, как положительные и отрицательные числа представлены в арифметике с дополнением до двух. Раздел спецификации языка Go о числовых типах отсылает читателя к соответствующей статье в Википедии . Я не читал этого, но я узнал о двух дополнениях из книги Чарльза Петцольда «Код» , которая представляет собой очень доступное введение в основы компьютеров и программирования.

Я поместил приведенный выше код (без большинства комментариев) в небольшой пакет целочисленных математических вычислений .

Краткое резюме:

import "math/bits"
const (
    MaxUint uint = (1 << bits.UintSize) - 1
    MaxInt int = (1 << bits.UintSize) / 2 - 1
    MinInt int = (1 << bits.UintSize) / -2
)

Задний план:

Как я полагаю, вы знаете, uintтип имеет тот же размер, что и uint32или uint64, в зависимости от платформы, на которой вы находитесь. Обычно их версию без размера можно использовать только тогда, когда нет риска приблизиться к максимальному значению, так как версия без спецификации размера может использовать «собственный» тип, в зависимости от платформы, который, как правило, работает быстрее.

Обратите внимание, что он имеет тенденцию быть «быстрее», потому что использование неродного типа иногда требует дополнительных вычислений и проверки границ, выполняемых процессором для имитации большего или меньшего целого числа. Имея это в виду, имейте в виду, что производительность процессора (или оптимизированного кода компилятора) почти всегда будет лучше, чем добавление собственного кода проверки границ, поэтому, если есть какой-либо риск, что он вступит в игру, он может сделать имеет смысл просто использовать версию с фиксированным размером и позволить оптимизированной эмуляции справиться с любыми последствиями этого.

С учетом вышесказанного, все еще есть ситуации, когда полезно знать, с чем вы работаете.

Пакет " math / bits " содержит размер uintв битах. Чтобы определить максимальное значение, сдвиньте 1это количество бит, минус 1. т.е.(1 << bits.UintSize) - 1

Обратите внимание, что при вычислении максимального значения uintвам, как правило, необходимо явно поместить его в uintпеременную (или более крупную), иначе компилятор может выйти из строя, так как по умолчанию он будет пытаться присвоить это вычисление подписанной int(где, как следует очевидно, не подошло бы), поэтому:

const MaxUint uint = (1 << bits.UintSize) - 1

Это прямой ответ на ваш вопрос, но есть также пара связанных расчетов, которые могут вас заинтересовать.

Согласно спецификации , uintи intвсегда одинаковый размер.

uint либо 32, либо 64 бит

int такой же размер как uint

Таким образом, мы также можем использовать эту константу для определения максимального значения int, взяв тот же ответ и разделив его на 2вычитание 1. то есть:(1 << bits.UintSize) / 2 - 1

И минимальное значение int, сдвинувшись 1на это количество бит и разделив результат на -2. то есть:(1 << bits.UintSize) / -2

В итоге:

MaxUint: (1 << bits.UintSize) - 1

MaxInt: (1 << bits.UintSize) / 2 - 1

MinInt: (1 << bits.UintSize) / -2

полный пример (должен быть таким же, как показано ниже)

package main

import "fmt"
import "math"
import "math/bits"

func main() {
    var mi32 int64 = math.MinInt32
    var mi64 int64 = math.MinInt64

    var i32 uint64 = math.MaxInt32
    var ui32 uint64 = math.MaxUint32
    var i64 uint64 = math.MaxInt64
    var ui64 uint64 = math.MaxUint64
    var ui uint64 = (1 << bits.UintSize) - 1
    var i uint64 = (1 << bits.UintSize) / 2 - 1
    var mi int64 = (1 << bits.UintSize) / -2

    fmt.Printf(" MinInt32: %d\n", mi32)
    fmt.Printf(" MaxInt32:  %d\n", i32)
    fmt.Printf("MaxUint32:  %d\n", ui32)
    fmt.Printf(" MinInt64: %d\n", mi64)
    fmt.Printf(" MaxInt64:  %d\n", i64)
    fmt.Printf("MaxUint64:  %d\n", ui64)
    fmt.Printf("  MaxUint:  %d\n", ui)
    fmt.Printf("   MinInt: %d\n", mi)
    fmt.Printf("   MaxInt:  %d\n", i)
}

Из математической библиотеки: https://github.com/golang/go/blob/master/src/math/const.go#L39

package main

import (
    "fmt"
    "math"
)

func main() {
    fmt.Printf("max int64: %d\n", math.MaxInt64)
}

Один из способов решить эту проблему - получить начальные точки из самих значений:

var minLen, maxLen uint
if len(sliceOfThings) > 0 {
  minLen = sliceOfThings[0].minLen
  maxLen = sliceOfThings[0].maxLen
  for _, thing := range sliceOfThings[1:] {
    if minLen > thing.minLen { minLen = thing.minLen }
    if maxLen < thing.maxLen { maxLen = thing.maxLen }
  }
}

Легкий пакет содержит их (а также ограничения на другие типы int и некоторые широко используемые целочисленные функции):

import (
    "fmt"
    "<Full URL>/go-imath/ix"
    "<Full URL>/go-imath/ux"
)
...
fmt.Println(ix.Minimal) // Output: -2147483648 (32-bit) or -9223372036854775808 (64-bit)
fmt.Println(ix.Maximal) // Output: 2147483647 or 9223372036854775807
fmt.Println(ux.Minimal) // Output: 0
fmt.Println(ux.Maximal) // Output: 4294967295 or 18446744073709551615

MaxInt8   = 1<<7 - 1
MinInt8   = -1 << 7
MaxInt16  = 1<<15 - 1
MinInt16  = -1 << 15
MaxInt32  = 1<<31 - 1
MinInt32  = -1 << 31
MaxInt64  = 1<<63 - 1
MinInt64  = -1 << 63
MaxUint8  = 1<<8 - 1
MaxUint16 = 1<<16 - 1
MaxUint32 = 1<<32 - 1
MaxUint64 = 1<<64 - 1

Используйте константы, определенные в математическом пакете :

const (
    MaxInt8   = 1<<7 - 1
    MinInt8   = -1 << 7
    MaxInt16  = 1<<15 - 1
    MinInt16  = -1 << 15
    MaxInt32  = 1<<31 - 1
    MinInt32  = -1 << 31
    MaxInt64  = 1<<63 - 1
    MinInt64  = -1 << 63
    MaxUint8  = 1<<8 - 1
    MaxUint16 = 1<<16 - 1
    MaxUint32 = 1<<32 - 1
    MaxUint64 = 1<<64 - 1
)