Struct agb_fixnum::Num

source ·

pub struct Num<I: FixedWidthUnsignedInteger, const N: usize>(/* private fields */);

Expand description

A fixed point number represented using I with N bits of fractional precision

Implementations§

source §

impl<I: FixedWidthUnsignedInteger, const N: usize> Num<I, N>

source

pub fn change_base<J: FixedWidthUnsignedInteger + From, const M: usize>( self ) -> Num<J, M>

Performs the conversion between two integer types and between two different fractional precisions

source

pub fn try_change_base<J: FixedWidthUnsignedInteger + TryFrom, const M: usize>( self ) -> Option<Num<J, M>>

Attempts to perform the conversion between two integer types and between two different fractional precisions

let a: Num<i32, 8> = 1.into();
let b: Option<Num<u8, 4>> = a.try_change_base();
assert_eq!(b, Some(1.into()));

let a: Num<i32, 8> = 18.into();
let b: Option<Num<u8, 4>> = a.try_change_base();
assert_eq!(b, None);

source

pub const fn from_raw(n: I) -> Self

A bit for bit conversion from a number to a fixed num

source

pub fn to_raw(self) -> I

The internal representation of the fixed point number

source

pub fn from_f32(input: f32) -> Self

Lossily transforms an f32 into a fixed point representation. This is not const because you cannot currently do floating point operations in const contexts, so you should use the num! macro from agb-macros if you want a const from_f32/f64

source

pub fn from_f64(input: f64) -> Self

Lossily transforms an f64 into a fixed point representation. This is not const because you cannot currently do floating point operations in const contexts, so you should use the num! macro from agb-macros if you want a const from_f32/f64

source

pub fn trunc(self) -> I

Truncates the fixed point number returning the integral part

let n: Num<i32, 8> = num!(5.67);
assert_eq!(n.trunc(), 5);
let n: Num<i32, 8> = num!(-5.67);
assert_eq!(n.trunc(), -5);

source

pub fn rem_euclid(self, rhs: Self) -> Self

Performs the equivalent to the integer rem_euclid, which is modulo numbering.

let n: Num<i32, 8> = num!(5.67);
let r: Num<i32, 8> = num!(4.);
assert_eq!(n.rem_euclid(r), num!(1.67));

let n: Num<i32, 8> = num!(-1.5);
let r: Num<i32, 8> = num!(4.);
assert_eq!(n.rem_euclid(r), num!(2.5));

source

pub fn floor(self) -> I

Performs rounding towards negative infinity

let n: Num<i32, 8> = num!(5.67);
assert_eq!(n.floor(), 5);
let n: Num<i32, 8> = num!(-5.67);
assert_eq!(n.floor(), -6);

source

pub fn frac(self) -> I

Returns the fractional component of a number as it’s integer representation

let n: Num<i32, 8> = num!(5.5);
assert_eq!(n.frac(), 1 << 7);

source

pub fn new(integral: I) -> Self

Creates an integer represented by a fixed point number

let n: Num<i32, 8> = Num::new(5);
assert_eq!(n.frac(), 0); // no fractional component
assert_eq!(n, num!(5.)); // just equals the number 5

source §

impl<const N: usize> Num<i32, N>

source

pub fn sqrt(self) -> Self

Returns the square root of a number, it is calculated a digit at a time.

let n: Num<i32, 8> = num!(16.);
assert_eq!(n.sqrt(), num!(4.));
let n: Num<i32, 8> = num!(2.25);
assert_eq!(n.sqrt(), num!(1.5));

source §

impl<I: FixedWidthSignedInteger, const N: usize> Num<I, N>

source

pub fn abs(self) -> Self

Returns the absolute value of a fixed point number

let n: Num<i32, 8> = num!(5.5);
assert_eq!(n.abs(), num!(5.5));
let n: Num<i32, 8> = num!(-5.5);
assert_eq!(n.abs(), num!(5.5));

source

pub fn cos(self) -> Self

Calculates the cosine of a fixed point number with the domain of [0, 1]. Uses a fifth order polynomial.

let n: Num<i32, 8> = num!(0.);   // 0 radians
assert_eq!(n.cos(), num!(1.));
let n: Num<i32, 8> = num!(0.25); // pi / 2 radians
assert_eq!(n.cos(), num!(0.));
let n: Num<i32, 8> = num!(0.5);  // pi radians
assert_eq!(n.cos(), num!(-1.));
let n: Num<i32, 8> = num!(0.75); // 3pi/2 radians
assert_eq!(n.cos(), num!(0.));
let n: Num<i32, 8> = num!(1.);   // 2 pi radians (whole rotation)
assert_eq!(n.cos(), num!(1.));

source

pub fn sin(self) -> Self

Calculates the sine of a number with domain of [0, 1].

let n: Num<i32, 8> = num!(0.);   // 0 radians
assert_eq!(n.sin(), num!(0.));
let n: Num<i32, 8> = num!(0.25); // pi / 2 radians
assert_eq!(n.sin(), num!(1.));
let n: Num<i32, 8> = num!(0.5);  // pi radians
assert_eq!(n.sin(), num!(0.));
let n: Num<i32, 8> = num!(0.75); // 3pi/2 radians
assert_eq!(n.sin(), num!(-1.));
let n: Num<i32, 8> = num!(1.);   // 2 pi radians (whole rotation)
assert_eq!(n.sin(), num!(0.));