Struct StringRadix

pub struct StringRadix { /* private fields */ }

Radix number, that is usually written as number_base (444₈ for example), but number is represented as String so base could be from range 2..=36.

Implementations

impl StringRadix

pub fn new(base: u8) -> Result<Self, RadixError>

Creates a new StringRadix.

Errors

Returns a BaseError when base isn’t correct.

Examples

use ognlib::num::radix::StringRadix;

let n = StringRadix::new(2).unwrap();
assert_eq!(n.number(), "0");
assert_eq!(n.base(), 2);

let e1 = StringRadix::new(1).unwrap_err();
assert_eq!(e1.to_string(), "Expected base in range `2..=36`, found 1");

let e2 = StringRadix::new(255).unwrap_err();
assert_eq!(e2.to_string(), "Expected base in range `2..=36`, found 255");

pub fn from_radix(number: &str, base: u8) -> Result<Self, RadixError>

Creates a new StringRadix with given str number and base.

Errors

Returns a BaseError when base isn’t correct or NumberError when number contains digit that are more or equal than base.

Examples

use ognlib::num::radix::StringRadix;

let n = StringRadix::from_radix("11010000", 2).unwrap();
assert_eq!(n.number(), "11010000");
assert_eq!(n.base(), 2);

let e = StringRadix::from_radix("129", 9).unwrap_err();
assert_eq!(e.to_string(), "Number contains a digit (9) that is more or equal than base (9)",);

pub fn number(&self) -> &str

Returns a number of StringRadix.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();

assert_eq!(radix.number(), "444");

pub const fn base(&self) -> u8

Returns a base of StringRadix.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();

assert_eq!(radix.base(), 5);

pub fn radix(&self) -> (&str, u8)

Returns a full StringRadix as tuple (number, base).

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();

assert_eq!(radix.radix(), ("444", 5));

pub fn to_radix(&mut self, base: u8) -> Result<Self, RadixError>

Translate StringRadix to another StringRadix.

Panics

Panics if k is less than 2 or k more than 36.

Errors

Returns a BaseError when base isn’t correct; ParseError if there was error with parse functions.

Examples

use ognlib::num::radix::StringRadix;

let mut n = StringRadix::from_radix("11010000", 2).unwrap();
let mut res = n.to_radix(16).unwrap();
assert_eq!(res.radix(), ("D0", 16));

let e = res.to_radix(42).unwrap_err();
assert_eq!(e.to_string(), "Expected base in range `2..=36`, found 42");

pub fn to_int_radix(&mut self, base: u8) -> Result<Radix, RadixError>

Translate StringRadix to another Radix.

Panics

Panics if k is less than 2 or k more than 36.

Errors

Returns a BaseError when base isn’t correct; ParseError if there was error with parse functions.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let mut n = StringRadix::from_radix("D14", 16).unwrap();
let res = n.to_int_radix(2).unwrap();
assert_eq!(res.radix(), (110100010100, 2));

let e = n.to_int_radix(12).unwrap_err();
assert_eq!(e.to_string(), "Expected base in range `2..=10`, found 12");

pub fn add_to_int(self, other: Self, base: u8) -> Result<Radix, RadixError>

Sum 2 StringRadix to new Radix.

Errors

Same as to_int_radix.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = StringRadix::from_radix("123", 4).unwrap();
let n2 = StringRadix::from_radix("444", 5).unwrap();

let res = StringRadix::add_to_int(n1, n2, 8).unwrap();
assert_eq!(res.radix(), (227, 8));

pub fn sub_to_int(self, other: Self, base: u8) -> Result<Radix, RadixError>

Sub 2 StringRadix to new Radix.

Errors

Same as to_int_radix.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = StringRadix::from_radix("123", 4).unwrap();
let n2 = StringRadix::from_radix("444", 5).unwrap();

let res = StringRadix::sub_to_int(n2, n1, 8).unwrap();
assert_eq!(res.radix(), (141, 8));

pub fn mul_to_int(self, other: Self, base: u8) -> Result<Radix, RadixError>

