Struct Int

pub struct Int<'l>(/* private fields */);

An arbitrary precision integer optimized for small values.

The implementation optimizes for the common case where integers are small enough to fit in native types, while gracefully handling arbitrarily large integers through string representation: small integers that fit in i128 are stored on the stack, while larger integers are stored as validated decimal strings. This avoids the overhead of big integer libraries for typical use cases.

Examples

use openmath::Int;

// Create from various integer types
let a = Int::from(42u8);
let b = Int::from(-123i64);
let c = Int::from(i128::MAX);

// Small integers are stored efficiently
let small = Int::from(42);
assert_eq!(small.is_i128(), Some(42));

// Create from strings for big integers
let big = Int::new("999999999999999999999999999999999999999999").expect("should be defined");
assert!(big.is_big().is_some());

// representation is chosen automatically:
let small = Int::new("-42").expect("should be defined");
assert_eq!(small.is_i128(), Some(-42));

Implementations

impl Int<'_>

pub const fn is_i128(&self) -> Option<i128>

Returns the value as an i128 if it fits, otherwise None.

This method allows you to check if the integer is small enough to be represented as a native i128 value.

Examples

use openmath::Int;

let small = Int::from(42);
assert_eq!(small.is_i128(), Some(42));

let big = Int::new("999999999999999999999999999999999999999999").expect("should be defined");
assert_eq!(big.is_i128(), None);

pub fn is_big(&self) -> Option<&str>

Returns the value as a string slice if it’s a big integer, otherwise None.

This method allows you to access the string representation of large integers that don’t fit in i128.

Examples

use openmath::Int;

let small = Int::from(42);
assert_eq!(small.is_big(), None);

let big = Int::new("999999999999999999999999999999999999999999").expect("should be defined");
assert_eq!(big.is_big(), Some("999999999999999999999999999999999999999999"));

pub fn new(num: &str) -> Option<Int<'_>>

Creates a new Int from a string slice.

The string must represent a valid decimal integer, optionally with a leading sign (+ or -). Returns None if the string is not a valid integer.

Examples

use openmath::Int;

assert!(Int::new("42").is_some());
assert!(Int::new("-123").is_some());
assert!(Int::new("+456").is_some());
assert!(Int::new("999999999999999999999999999999999999999999").is_some());

// Invalid formats
assert!(Int::new("12.34").is_none());
assert!(Int::new("abc").is_none());
assert!(Int::new("").is_none());

pub fn from_string(num: String) -> Option<Int<'static>>

Creates a new Int from an owned string.

Similar to new, but takes ownership of the string for cases where you want a 'static lifetime integer.

Examples

use openmath::Int;

let big_num = "12345678901234567890123456789012345678901234567890".to_string();
let int = Int::from_string(big_num).unwrap();
assert!(int.is_big().is_some());

pub const fn is_zero(&self) -> bool

Returns true if this integer represents zero.

Examples

use openmath::Int;

assert!(Int::from(0).is_zero());
assert!(Int::new("0").expect("should be defined").is_zero());
assert!(Int::new("+0").expect("should be defined").is_zero());
assert!(Int::new("-0").expect("should be defined").is_zero());
assert!(!Int::from(1).is_zero());

pub fn is_positive(&self) -> bool

Returns true if this integer is positive (> 0).

Examples

use openmath::Int;

assert!(Int::from(1).is_positive());
assert!(Int::new("999999999999999999999999999999999999999999").expect("should be defined").is_positive());
assert!(!Int::from(0).is_positive());
assert!(!Int::from(-1).is_positive());

pub fn is_negative(&self) -> bool

Returns true if this integer is negative (< 0).

Examples

use openmath::Int;

assert!(Int::from(-1).is_negative());
assert!(Int::new("-999999999999999999999999999999999999999999").expect("should be defined").is_negative());
assert!(!Int::from(0).is_negative());
assert!(!Int::from(1).is_negative());

pub fn into_owned(self) -> Int<'static>

Trait Implementations

impl<'l> Clone for Int<'l>

fn clone(&self) -> Int<'l>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'l> Debug for Int<'l>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Int<'de>

Available on crate feature serde only.

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Int<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'l> From<i128> for Int<'l>

fn from(value: i128) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<i16> for Int<'l>

fn from(value: i16) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<i32> for Int<'l>

fn from(value: i32) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<i64> for Int<'l>

fn from(value: i64) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<i8> for Int<'l>

fn from(value: i8) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<isize> for Int<'l>

fn from(value: isize) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<u16> for Int<'l>

fn from(value: u16) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<u32> for Int<'l>

fn from(value: u32) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<u64> for Int<'l>

fn from(value: u64) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<u8> for Int<'l>

fn from(value: u8) -> Int<'l>

Converts to this type from the input type.

impl<'l> From<usize> for Int<'l>

fn from(value: usize) -> Int<'l>

Converts to this type from the input type.

impl<'l> Hash for Int<'l>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<'d> OMDeserializable<'d> for Int<'d>

type Ret = Int<'d>

The type returned by from_openmath; Can be Self, but can also be something more complex so that OM-values can be “deferred” until enough information is there to construct a Self; See above for an example.

type Err = &'static str

The type of errors that can occur during deserialization.

fn from_openmath(om: OM<'d, Self>, _: &str) -> Result<Self, Self::Err>

where Self: Sized,

Attempt to deserialize an OpenMath object into this type.

fn from_openmath_xml(input: &'de str) -> Result<Self, XmlReadError<Self::Err>>

where Self: Sized,

Available on crate feature xml only.

Deserializes self from a string of OpenMath XML.

impl OMSerializable for Int<'_>

fn as_openmath<'s, S: OMSerializer<'s>>( &self, serializer: S, ) -> Result<S::Ok, S::Err>

Serialize this value using the provided serializer.

fn cdbase(&self) -> Option<&str>

fn openmath_display(&self) -> impl Display + Debug + use<'_, Self>

OpenMath-style Debug and Display implementations

fn openmath_serde(&self) -> impl Serialize + use<'_, Self>

Available on crate feature serde only.

Create a serde-compatible serializer wrapper.

fn xml(&self, pretty: bool) -> impl Display

Returns something that Displays as the OpenMath XML of this object.

fn omobject(&self) -> OMObject<'_, Self>

returns this element as something that serializes into an OMOBJ; i.e. a “top-level” OpenMath object.

impl<'l> Ord for Int<'l>

fn cmp(&self, other: &Int<'l>) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl<'l> PartialEq for Int<'l>

fn eq(&self, other: &Int<'l>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'l> PartialOrd for Int<'l>

fn partial_cmp(&self, other: &Int<'l>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl<'l> Serialize for Int<'l>

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'l> TryFrom<&'l str> for Int<'l>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: &'l str) -> Result<Self, Self::Error>

Performs the conversion.

impl<'l> TryFrom<Cow<'l, str>> for Int<'l>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: Cow<'l, str>) -> Result<Self, Self::Error>

Performs the conversion.

impl TryFrom<String> for Int<'_>

type Error = ()

The type returned in the event of a conversion error.

fn try_from(value: String) -> Result<Self, Self::Error>

Performs the conversion.

impl<'l> Eq for Int<'l>

impl<'l> StructuralPartialEq for Int<'l>