Struct digits::Digits

source · [−]
pub struct Digits { /* private fields */ }
Expand description

This struct acts similar to a full number with a custom numeric character base which is provided and mapped via a BaseCustom instance.

The underlying implementation for Digits is a linked list where all the methods recurse as far as need to to implement the operations.

Implementations

Add two Digits instances together.

Example
use digits::prelude::*;

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

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

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

This will panic if numeric bases are not the same.

Returns a vector of each characters position mapping

Make numeric base size publicly available on Digits

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::prelude::*;

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");

Returns true of false based on whether the limit of allowed adjacents is not exceeded. Early termination result when false.

Same as being a more efficient self.max_adjacent <= allowed_adjacent.

Returns whether the two Digits instances have the same numeric base and character mapping.

Example
use digits::prelude::*;

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

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

assert!(two.is_compat(&three));

Returns bool value of if the number is one.

Returns bool value of if the number is zero.

Returns a usize of the total linked list length.

Give the count for the maximum of the same adjacent characters for this digit.

Note that adjacent is a non-inclusive count. So for 7 numbers it’s 1 adjacent to 6 which will return 6.

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let num = Digits::new(base10, "557771".to_string());

assert_eq!(num.max_adjacent(), 2);

The above example demonstrates that there are 2 adjacent 7s next to a 7 and that is the biggest adjacent set of numbers.

Multiply two Digits instances together.

Example
use digits::prelude::*;

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

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

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

This will panic if numeric bases are not the same.

Add two Digits instances together.

Example
use digits::prelude::*;

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

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

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

This will panic if numeric bases are not the same.

Multiply two Digits instances together.

Example
use digits::prelude::*;

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

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

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

This will panic if numeric bases are not the same.

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.

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let nine = Digits::new(base10, "9".to_string());

assert_eq!(nine.to_s(), "9");

Create a Digits from a Vector of from zero positional mappings for custom Digits numeric base.

Example
use digits::prelude::*;

let base16 = BaseCustom::<char>::new("0123456789abcdef".chars().collect());
let builder = Digits::new(base16, "".to_string());
let num = builder.new_mapped(&vec![1,0,2,1]).ok().unwrap();

assert_eq!(num.to_s(), "1021");

If zero had been Z in the example above the same vector vec![1,0,2,1] would have produced a Digits instance of a Hex value of “1Z21”. The vector is the litteral positional map of the character(s) via an index from zero regardless of numeric base.

If a number provided within the vector is higher than the numeric base size then the method will return an Err(&'static str) Result.

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

Example
use digits::prelude::*;

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

assert_eq!(one.to_s(), "1");

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

Example
use digits::prelude::*;

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

assert_eq!(zero.to_s(), "0");

Returns the next Digits in incrementing that only allows the given number of adjacent number duplicates.

This will panic! if numeric base is less than 4.

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let mut num = Digits::new(base10, "98".to_string());

assert_eq!(num.next_non_adjacent(0).to_s(), "101");

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

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let nine = Digits::new(base10, "9".to_string());
let one = nine.one();

assert_eq!(one.to_s(), "1");

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.

Multiplies self times the power-of given Digits parameter.

Example
use digits::prelude::*;

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

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

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

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

Sometimes given starting Digits have more adjacent characters than is desired when proceeding with non-adjacent steps. This method provides a valid initial state for step_non_adjacent’s algorithm to not miss any initial steps.

_This method is used internally for next_non_adjacent.

This will panic! if numeric base is less than 4.

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let mut num = Digits::new(base10, "0003".to_string());

assert_eq!(num.prep_non_adjacent(1).to_s(), "0009");

In the example above the prep moves to a valid state of “0010” and then minuses one to “0009” so that step_non_adjacent will add 1 and return to the valid state of “0010” for this one-adjacent scenario.

For performance in your own applications use this method once and continue iterating with step_non_adjacent.

For convenience you may just use next_non_adjacent instead of prep and step.

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.

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let nine = Digits::new(base10, "9".to_string());
let forty_two = nine.propagate("42".to_string());

assert_eq!(forty_two.to_s(), "42");

Right count of digits character index.

Returns a usize of how many Digits values from the right match the BaseCustom index given for number.

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("ABC3456789".chars().collect());
let num = Digits::new(base10, "34BBB".to_string());

assert_eq!(num.rcount(1), 3);
Output
3

An alias for clone. Useful for unboxing.

Returns the next Digits in incrementing that only allows the given number of adjacent number duplicates.

This will panic! if numeric base is less than 4.

NOTE: This assumes the starting state is valid for given non adjacent characters. If you want to ensure this please use prep_adjacent before this, or just use next_non_adjacent to handle them both.

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let mut num = Digits::new(base10, "98".to_string());

assert_eq!(num.step_non_adjacent(0).to_s(), "101");

Plus one.

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

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

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

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let nine = Digits::new(base10, "9".to_string());
let zero = nine.zero();

assert_eq!(zero.to_s(), "0");

Zero fills the left of the current number up to a total character length.

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let mut nine = Digits::new(base10, "9".to_string());
nine.zero_fill(4);

assert_eq!(nine.to_s(), "0009");

Zero trims the left of the current number.

Example
use digits::prelude::*;

let base10 = BaseCustom::<char>::new("0123456789".chars().collect());
let mut nine = Digits::new(base10, "0009".to_string());
nine.zero_trim();

assert_eq!(nine.to_s(), "9");

Trait Implementations

The resulting type after applying the + operator.

Performs the + operation. Read more

Performs the += operation. Read more

The resulting type after applying the ^ operator.

Performs the ^ operation. Read more

Performs the ^= operation. Read more

Returns a copy of the value. Read more

Performs copy-assignment from source. Read more

Formats the value using the given formatter. Read more

Returns the “default value” for a type. Read more

Formats the value using the given formatter. Read more

Converts to this type from the input type.

Converts to this type from the input type.

Converts to this type from the input type.

Converts to this type from the input type.

The resulting type after applying the * operator.

Performs the * operation. Read more

Performs the *= operation. Read more

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

This method tests for !=.

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

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

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

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

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

Convert current Digits to binary

Convert current Digits to octal

Convert current Digits to decimal

Convert current Digits to hexadecimal

Convert current Digits to lowercase hexadecimal

Example Read more

Auto Trait Implementations

Blanket Implementations

Gets the TypeId of self. Read more

Immutably borrows from an owned value. Read more

Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The resulting type after obtaining ownership.

Creates owned data from borrowed data, usually by cloning. Read more

🔬 This is a nightly-only experimental API. (toowned_clone_into)

Uses borrowed data to replace owned data, usually by cloning. Read more

Converts the given value to a String. Read more

The type returned in the event of a conversion error.

Performs the conversion.

The type returned in the event of a conversion error.

Performs the conversion.