Mul 2 StringRadix to new Radix.

Errors

Same as to_int_radix.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = StringRadix::from_radix("123", 4).unwrap();
let n2 = StringRadix::from_radix("444", 5).unwrap();

let res = StringRadix::mul_to_int(n1, n2, 8).unwrap();
assert_eq!(res.radix(), (6424, 8));

Trait Implementations

impl Add<usize> for StringRadix

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

Performs a + operation (usize as rhs).

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n = Radix::from_radix(123, 4).unwrap();
let n_str = StringRadix::from_radix("123", 4).unwrap();

let res = (n + 124).to_radix(8).unwrap();
let res_str = (n_str + 124).to_radix(8).unwrap();

assert_eq!(res.radix(), (227, 8));
assert_eq!(res_str.radix(), ("227", 8));

type Output = StringRadix

The resulting type after applying the + operator.

impl Add for StringRadix

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

Performs a + operation.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = Radix::from_radix(123, 4).unwrap();
let n2 = Radix::from_radix(444, 5).unwrap();
let n_str1 = StringRadix::from_radix("123", 4).unwrap();
let n_str2 = StringRadix::from_radix("444", 5).unwrap();

let res = (n1 + n2).to_radix(8).unwrap();
let res_str = (n_str1 + n_str2).to_radix(8).unwrap();

assert_eq!(res.radix(), (227, 8));
assert_eq!(res_str.radix(), ("227", 8));

type Output = StringRadix

The resulting type after applying the + operator.

impl AddAssign<usize> for StringRadix

fn add_assign(&mut self, other: usize)

Performs a += operation (usize is rhs).

Examples

use ognlib::num::radix::{Radix, StringRadix};

let mut n = Radix::from_radix(123, 4).unwrap();
let mut n_str = StringRadix::from_radix("123", 4).unwrap();

n += 124;
n_str += 124;

n = n.to_radix(8).unwrap();
n_str = n_str.to_radix(8).unwrap();

assert_eq!(n.radix(), (227, 8));
assert_eq!(n_str.radix(), ("227", 8));

impl AddAssign for StringRadix

fn add_assign(&mut self, other: Self)

Performs a += operation.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let mut n1 = Radix::from_radix(123, 4).unwrap();
let n2 = Radix::from_radix(444, 5).unwrap();
let mut n_str1 = StringRadix::from_radix("123", 4).unwrap();
let n_str2 = StringRadix::from_radix("444", 5).unwrap();

n1 += n2;
n_str1 += n_str2;

n1 = n1.to_radix(8).unwrap();
n_str1 = n_str1.to_radix(8).unwrap();

assert_eq!(n1.radix(), (227, 8));
assert_eq!(n_str1.radix(), ("227", 8));

impl Clone for StringRadix

fn clone(&self) -> StringRadix

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for StringRadix

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

Formats the value using the given formatter.

impl Div<usize> for StringRadix

fn div(self, other: usize) -> Self::Output

Performs a / operation (usize as rhs).

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n = Radix::from_radix(444, 5).unwrap();
let n_str = StringRadix::from_radix("444", 5).unwrap();

let res = (n / 27).to_radix(8).unwrap();
let res_str = (n_str / 27).to_radix(8).unwrap();

assert_eq!(res.radix(), (4, 8));
assert_eq!(res_str.radix(), ("4", 8));

type Output = StringRadix

The resulting type after applying the / operator.

impl Div for StringRadix

fn div(self, other: Self) -> Self::Output

Performs a / operation.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = Radix::from_radix(123, 4).unwrap();
let n2 = Radix::from_radix(444, 5).unwrap();
let n_str1 = StringRadix::from_radix("123", 4).unwrap();
let n_str2 = StringRadix::from_radix("444", 5).unwrap();

let res = (n2 / n1).to_radix(8).unwrap();
let res_str = (n_str2 / n_str1).to_radix(8).unwrap();

assert_eq!(res.radix(), (4, 8));
assert_eq!(res_str.radix(), ("4", 8));

type Output = StringRadix

The resulting type after applying the / operator.

