El valor máximo para un tipo int en Go

¿Cómo se especifica el valor máximo representable para un unsignedtipo entero?

Me gustaría saber cómo inicializar minen el ciclo a continuación que calcula iterativamente las longitudes mínimas y máximas de algunas estructuras.

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
}

por lo que la primera vez a través de la comparación, minLen >= n.

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

La parte pertinente:

Como los tipos enteros usan aritmética de complemento a dos, puede inferir los valores constantes min / max para inty uint. Por ejemplo,

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

Según el comentario de @ 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 para límites de tipo físico.

Los valores máximos se definen en el paquete matemático, por lo que en su caso: math.MaxUint32

Tenga cuidado, ya que no hay desbordamiento: el incremento del pasado máximo provoca una envoltura.

Usaría el mathpaquete para obtener el valor máximo y el valor mínimo:

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
}

Ouput:

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

Originalmente usé el código tomado del hilo de discusión que @nmichaels usó en su respuesta. Ahora uso un cálculo ligeramente diferente. He incluido algunos comentarios en caso de que alguien más tenga la misma consulta que @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
)

Los dos últimos pasos funcionan debido a cómo se representan los números positivos y negativos en la aritmética del complemento a dos. La sección de especificación del lenguaje Go sobre Tipos numéricos remite al lector al artículo relevante de Wikipedia . No he leído eso, pero aprendí sobre el complemento de dos del libro Code de Charles Petzold , que es una introducción muy accesible a los fundamentos de las computadoras y la codificación.

Puse el código de arriba (menos la mayoría de los comentarios) en un pequeño paquete matemático entero .

Sumario rápido:

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

Antecedentes:

Como supongo que ya sabes, el uinttipo es del mismo tamaño que sea uint32o uint64, dependiendo de la plataforma que se encuentra. Por lo general, uno usaría la versión sin tamaño de estos solo cuando no haya riesgo de acercarse al valor máximo, ya que la versión sin una especificación de tamaño puede usar el tipo "nativo", dependiendo de la plataforma, que tiende a ser más rápido.

Tenga en cuenta que tiende a ser "más rápido" porque el uso de un tipo no nativo a veces requiere que el procesador realice una comprobación matemática y de límites adicional para emular el número entero más grande o más pequeño. Con eso en mente, tenga en cuenta que el rendimiento del procesador (o el código optimizado del compilador) casi siempre será mejor que agregar su propio código de verificación de límites, por lo que si existe algún riesgo de que entre en juego, puede tiene sentido usar simplemente la versión de tamaño fijo y dejar que la emulación optimizada se encargue de las consecuencias de eso.

Dicho esto, todavía hay algunas situaciones en las que es útil saber con qué está trabajando.

El paquete " matemáticas / bits " contiene el tamaño de uint, en bits. Para determinar el valor máximo, cambie 1esa cantidad de bits, menos 1. es decir:(1 << bits.UintSize) - 1

Tenga en cuenta que al calcular el valor máximo de uint, generalmente tendrá que ponerlo explícitamente en una uintvariable (o más grande), de lo contrario, el compilador puede fallar, ya que de forma predeterminada intentará asignar ese cálculo a un signoint (donde, como debería sea ​​obvio, no encajaría), entonces:

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

Esa es la respuesta directa a su pregunta, pero también hay algunos cálculos relacionados que pueden interesarle.

Según la especificación , uinty intsiempre son del mismo tamaño.

uint ya sea 32 o 64 bits

int mismo tamaño que uint

Entonces, también podemos usar esta constante para determinar el valor máximo de int, tomando esa misma respuesta y dividiendo para 2luego restar1 . es decir:(1 << bits.UintSize) / 2 - 1

Y el valor mínimo de int, cambiando 1por tantos bits y dividiendo el resultado entre -2. es decir:(1 << bits.UintSize) / -2

En resumen:

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

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

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

ejemplo completo (debe ser el mismo que se muestra a continuación)

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)
}

Desde lib matemática: 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)
}

Una forma de resolver este problema es obtener los puntos de partida de los valores mismos:

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 }
  }
}

Un paquete liviano los contiene (así como otros límites de tipos int y algunas funciones enteras ampliamente utilizadas):

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