num_convert

Rust library for converting integers.

Description

This library provide a way to convert from one type to another type. Supports generics types.

Generic traits for conversions between integer types.

• The FromByAdd trait for converting from negative integers to positive or vice versa.
• The IntoByAdd trait for converting into negative integers to positive or vice versa.
• The TryFromByAdd trait for converting from negative integers to positive or vice versa, that can fail.
• The TryIntoByAdd trait for converting into negative integers to positive or vice versa, that can fail.
• The FromAs generic trait for conversion from integers with possible overflow.
• The IntoAs generic trait for conversion into integers with possible overflow.
• The TryFromDigits trait for converting from digits as a number, with possible value types.
• The TryFromIntStr trait for converting from str or integer to type integer.
• The FromTuple trait for convert a tuple of different types to an array of integers.
• The TryFromTuple trait for convert a tuple of different types to an array of integers, possible conversion error.

Other traits for integers.

• A trait IntegerLen to determine the number of digits of integers.
• The Sbits trait for define the size of integer value in bits.
• The Tbits trait for define the size of integer type in bits.
• The ToZero trait for implementing the null value of types.
• The ToMin trait for implement lower bounds on types.
• The ToMax trait for implement upper bounds on types.

Usage

Add this to your Cargo.toml

rust,ignore [dependencies] num_convert = { git = "https://github.com/pic16f877ccs/num_convert", version = "0.6.0" }

Or using cargo

```rust,ignore cargo add numconvert --git "https://github.com/pic16f877ccs/numconvert"

```

Examples

Convert from negative into positive and positive into negative. ``` use num_convert::FromByAdd;

asserteq!(::frombyadd(-28i8), 100u8); asserteq!(::frombyadd(10u8), -118i8); ```

Convert into between integer types. ``` use num_convert::IntoByAdd;

fn integertointeger, T2: IntoByAdd, U1, U2>(min: T1, max: T2) -> (U1, U2) { (min.intobyadd(), max.intobyadd()) } asserteq!(integertointeger(i16::MIN, u16::MAX), (u16::MIN, i16::MAX)); asserteq!(integertointeger(u16::MIN, u16::MAX), (i16::MIN, i16::MAX)); ```

Convert from negative into positive without error and with error. ``` use num_convert::TryFromByAdd;

asserteq!(::tryfrombyadd(-128i16), Some(0u8)); asserteq!(::tryfrombyadd(-129i16), None); ```

Convert between 128 bit types lossless. ``` use num_convert::TryIntoByAdd;

asserteq!(>::tryintobyadd(i128::MIN), Some(u128::MIN)); asserteq!(>::tryintobyadd(u128::MIN), Some(i128::MIN)); ```

Conversions type U16 in U8 without overflow and with overflow. ``` use num_convert::{IntoAs, FromAs};

asserteq!(>::intoas(255u16), 255u8); asserteq!(>::intoas(258u16), 2u8); asserteq!(::fromas(261u16), 5u8); ```

Converting from digits as a number. ``` use num_convert::TryFromDigits;

let arr: [u32; 6] = [25635071, 25634091, 25633334, 25636309, 25637101, 25636243]; let val: Vec = arr.iter().map(|var| u8::fromdigits(*var).unwrapor(255u8) ).collect::<_>(); assert_eq!(val, [71, 91, 255, 255, 101, 243]); ```

The size of integer values in bits. ``` use num_convert::Sbits;

asserteq!((-128i8).sbits(), 8u32); asserteq!(u64::MAX.sbits(), 64u32); ```

The size of integer type in bits. ``` use num_convert::Tbits;

asserteq!(i8::tbits(), 8u32); asserteq!(u64::tbits(), 64u32); ```

Determining the number of digits of integers. ``` use num_convert::IntegerLen;

asserteq!(0i8.len(), 1usize); asserteq!(i8::MAX.len(), 3usize); asserteq!(i128::MAX.len(), 39usize); asserteq!(u128::MAX.len(), 39usize); Converting from tuple to array of integers. use num_convert::FromTuple;

asserteq!(::from5((true, false, 45u8, 2023u16, -60i8,)), [1i32, 0i32, 45i32, 2023i32, -60i32]); asserteq!(::from3((45u8, 2023u16, -53i8,)).iter().sum::(), 2015i32); Conversion from str or integer to type integer. use num_convert::TryFromIntStr;

asserteq!(>::tryfromintstr("2023"), Ok(2023u16)); assert!(>::tryfromintstr("20-2-2023").iserr()); asserteq!(>::tryfromintstr(22023), Ok(22023)); assert!(>::tryfromintstr(222022).iserr()); asserteq!(>::tryfromintstr(true), Ok(1i32)); asserteq!(>::tryfromintstr(false), Ok(0i32)); Converting tuple to array of integers. use num_convert::TryTupToArr;

asserteq!(TryTupToArr::::tryinto_arr((45u8, 2023u16, -60i8,)), Ok([45i32, 2023i32, -60i32]));

let arr: [i16; 3] = ("45", 2023u16, true,).tryintoarr().unwrap(); assert_eq!(arr, [45i16, 2023i16, 1i16]); ```

License

GNU General Public License v3.0