impl DivAssign<usize> for StringRadix

fn div_assign(&mut self, other: usize)

Performs a /= operation (usize as rhs).

Examples

use ognlib::num::radix::{Radix, StringRadix};

let mut n = Radix::from_radix(444, 5).unwrap();
let mut n_str = StringRadix::from_radix("444", 5).unwrap();

n /= 27;
n_str /= 27;

n = n.to_radix(8).unwrap();
n_str = n_str.to_radix(8).unwrap();

assert_eq!(n.radix(), (4, 8));
assert_eq!(n_str.radix(), ("4", 8));

impl DivAssign for StringRadix

fn div_assign(&mut self, other: Self)

Performs a /= operation.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = Radix::from_radix(123, 4).unwrap();
let mut n2 = Radix::from_radix(444, 5).unwrap();
let n_str1 = StringRadix::from_radix("123", 4).unwrap();
let mut n_str2 = StringRadix::from_radix("444", 5).unwrap();

n2 /= n1;
n_str2 /= n_str1;

n2 = n2.to_radix(8).unwrap();
n_str2 = n_str2.to_radix(8).unwrap();

assert_eq!(n2.radix(), (4, 8));
assert_eq!(n_str2.radix(), ("4", 8));

impl From<&StringRadix> for i16

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: i16 = radix.into();

assert_eq!(num, 124i16);

impl From<&StringRadix> for i32

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: i32 = radix.into();

assert_eq!(num, 124i32);

impl From<&StringRadix> for i64

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: i64 = radix.into();

assert_eq!(num, 124i64);

impl From<&StringRadix> for i8

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: i8 = radix.into();

assert_eq!(num, 124i8);

impl From<&StringRadix> for isize

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: isize = radix.into();

assert_eq!(num, 124isize);

impl From<&StringRadix> for u16

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: u16 = radix.into();

assert_eq!(num, 124u16);

impl From<&StringRadix> for u32

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: u32 = radix.into();

assert_eq!(num, 124u32);

impl From<&StringRadix> for u64

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: u64 = radix.into();

assert_eq!(num, 124u64);

impl From<&StringRadix> for u8

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: u8 = radix.into();

assert_eq!(num, 124u8);

impl From<&StringRadix> for usize

fn from(radix: &StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124usize);

impl From<StringRadix> for i16

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<StringRadix> for i32

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<StringRadix> for i64

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<StringRadix> for i8

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<StringRadix> for isize

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<StringRadix> for u16

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<StringRadix> for u32

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<StringRadix> for u64

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<StringRadix> for u8

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<StringRadix> for usize

fn from(radix: StringRadix) -> Self

Converts a StringRadix into primitive int.

Example

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from_radix("444", 5).unwrap();
let num: usize = radix.into();

assert_eq!(num, 124);

impl From<i16> for StringRadix

fn from(number: i16) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123i16);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl From<i32> for StringRadix

fn from(number: i32) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123i32);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl From<i64> for StringRadix

fn from(number: i64) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123i64);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl From<i8> for StringRadix

fn from(number: i8) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123i8);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl From<isize> for StringRadix

fn from(number: isize) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123isize);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl From<u16> for StringRadix

fn from(number: u16) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123u16);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl From<u32> for StringRadix

fn from(number: u32) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123u32);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl From<u64> for StringRadix

fn from(number: u64) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123u64);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl From<u8> for StringRadix

fn from(number: u8) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123u8);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl From<usize> for StringRadix

fn from(number: usize) -> Self

Creates a new StringRadix with base 10 and given integer number.

Examples

use ognlib::num::radix::StringRadix;

let radix = StringRadix::from(123usize);
assert_eq!(radix.number(), "123");
assert_eq!(radix.base(), 10);

impl FromStr for StringRadix

fn from_str(number: &str) -> Result<Self, Self::Err>

Creates a new StringRadix with base 10 and given str number.

Errors

Returns ParseIntError if number contains invalid digit.

Examples

use {core::str::FromStr, ognlib::num::radix::StringRadix};

