Struct largeint::largeint::LargeInt

pub struct LargeInt {
    pub digits: String,
    pub sign: Sign,
}

Arithmetic is carried out on instances of LargeInt. The scalar value is stored in a String and its sign in the enum Sign.

Fields

digits: String

Stores the scalar value of the LargeInt as a String.

sign: Sign

Stores the sign of the value as a Sign.

Methods

impl LargeInt

pub fn get_int(&self) -> String

Returns a copy of the scalar LargeInt value as a String.

pub fn get_sign(&self) -> String

Returns the Sign of the LargeInt value as a String.

pub fn compare(&self, large2: &LargeInt) -> Compare

Compares the scalar value of two LargeInts.

Examples

extern crate largeint;
use largeint::largeint::*;

let largeint1 = new(String::from("150"), Sign::Positive);
let largeint2 = new(String::from("100"), Sign::Positive);

assert_eq!(largeint1.compare(&largeint2), Compare::Larger);

pub fn add(&self, large2: &LargeInt) -> LargeInt

Adds two LargeInts together.

Examples

extern crate largeint;
use largeint::largeint::*;

let largeint1 = new(String::from("80000000000000000000000000000"), Sign::Positive);
let largeint2 = new(String::from("10000000000000000000000000000"), Sign::Positive);
let sum = largeint1.add(&largeint2);
let check = new(String::from("90000000000000000000000000000"), Sign::Positive);
assert_eq!(sum, check);

pub fn sub(&self, large2: &LargeInt) -> LargeInt

Subtracts a LargeInt from another.

Examples

extern crate largeint;
use largeint::largeint::*;

let largeint1 = new(String::from("80000000000000000000000000000"), Sign::Positive);
let largeint2 = new(String::from("10000000000000000000000000000"), Sign::Positive);
let sum = largeint1.sub(&largeint2);
let check = new(String::from("70000000000000000000000000000"), Sign::Positive);
assert_eq!(sum, check);

pub fn mul(&self, large2: &LargeInt) -> LargeInt

Multiplies two LargeInts together.

Examples

extern crate largeint;
use largeint::largeint::*;

let largeint1 = new(String::from("1110987654321"), Sign::Positive);
let largeint2 = new(String::from("1234567891011"), Sign::Negative);
let sum = largeint1.mul(&largeint2);
let check = new(String::from("1371589685334334871208531"), Sign::Negative);
assert_eq!(sum, check);

pub fn div(&self, large2: &LargeInt) -> LargeInt

Divides one LargeInt by another LargeInt.

Examples

extern crate largeint;
use largeint::largeint::*;

let largeint1 = new(String::from("3987382479238749823798759823745983748927"), Sign::Negative);
let largeint2 = new(String::from("98394783947982377583783759928"), Sign::Negative);
let sum = largeint1.div(&largeint2);
let check = new(String::from("40524327807"), Sign::Positive);
assert_eq!(sum, check);

pub fn rem(&self, large2: &LargeInt) -> LargeInt

Returns the remainder of a floor division operation.

Examples

extern crate largeint;
use largeint::largeint::*;

let largeint1 = new(String::from("3987382479238749823798759823745983748927"), Sign::Negative);
let largeint2 = new(String::from("98394783947982377583783759928"), Sign::Negative);
let sum = largeint1.rem(&largeint2);
let check = new(String::from("31770318334258129020721031031"), Sign::Positive);
assert_eq!(sum, check);

Trait Implementations

impl PartialEq for LargeInt

fn eq(&self, other: &LargeInt) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

This method tests for !=.

impl Debug for LargeInt

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

Formats the value using the given formatter.

impl Clone for LargeInt

fn clone(&self) -> LargeInt

Returns a copy of the value.

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

Performs copy-assignment from source.