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
sourceimpl Digits
impl Digits
sourcepub fn add(&self, other: Self) -> Self
pub fn add(&self, other: Self) -> Self
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.
sourcepub fn as_mapping_vec(&self) -> Vec<u64>
pub fn as_mapping_vec(&self) -> Vec<u64>
Returns a vector of each characters position mapping
sourcepub fn gen<T>(&self, other: T) -> Self where
Self: From<(BaseCustom<char>, T)>,
pub fn gen<T>(&self, other: T) -> Self where
Self: From<(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::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");
sourcepub fn is_valid_adjacent(&self, adjacent: usize) -> bool
pub fn is_valid_adjacent(&self, adjacent: usize) -> bool
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
.
sourcepub fn is_compat(&self, other: &Self) -> bool
pub fn is_compat(&self, other: &Self) -> bool
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));
sourcepub fn max_adjacent(&self) -> usize
pub fn max_adjacent(&self) -> usize
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.
sourcepub fn mul(&self, other: Self) -> Self
pub fn mul(&self, other: Self) -> Self
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.
sourcepub fn mut_add(&mut self, other: Self) -> Self
pub fn mut_add(&mut self, other: Self) -> Self
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.
sourcepub fn mut_mul(&mut self, other: Self) -> Self
pub fn mut_mul(&mut self, other: Self) -> Self
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.
sourcepub fn new<S>(mapping: BaseCustom<char>, number: S) -> Digits where
S: Into<String>,
pub fn new<S>(mapping: BaseCustom<char>, number: S) -> Digits 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.
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");
sourcepub fn new_mapped(&self, places: &[u64]) -> Result<Self, &'static str>
pub fn new_mapped(&self, places: &[u64]) -> Result<Self, &'static str>
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.
sourcepub fn new_one(mapping: BaseCustom<char>) -> Self
pub fn new_one(mapping: BaseCustom<char>) -> Self
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");
sourcepub fn new_zero(mapping: BaseCustom<char>) -> Self
pub fn new_zero(mapping: BaseCustom<char>) -> Self
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");
sourcepub fn next_non_adjacent(&mut self, adjacent: usize) -> Self
pub fn next_non_adjacent(&mut self, adjacent: usize) -> Self
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");
sourcepub fn one(&self) -> Self
pub fn one(&self) -> Self
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");
sourcepub fn pinky(&self) -> char
pub 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.
sourcepub fn pow(&mut self, pwr: Self) -> Self
pub fn pow(&mut self, pwr: Self) -> Self
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"
sourcepub fn pred_till_zero(&mut self) -> Self
pub fn pred_till_zero(&mut self) -> Self
Minuses one unless it’s zero, then it just returns a Digits instance of zero.
sourcepub fn prep_non_adjacent(&mut self, adjacent: usize) -> Self
pub fn prep_non_adjacent(&mut self, adjacent: usize) -> Self
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.
sourcepub fn propagate<S>(&self, number: S) -> Self where
S: Into<String>,
pub 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.
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");
sourcepub fn rcount(&self, character_index: u8) -> usize
pub fn rcount(&self, character_index: u8) -> usize
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
sourcepub fn step_non_adjacent(&mut self, adjacent: usize) -> Self
pub fn step_non_adjacent(&mut self, adjacent: usize) -> Self
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");
sourcepub fn to_s(&self) -> String
pub fn to_s(&self) -> String
Gives the full value of all digits within the linked list as a String.
sourcepub fn to_string(&self) -> String
pub fn to_string(&self) -> String
Gives the full value of all digits within the linked list as a String.
sourcepub fn zero(&self) -> Self
pub fn zero(&self) -> Self
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");
sourcepub fn zero_fill(&mut self, length: usize)
pub fn zero_fill(&mut self, length: usize)
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");
Trait Implementations
sourceimpl AddAssign<Digits> for Digits
impl AddAssign<Digits> for Digits
sourcefn add_assign(&mut self, other: Self)
fn add_assign(&mut self, other: Self)
Performs the +=
operation. Read more
sourceimpl BitXorAssign<Digits> for Digits
impl BitXorAssign<Digits> for Digits
sourcefn bitxor_assign(&mut self, other: Self)
fn bitxor_assign(&mut self, other: Self)
Performs the ^=
operation. Read more
sourceimpl MulAssign<Digits> for Digits
impl MulAssign<Digits> for Digits
sourcefn mul_assign(&mut self, other: Self)
fn mul_assign(&mut self, other: Self)
Performs the *=
operation. Read more
sourceimpl PartialOrd<Digits> for Digits
impl PartialOrd<Digits> for Digits
sourcefn partial_cmp(&self, other: &Digits) -> Option<Ordering>
fn partial_cmp(&self, other: &Digits) -> Option<Ordering>
This method returns an ordering between self
and other
values if one exists. Read more
1.0.0 · sourcefn lt(&self, other: &Rhs) -> bool
fn lt(&self, other: &Rhs) -> bool
This method tests less than (for self
and other
) and is used by the <
operator. Read more
1.0.0 · sourcefn le(&self, other: &Rhs) -> bool
fn le(&self, other: &Rhs) -> bool
This method tests less than or equal to (for self
and other
) and is used by the <=
operator. Read more
Auto Trait Implementations
impl RefUnwindSafe for Digits
impl Send for Digits
impl Sync for Digits
impl Unpin for Digits
impl UnwindSafe for Digits
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> ToOwned for T where
T: Clone,
impl<T> ToOwned for T where
T: Clone,
type Owned = T
type Owned = T
The resulting type after obtaining ownership.
sourcefn clone_into(&self, target: &mut T)
fn clone_into(&self, target: &mut T)
toowned_clone_into
)Uses borrowed data to replace owned data, usually by cloning. Read more