let n = StringRadix::from_str("123").unwrap();
assert_eq!(n.radix(), ("123", 10));

let e = StringRadix::from_str("12A").unwrap_err();
assert_eq!(e.to_string(), "invalid digit found in string");

type Err = ParseIntError

The associated error which can be returned from parsing.

impl Mul<usize> for StringRadix

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

Performs a * operation (usize as rhs).

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n = Radix::from_radix(123, 4).unwrap();
let n_str = StringRadix::from_radix("123", 4).unwrap();

let res = (n * 124).to_radix(8).unwrap();
let res_str = (n_str * 124).to_radix(8).unwrap();

assert_eq!(res.radix(), (6424, 8));
assert_eq!(res_str.radix(), ("6424", 8));

type Output = StringRadix

The resulting type after applying the * operator.

impl Mul for StringRadix

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

Performs a * operation.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = Radix::from_radix(123, 4).unwrap();
let n2 = Radix::from_radix(444, 5).unwrap();
let n_str1 = StringRadix::from_radix("123", 4).unwrap();
let n_str2 = StringRadix::from_radix("444", 5).unwrap();

let res = (n1 * n2).to_radix(8).unwrap();
let res_str = (n_str1 * n_str2).to_radix(8).unwrap();

assert_eq!(res.radix(), (6424, 8));
assert_eq!(res_str.radix(), ("6424", 8));

type Output = StringRadix

The resulting type after applying the * operator.

impl MulAssign<usize> for StringRadix

fn mul_assign(&mut self, other: usize)

Performs a *= operation (usize as rhs).

Examples

use ognlib::num::radix::{Radix, StringRadix};

let mut n = Radix::from_radix(123, 4).unwrap();
let mut n_str = StringRadix::from_radix("123", 4).unwrap();

n *= 124;
n_str *= 124;

n = n.to_radix(8).unwrap();
n_str = n_str.to_radix(8).unwrap();

assert_eq!(n.radix(), (6424, 8));
assert_eq!(n_str.radix(), ("6424", 8));

impl MulAssign for StringRadix

fn mul_assign(&mut self, other: Self)

Performs a *= operation.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let mut n1 = Radix::from_radix(123, 4).unwrap();
let n2 = Radix::from_radix(444, 5).unwrap();
let mut n_str1 = StringRadix::from_radix("123", 4).unwrap();
let n_str2 = StringRadix::from_radix("444", 5).unwrap();

n1 *= n2;
n_str1 *= n_str2;

n1 = n1.to_radix(8).unwrap();
n_str1 = n_str1.to_radix(8).unwrap();

assert_eq!(n1.radix(), (6424, 8));
assert_eq!(n_str1.radix(), ("6424", 8));

impl Ord for StringRadix

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl PartialEq for StringRadix

fn eq(&self, other: &StringRadix) -> bool

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for StringRadix

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests less than (for self and other) and is used by the < operator.

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

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

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

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

impl Rem<usize> for StringRadix

fn rem(self, other: usize) -> Self::Output

Performs a % operation (usize as rhs).

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n = Radix::from_radix(444, 5).unwrap();
let n_str = StringRadix::from_radix("444", 5).unwrap();

let res = (n % 27).to_radix(8).unwrap();
let res_str = (n_str % 27).to_radix(8).unwrap();

assert_eq!(res.radix(), (20, 8));
assert_eq!(res_str.radix(), ("20", 8));

type Output = StringRadix

The resulting type after applying the % operator.

impl Rem for StringRadix

fn rem(self, other: Self) -> Self::Output

Performs a % operation.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = Radix::from_radix(123, 4).unwrap();
let n2 = Radix::from_radix(444, 5).unwrap();
let n_str1 = StringRadix::from_radix("123", 4).unwrap();
let n_str2 = StringRadix::from_radix("444", 5).unwrap();

let res = (n2 % n1).to_radix(8).unwrap();
let res_str = (n_str2 % n_str1).to_radix(8).unwrap();

assert_eq!(res.radix(), (20, 8));
assert_eq!(res_str.radix(), ("20", 8));

type Output = StringRadix

