Struct digits::Digits

pub struct Digits<'a> { /* fields omitted */ }

This struct acts similar to a full number with a custom numeric character base. But the underlying implementation is a linked list where all the methods recurse as far as need to to implement the operations.

Methods

impl<'a> Digits<'a>

fn add(&self, other: Self) -> Self

Add two Digits instances together.

Example

use digits::{BaseCustom,Digits};

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());

let mut eleven = Digits::new(&base10, "11".to_string());
let two = Digits::new(&base10, "2".to_string());

assert_eq!(eleven.add(two).to_s(), "13");

Output

"13"

fn gen<T>(&self, other: T) -> Self where
    Self: From<(&'a BaseCustom<char>, T)>, 

Allows you to generate/encode a Digits from a u64 or other Digits even if they are of a different numeric base.

Example

use digits::{BaseCustom,Digits};

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());

let two = Digits::new(&base10, "2".to_string());
let three = two.gen(3_u64);

assert_eq!(three.to_s(), "3");

fn is_one(&self) -> bool

Returns bool value of if the number is one.

fn is_zero(&self) -> bool

Returns bool value of if the number is zero.

fn length(&self) -> usize

Returns a usize of the total linked list length.

fn mul(&self, other: Self) -> Self

Multiply two Digits instances together.

Example

use digits::{BaseCustom,Digits};

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());

let mut eleven = Digits::new(&base10, "11".to_string());
let two = Digits::new(&base10, "2".to_string());

assert_eq!(eleven.mul(two).to_s(), "22");

Output

"22"

fn mut_add(&mut self, other: Self) -> Self

Add two Digits instances together. The one the mut_add method is called on must be mutable and modifies itself. The other is consumed.

Example

use digits::{BaseCustom,Digits};

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());

let mut eleven = Digits::new(&base10, "11".to_string());
let two = Digits::new(&base10, "2".to_string());

assert_eq!(eleven.mut_add(two).to_s(), "13");

Output

"13"

fn mut_mul(&mut self, other: Self) -> Self

Multiply two Digits instances together. The one the mut_mul method is called on must be mutable and modifies itself. The other is consumed.

Example

use digits::{BaseCustom,Digits};

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());

let mut eleven = Digits::new(&base10, "11".to_string());
let two = Digits::new(&base10, "2".to_string());

assert_eq!(eleven.mut_mul(two).to_s(), "22");

Output

"22"

fn new<S>(mapping: &'a BaseCustom<char>, number: S) -> Digits<'a> where
    S: Into<String>, 

Creates a new Digits instance with the provided character set and value.

The first parameter must be a BaseCustom object which defines and maps all values. The second parameter is a string value with all valid characters from the BaseCustom set.

fn new_one(mapping: &'a BaseCustom<char>) -> Self

Creates a new Digits instance with value of one and the provided character mapping.

fn new_zero(mapping: &'a BaseCustom<char>) -> Self

Creates a new Digits instance with value of zero and uses the provided character mapping.

fn one(&self) -> Self

Creates a new Digits instance with value of one and uses the current character mapping.

fn pinky(&self) -> char

The “pinky” is the smallest digit a.k.a. current digit in the linked list a.k.a. the right most digit. This will be a char value for that digit.

fn pow(&mut self, pwr: Self) -> Self

Multiplies self times the power-of given Digits parameter.

Example

use digits::{BaseCustom,Digits};

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());

let mut eleven = Digits::new(&base10, "11".to_string());
let two = Digits::new(&base10, "2".to_string());

assert_eq!(eleven.pow(two).to_s(), "121");

Output

"121"

fn pred_till_zero(&mut self) -> Self

Minuses one unless it's zero, then it just returns a Digits instance of zero.

fn propagate<S>(&self, number: S) -> Self where
    S: Into<String>, 

Creates a new Digits instance with the internal character set and given value.

The parameter is a string value with all valid characters from the BaseCustom set.

fn replicate(self) -> Self

An alias for clone. Useful for unboxing.

fn succ(&mut self) -> Self

Plus one.

fn to_s(&self) -> String

Gives the full value of all digits within the linked list as a String.

fn to_string(&self) -> String

Gives the full value of all digits within the linked list as a String.

fn zero(&self) -> Self

Creates a new Digits instance with value of zero and the current character mapping.

Trait Implementations

impl<'a> Clone for Digits<'a>

fn clone(&self) -> Digits<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> From<(&'a BaseCustom<char>, u64)> for Digits<'a>

fn from(d: (&'a BaseCustom<char>, u64)) -> Digits<'a>

Performs the conversion.

impl<'a, 'b> From<(&'a BaseCustom<char>, Digits<'b>)> for Digits<'a>

fn from(d: (&'a BaseCustom<char>, Digits<'b>)) -> Digits<'a>

Performs the conversion.

impl<'a, 'b> From<(Digits<'a>, Digits<'b>)> for Digits<'a>

fn from(d: (Digits<'a>, Digits<'b>)) -> Digits<'a>

Performs the conversion.

impl<'a> Into<String> for Digits<'a>

fn into(self) -> String

impl<'a> Display for Digits<'a>

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

Formats the value using the given formatter.

impl<'a> Debug for Digits<'a>

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

Formats the value using the given formatter.

impl<'a> PartialEq for Digits<'a>

fn eq(&self, other: &Digits<'a>) -> bool

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

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

This method tests for !=.

impl<'a> Add for Digits<'a>

type Output = Self

The resulting type after applying the + operator

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

The method for the + operator

impl<'a> AddAssign for Digits<'a>

fn add_assign(&mut self, other: Self)

The method for the += operator

impl<'a> Mul for Digits<'a>

type Output = Self

The resulting type after applying the * operator

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

The method for the * operator

impl<'a> MulAssign for Digits<'a>

fn mul_assign(&mut self, other: Self)

The method for the *= operator

impl<'a> BitXor for Digits<'a>

type Output = Self

The resulting type after applying the ^ operator

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

The method for the ^ operator

impl<'a> BitXorAssign for Digits<'a>

fn bitxor_assign(&mut self, other: Self)

The method for the ^= operator

impl<'a> PartialOrd for Digits<'a>

fn partial_cmp(&self, other: &Digits<'a>) -> Option<Ordering>

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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