Struct Radix

pub struct Radix { /* private fields */ }

Radix number, that is usually written as number_base (444₈ for example). Base can be only in range 2..=10.

Implementations

impl Radix

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

Creates a new Radix.

Errors

Returns a BaseError when base isn’t correct.

Examples

use ognlib::num::radix::Radix;

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

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

let e2 = Radix::new(33).unwrap_err();
assert_eq!(e2.to_string(), "Expected base in range `2..=10`, found 33");

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

Creates a new Radix with given number and base.

Panics

Panics if a char from RADIX is somehow not parsed

Errors

Returns a BaseError if base isn’t correct; NumberError if number isn’t correct.

Examples

use ognlib::num::radix::Radix;

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

let e = Radix::from_radix(444, 3).unwrap_err();
assert_eq!(e.to_string(), "Number contains a digit (4) that is more or equal than base (3)",);

pub const fn number(&self) -> usize

Returns a number of Radix.

Example

use ognlib::num::radix::Radix;

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

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

pub const fn base(&self) -> u8

Returns a base of Radix.

Example

use ognlib::num::radix::Radix;

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

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

pub const fn radix(&self) -> (usize, u8)

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

Example

use ognlib::num::radix::Radix;

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

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

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

Translate Radix 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;

let n1 = Radix::from(123);
let new1 = n1.to_radix(8).unwrap();

let n2 = Radix::from_radix(173, 8).unwrap();
let new2 = n2.to_radix(10).unwrap();

assert_eq!(new1.radix(), (173, 8));
assert_eq!(new2.radix(), (123, 10));

let e = new2.to_radix(1).unwrap_err();
assert_eq!(e.to_string(), "Expected base in range `2..=10`, found 1");

pub fn to_str_radix(self, base: u8) -> Result<StringRadix, RadixError>

Translate Radix 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::{Radix, StringRadix};

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

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

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

Sum 2 Radix to new StringRadix.

Errors

Same as to_str_radix.

Examples

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

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

let res = Radix::add_to_str(n1, n2, 16).unwrap();
assert_eq!(res.radix(), ("97", 16));

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

Sub 2 Radix to new StringRadix.

Errors

Same as to_str_radix.

Examples

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

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

let res = Radix::sub_to_str(n2, n1, 16).unwrap();
assert_eq!(res.radix(), ("61", 16));

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

Mul 2 Radix to new StringRadix.

Errors

Same as to_str_radix.

Examples

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

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

let res = Radix::mul_to_str(n1, n2, 16).unwrap();
assert_eq!(res.radix(), ("D14", 16));

Trait Implementations

impl Add<usize> for Radix

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 = Radix

The resulting type after applying the + operator.

impl Add for Radix

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 = Radix

The resulting type after applying the + operator.

impl AddAssign<usize> for Radix

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 Radix

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 Radix

fn clone(&self) -> Radix

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Radix

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

Formats the value using the given formatter.

impl Div<usize> for Radix

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 = Radix

The resulting type after applying the / operator.

impl Div for Radix

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 = Radix

The resulting type after applying the / operator.

impl DivAssign<usize> for Radix

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 Radix

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<&Radix> for i16

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124i16);

impl From<&Radix> for i32

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124i32);

impl From<&Radix> for i64

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124i64);

impl From<&Radix> for i8

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124i8);

impl From<&Radix> for isize

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124isize);

impl From<&Radix> for u16

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124u16);

impl From<&Radix> for u32

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124u32);

impl From<&Radix> for u64

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124u64);

impl From<&Radix> for u8

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124u8);

impl From<&Radix> for usize

fn from(radix: &Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124usize);

impl From<Radix> for i16

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124i16);

impl From<Radix> for i32

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124i32);

impl From<Radix> for i64

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124i64);

impl From<Radix> for i8

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124i8);

impl From<Radix> for isize

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124isize);

impl From<Radix> for u16

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124u16);

impl From<Radix> for u32

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124u32);

impl From<Radix> for u64

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124u64);

impl From<Radix> for u8

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124u8);

impl From<Radix> for usize

fn from(radix: Radix) -> Self

Converts a Radix into primitive int.

Example

use ognlib::num::radix::Radix;

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

assert_eq!(num, 124usize);

impl From<i16> for Radix

fn from(number: i16) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl From<i32> for Radix

fn from(number: i32) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl From<i64> for Radix

fn from(number: i64) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl From<i8> for Radix

fn from(number: i8) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl From<isize> for Radix

fn from(number: isize) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl From<u16> for Radix

fn from(number: u16) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl From<u32> for Radix

fn from(number: u32) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl From<u64> for Radix

fn from(number: u64) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl From<u8> for Radix

fn from(number: u8) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl From<usize> for Radix

fn from(number: usize) -> Self

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

Examples

use ognlib::num::radix::Radix;

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

impl FromStr for Radix

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

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

Errors

Returns ParseIntError if number contains invalid digits.

Examples

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

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

let e = Radix::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 Radix

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 = Radix

The resulting type after applying the * operator.

impl Mul for Radix

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 = Radix

The resulting type after applying the * operator.

impl MulAssign<usize> for Radix

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 Radix

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 Radix

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 Radix

fn eq(&self, other: &Radix) -> 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 Radix

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 Radix

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 = Radix

The resulting type after applying the % operator.

impl Rem for Radix

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 = Radix

The resulting type after applying the % operator.

impl RemAssign<usize> for Radix

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 Radix

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 Radix

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 = Radix

The resulting type after applying the - operator.

impl Sub for Radix

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 = Radix

The resulting type after applying the - operator.

impl SubAssign<usize> for Radix

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 Radix

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 Copy for Radix

impl Eq for Radix

impl StructuralPartialEq for Radix