based 0.1.0

Custom numerical bases
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! # based
//!
//! `based` supports the creation of bases with custom digits,
//! where each digit is one character. 
//!
//! `based` does not currently support multiple-character digits.
//!


use std::ops::{AddAssign, MulAssign};

#[derive(Debug)]
/// Error type produced when [`Base::from_str`](Base::from_str) encounters an unknown character.
/// Contains the unknown character.
pub struct UnknownChar(char);

impl std::fmt::Display for UnknownChar {
  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
      write!(f, "Encountered char {} not in base", self.0)
  }
}

impl std::error::Error for UnknownChar {
  fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
      None
  }
}

/// The Base of a numeral system.
pub struct Base {
  base: Vec<char>,
  vals: std::collections::HashMap<char, usize>,
}

impl std::fmt::Display for Base {
  fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
      write!(f, "{}", self.base.iter().collect::<String>())
  }
}

impl Base {
  /// Creates a new base from the given string slice.
  /// 
  /// The value of each character is its index in the slice,
  /// e.g. the first character has value 1, the second
  /// value 2, etc.
  /// 
  /// The behavior of the function is undefined when
  /// a character is present more than once in the given
  /// string slice.
  ///
  /// # Examples
  ///
  /// ```
  /// use based::Base;
  ///
  /// let base16 = based::Base::new("0123456789abcdef");
  /// ```
  pub fn new(base: &str) -> Base {
    let mut vals: std::collections::HashMap<char, usize> = base
    .chars()
    .enumerate()
    .map(|(i, c)| (c, i))
    .collect();
    vals.shrink_to_fit();

    let mut base: Vec<char> = base.chars().collect();
    base.shrink_to_fit();

    Base {
      base,
      vals, 
    }
  }

  /// Given a base and a number's representation
  /// in that base, return the number.
  ///
  /// Returns `Err` if it encounters a character not in the `Base`.
  ///
  /// # Examples
  /// 
  /// ```
  /// use based::Base;
  ///
  /// let base16 = Base::new("0123456789abcdef");
  /// let sixteen = base16.from_str::<usize>("10");
  /// assert_eq!(sixteen.unwrap(), 16);
  /// ```
  pub fn from_str<T: AddAssign + std::default::Default + MulAssign + std::convert::From<usize>>(&self, rep: &str) -> Result<T, UnknownChar> {
    let mut val: T = Default::default();
    let radix = self.base.len();
    for c in rep.chars() {
      match self.vals.get(&c) {
        None => return Err(UnknownChar(c)),
        Some(v) => {
          val *= T::from(radix);
          val += T::from(*v);
        }
      }
    }
    Ok(val)
  }

  /// Given a base and a number, return the 
  /// representation of the number in the base.
  /// # Examples
  /// 
  /// ```
  /// use based::Base;
  ///
  /// let base16 = Base::new("0123456789abcdef");
  /// let sixteen = base16.rep::<usize>(16);
  /// assert_eq!(sixteen, "10");
  /// ```
  pub fn rep<T: std::convert::Into<usize>>(&self, val: T) -> String {
    let mut stack = Vec::new();
    let radix = self.base.len();
    let into = val.into();
    let mut rem = into % radix;
    stack.push(self.base[rem]);
    let mut div = into / radix;
    while div > 0 {
      rem = div % radix;
      div = div / radix;
      stack.push(self.base[rem]);
    } 
    stack.reverse();
    stack.into_iter().collect()
  }
}