Struct Octal

pub struct Octal;

This type represents an octal base. It contains more efficient overrides of the Base functions to improve performance.

Trait Implementations

impl Base for Octal

const NUMBER: u16 = 8u16

This contains the numeric value of the type. E.g. for binary 2, for decimal 10, etc.

fn new() -> Self

Function that can create an instance of this Base. Users should never have to manually create instances of this type. This is called implicitly on every call to BigNumBase<Self>::new() so it should be as lightweight as possible. Note that it is not called when creating a BigNumBase from another, like when performing an addition. In this case the base is simply copied over.

fn exp_range(&self) -> ExpRange

Function that fetches the non-inclusive range of the exponent for the significand in the BigNum with this base. E.g. the range for binary is [63, 64), since the range of the significand is [2^63, 2^64)

fn sig_range(&self) -> SigRange

Function that fetches the inclusive range for the significand in the BigNum with this base. E.g. for binary the range of the significand is [2^63, 2^64 - 1]

fn pow(exp: u32) -> u64

This is a function that computes Self::NUMBER ^ exp. It has a default implementation that computes the value directly. It is recommended to override this behavior if there is a trick to the exponentiation (like how for binary 2^n = (1 << n)). You can also create a gloabl const lookup table and reference that.

fn pow_u128(exp: u32) -> u128

This is a function that computes the same value as pow but in a u128 value. Mostly useful to help with multiplication/division, and as such it’s probably unnecessary to override it unless multiplication/division performance is critical

fn rshift(lhs: u64, exp: u32) -> u64

This is a function that computes lhs / (Self::NUMBER ^ exp). There is a default implementation that obtains the value of Self::NUMBER ^ exp via the pow method for this type, and does a multiplication. It is recommended to override this method if there is a trick for the division (like how in binary, lhs / (2 ^ exp) = lhs << exp, or in octal lhs / (8 ^ exp) = lhs << (3 * exp)

fn rshift_u128(lhs: u128, exp: u32) -> u128

This is a function that computes the same thing as rshift but in a u128 value. Mostly useful to help with multiplication/division, and as such it’s probably unnecessary to override it unless multiplication/division performance is critical

fn lshift(lhs: u64, exp: u32) -> u64

This is a function that computes lhs * (Self::NUMBER ^ exp). There is a default implementation that obtains the value of Self::NUMBER ^ exp via the pow method for this type, and does a division. It is recommended to override this method if there is a trick for the division (like how in binary, lhs * (2 ^ exp) = lhs >> exp, or in octal lhs * (8 ^ exp) = lhs >> (3 * exp)

fn lshift_u128(lhs: u128, exp: u32) -> u128

This is a function that computes the same thing as lshift but in a u128 value. Mostly useful to help with multiplication/division, and as such it’s probably unnecessary to override it unless multiplication/division performance is critical

fn calculate_ranges() -> (ExpRange, SigRange)

This function calculates the ranges for the exponent and the significand. It is not particularly efficient so if performance is a concern you should not use it. It mainly exists to facilitate the create_default_base! macro. It is recommended to store the ranges in a const and return them directly in the exp_range and sig_range methods if convenient.

fn get_mag(sig: u64) -> u32

This is a function that computes the highest power x such that sig >= (Self::NUMBER ^ x). There is a default implementation that uses ilog, and it is recommended to use this unless there is a special way to find the magnitude (e.g. binary and decimal have specialized ilog implementations). As a special case, bases that are powers of 2 or 10 can use log arithmetic to convert. I tried this with octal and hexadecimal but it had no noticeable impact.

fn get_mag_u128(sig: u128) -> u32

This is a function that computes the same thing as get_mag but in a u128 value. Mostly useful to help with multiplication/division, and as such it’s probably unnecessary to override it unless multiplication/division performance is critical

fn as_number(&self) -> u16

This method just fetches Self::NUMBER but is provided as an instance method for convenience. Overriding it is undefined behavior

impl Clone for Octal

fn clone(&self) -> Octal

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Octal

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

Formats the value using the given formatter.

impl Copy for Octal