The resulting type after applying the % operator.

impl RemAssign<usize> for StringRadix

fn rem_assign(&mut self, other: usize)

Performs a %= operation (usize as rhs).

Examples

use ognlib::num::radix::{Radix, StringRadix};

let mut n = Radix::from_radix(444, 5).unwrap();
let mut n_str = StringRadix::from_radix("444", 5).unwrap();

n %= 27;
n_str %= 27;

n = n.to_radix(8).unwrap();
n_str = n_str.to_radix(8).unwrap();

assert_eq!(n.radix(), (20, 8));
assert_eq!(n_str.radix(), ("20", 8));

impl RemAssign for StringRadix

fn rem_assign(&mut self, other: Self)

Performs a %= operation.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = Radix::from_radix(123, 4).unwrap();
let mut n2 = Radix::from_radix(444, 5).unwrap();
let n_str1 = StringRadix::from_radix("123", 4).unwrap();
let mut n_str2 = StringRadix::from_radix("444", 5).unwrap();

n2 %= n1;
n_str2 %= n_str1;

n2 = n2.to_radix(8).unwrap();
n_str2 = n_str2.to_radix(8).unwrap();

assert_eq!(n2.radix(), (20, 8));
assert_eq!(n_str2.radix(), ("20", 8));

impl Sub<usize> for StringRadix

fn sub(self, other: usize) -> Self::Output

Performs a - operation (usize is rhs). Result of operation is an absolute value. Base of resulting number is the base of greater number.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n = Radix::from_radix(123, 4).unwrap();
let n_str = StringRadix::from_radix("123", 4).unwrap();

let res = (n - 124).to_radix(8).unwrap();
let res_str = (n_str - 124).to_radix(8).unwrap();

assert_eq!(res.radix(), (141, 8));
assert_eq!(res_str.radix(), ("141", 8));

type Output = StringRadix

The resulting type after applying the - operator.

impl Sub for StringRadix

fn sub(self, other: Self) -> Self::Output

Performs a - operation. Result of the operation is an absolute value. Base of the resulting number is the base of the greater number.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let n1 = Radix::from_radix(123, 4).unwrap();
let n2 = Radix::from_radix(444, 5).unwrap();
let n_str1 = StringRadix::from_radix("123", 4).unwrap();
let n_str2 = StringRadix::from_radix("444", 5).unwrap();

let res = (n1 - n2).to_radix(8).unwrap();
let res_str = (n_str1 - n_str2).to_radix(8).unwrap();

assert_eq!(res.radix(), (141, 8));
assert_eq!(res_str.radix(), ("141", 8));

type Output = StringRadix

The resulting type after applying the - operator.

impl SubAssign<usize> for StringRadix

fn sub_assign(&mut self, other: usize)

Performs a -= operation (usize as rhs).

The same rules as for common sub are applied.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let mut n = Radix::from_radix(123, 4).unwrap();
let mut n_str = StringRadix::from_radix("123", 4).unwrap();

n -= 124;
n_str -= 124;

n = n.to_radix(8).unwrap();
n_str = n_str.to_radix(8).unwrap();

assert_eq!(n.radix(), (141, 8));
assert_eq!(n_str.radix(), ("141", 8));

impl SubAssign for StringRadix

fn sub_assign(&mut self, other: Self)

Performs a -= operation. The same rules as for common sub are applied.

Examples

use ognlib::num::radix::{Radix, StringRadix};

let mut n1 = Radix::from_radix(123, 4).unwrap();
let n2 = Radix::from_radix(444, 5).unwrap();
let mut n_str1 = StringRadix::from_radix("123", 4).unwrap();
let n_str2 = StringRadix::from_radix("444", 5).unwrap();

n1 -= n2;
n_str1 -= n_str2;

n1 = n1.to_radix(8).unwrap();
n_str1 = n_str1.to_radix(8).unwrap();

assert_eq!(n1.radix(), (141, 8));
assert_eq!(n_str1.radix(), ("141", 8));

impl Eq for StringRadix

impl StructuralPartialEq for StringRadix