Enum number_theory::NTResult

#[non_exhaustive]
pub enum NTResult<T: Sized + Clone> {
    Eval(T),
    Overflow,
    DNE,
    Infinite,
    InfiniteSet,
    CompExceeded,
    CompOverflow,
    Undefined,
}

Enum returned in checked functions returning any errors of evaluation

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Eval(T)

Evaluation is knowable and was calculated in the bounds. FFI return 0

Overflow

Solution Exists but does not fit in datatype. FFI return 1

DNE

Solution Does Not Exist. FFI return 2

Infinite

Solution Exists but is Infinitely large. FFI return 3

InfiniteSet

Solutions exist but there are infinite number of them (all elements of Z). FFI return 4

CompExceeded

Computation exceeds some practical bound. FFI return 5

CompOverflow

Overflowed during computation result does not necessarily exceed the datatype. FFI return 6

Undefined

Function is not defined for the inputs. FFI return 7

Implementations

impl<T: Sized + Clone + Default> NTResult<T>

pub fn unwrap(&self) -> T

Returns the Evaluated number

pub fn expect(&self, signal: &str) -> T

Returns the result or panics with the selected message

pub fn unwrap_or(&self, res: T) -> T

Returns the result or the selected default

pub fn is_infinite(&self) -> bool

Checks if the result is infinitely large

pub fn is_infiniteset(&self) -> bool

Checks if the result is an infinite set

pub fn is_dne(&self) -> bool

Checks if the solution to the function exists

pub fn is_overflow(&self) -> bool

Checks if the result exceeds the datatype max

pub fn is_comp_overflow(&self) -> bool

Checks if there was an overflow during computation

pub fn is_comp_exceeded(&self) -> bool

Checks if the Computation exceeded

pub fn is_undefined(&self) -> bool

Checks if the result is undefined

pub fn from_option(opt: Option<T>, ntvariant: Self) -> Self

Converts from Option to NTResult. None values are converted to the selected NTResult variant

 use number_theory::NumberTheory;
 use number_theory::NTResult; 
  
 // A None is returned here due to exceeding the i8::MAX
 let res = 255u8.checked_add(1);
 // The None option is converted to an NTResult::Overflow
   
 let convert = NTResult::from_option(res,NTResult::Overflow);
 
 assert_eq!(convert, NTResult::Overflow);
  
 // An Some result is converted to Eval 
  
   let res = 254u8.checked_add(1);
   let convert = NTResult::from_option(res,NTResult::Overflow);
    
     assert_eq!(convert, NTResult::Eval(255));

pub fn map<U: Clone, F: FnOnce(T) -> U>(&self, func: F) -> NTResult<U>

Maps within the Enum

pub fn ffi(&self) -> (T, u8)

Return value and flag for FFI bindings

use number_theory::NumberTheory;
  // Attempt to factor 0
  let res = 0.checked_factor();
  // Fails and returns a NTResult that can be decomposed to an empty vec  
  // and 4 for C api binding
  assert_eq!(res.ffi(),(vec![],4)); 
   
  let res = 1.checked_factor(); 
  // Likewise an DNE NTResult gets converted to a vec and 2
  assert_eq!(res.ffi(), (vec![],2)); 
   
  let res = 9.checked_factor();
  // Finally a fully factorable integer gets a vector and the 0 flag
  assert_eq!(res.ffi(),(vec![3,2],0))

Trait Implementations

impl<T: Clone + Sized + Clone> Clone for NTResult<T>

fn clone(&self) -> NTResult<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Sized + Clone> Debug for NTResult<T>

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

Formats the value using the given formatter.

impl<T: Clone + Default + Sized + Display> Display for NTResult<T>

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

Formats the value using the given formatter.

impl<T: PartialEq + Sized + Clone> PartialEq for NTResult<T>

fn eq(&self, other: &NTResult<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T: Eq + Sized + Clone> Eq for NTResult<T>

impl<T: Sized + Clone> StructuralEq for NTResult<T>

impl<T: Sized + Clone> StructuralPartialEq for NTResult<T>