Struct digits::prelude::Digits [] [src]

pub struct Digits { /* fields omitted */ }

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.

Methods

impl Digits
[src]

[src]

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.

[src]

Returns a vector of each characters position mapping

[src]

Make numeric base size publicly available on Digits

[src]

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

[src]

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.

[src]

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

[src]

Returns bool value of if the number is one.

[src]

Returns bool value of if the number is zero.

[src]

Returns a usize of the total linked list length.

[src]

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.

[src]

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.

[src]

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.

[src]

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.

[src]

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

[src]

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.

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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.

[src]

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"

[src]

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

[src]

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.

[src]

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

[src]

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

[src]

An alias for clone. Useful for unboxing.

[src]

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

[src]

Plus one.

[src]

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

[src]

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

[src]

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

[src]

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

[src]

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

impl Clone for Digits
[src]

[src]

Returns a copy of the value. Read more

1.0.0
[src]

Performs copy-assignment from source. Read more

impl Reverse for Digits
[src]

[src]

Example Read more

impl From<(BaseCustom<char>, u64)> for Digits
[src]

[src]

Performs the conversion.

impl From<(BaseCustom<char>, Digits)> for Digits
[src]

[src]

Performs the conversion.

impl From<(Digits, Digits)> for Digits
[src]

[src]

Performs the conversion.

impl From<Digits> for String
[src]

[src]

Performs the conversion.

impl Into<String> for Digits
[src]

[src]

impl Display for Digits
[src]

[src]

Formats the value using the given formatter. Read more

impl Debug for Digits
[src]

[src]

Formats the value using the given formatter. Read more

impl PartialEq for Digits
[src]

[src]

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

1.0.0
[src]

This method tests for !=.

impl Add for Digits
[src]

The resulting type after applying the + operator.

[src]

Performs the + operation.

impl AddAssign for Digits
[src]

[src]

Performs the += operation.

impl Mul for Digits
[src]

The resulting type after applying the * operator.

[src]

Performs the * operation.

impl MulAssign for Digits
[src]

[src]

Performs the *= operation.

impl BitXor for Digits
[src]

The resulting type after applying the ^ operator.

[src]

Performs the ^ operation.

impl BitXorAssign for Digits
[src]

[src]

Performs the ^= operation.

impl PartialOrd for Digits
[src]

[src]

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

1.0.0
[src]

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

1.0.0
[src]

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

1.0.0
[src]

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

1.0.0
[src]

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

impl Default for Digits
[src]

[src]

Returns the "default value" for a type. Read more

impl Radix for Digits
[src]

[src]

Convert current Digits to binary

[src]

Convert current Digits to octal

[src]

Convert current Digits to decimal

[src]

Convert current Digits to hexadecimal

[src]

Convert current Digits to lowercase hexadecimal