int512

int512 is not implemented in the current release.

Property	Value
Size	64 bytes (512 bits)
Minimum value	−2⁵¹¹ ≈ −6.703904 × 10¹⁵³
Maximum value	2⁵¹¹−1 ≈ 6.703904 × 10¹⁵³
Literal suffix	`i512`
Representation	Two's complement
Hardware support	Software-emulated on all targets

int512 is the widest signed integer in Rux — a fixed-width type whose size is identical on every target platform. Like all signed types it uses two's complement: the most significant bit is the sign bit. No mainstream CPU has native 512-bit arithmetic, so every operation is software-emulated; reserve it for the few algorithms that genuinely need this much precision.

Literals

let a: int512 = 1;  // explicit annotation
let b = 42i512;     // type suffix

If a literal value does not fit in int512, the compiler emits an error at compile time. See Literals for decimal, hexadecimal, octal, and binary forms.

Typical Use Cases

Large-integer cryptographic primitives
RSA-style modular arithmetic scaffolding

Arithmetic

Operator	Description	Compound
`+`	Addition	`+=`
`-`	Subtraction	`-=`
`*`	Multiplication	`*=`
`/`	Division	`/=`
`%`	Remainder	`%=`
`**`	Exponentiation	n/a

let a: int512 = 10;
let b: int512 = 3;

let sum  = a + b;   // 13
let quot = a / b;   // 3   truncates toward zero
let rem  = a % b;   // 1   carries the sign of the dividend

Division and remainder truncate toward zero, so the remainder takes the sign of the dividend: -7 % 2 is -1.

Overflow. In debug builds, signed overflow raises a fatal error. In release builds it wraps modulo 2⁵¹² in two's-complement fashion. Wraparound is well-defined in Rux (unlike C/C++), but relying on it is almost always a logic error.

Comparison

Operator	Description	Result
`==`	Equal	`bool`
`!=`	Not equal	`bool`
`<`	Less than	`bool`
`<=`	Less than or equal	`bool`
`>`	Greater than	`bool`
`>=`	Greater than or equal	`bool`

Both operands must have the same type. Comparing int512 with another integer type — or with an unsigned type such as uint512 — is a compile-time error; cast one operand explicitly first.

Shift and Bitwise

Right shift with >> on a signed value is arithmetic: vacated bits are filled with the sign bit, preserving the sign. To fill with zeros instead, use the logical right shift >>>, which keeps the same signed type and width.

let s: int512 = -8;
let r = s >> 2;     // -2   sign-filled (arithmetic) right shift

The bitwise operators &, |, ^, and ~ are also defined (~x equals −(x + 1)), but bitmask work usually reads more clearly on unsigned types.

Conversion

Rux performs no implicit numeric conversions — every conversion uses the as operator. Narrowing keeps only the low-order bits; a same-width signed↔unsigned cast reinterprets the bit pattern. int512 is the widest signed type, so there is no wider type to widen into.

let x: int512 = -1;
let small = x as int64;    // -1   narrowed, low 64 bits kept
let u     = x as uint512;  // 2^512 − 1   same width, bits reinterpreted