144 lines
4.6 KiB
Rust
144 lines
4.6 KiB
Rust
use bnum::BInt;
|
|
use typenum::Unsigned;
|
|
use std::marker::PhantomData;
|
|
|
|
#[derive(Clone,Copy,Debug,Hash)]
|
|
pub struct Fixed<const CHUNKS:usize,Frac>{
|
|
pub(crate)bits:BInt<{CHUNKS}>,
|
|
pub(crate)frac:PhantomData<Frac>,
|
|
}
|
|
|
|
impl<const CHUNKS:usize,Frac:Unsigned> Fixed<CHUNKS,Frac>{
|
|
pub const ZERO:Self=Self{bits:BInt::<CHUNKS>::ZERO,frac:PhantomData};
|
|
pub const ONE:Self=Self{bits:BInt::<CHUNKS>::ONE.shl(Frac::U32),frac:PhantomData};
|
|
pub const NEG_ONE:Self=Self{bits:BInt::<CHUNKS>::NEG_ONE.shl(Frac::U32),frac:PhantomData};
|
|
}
|
|
|
|
impl<const CHUNKS:usize,FracDst:Unsigned,T> From<T> for Fixed<CHUNKS,FracDst>
|
|
where
|
|
BInt<CHUNKS>:From<T>
|
|
{
|
|
fn from(value:T)->Self{
|
|
Self{
|
|
bits:BInt::<{CHUNKS}>::from(value)<<FracDst::U32,
|
|
frac:PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<const CHUNKS:usize,Frac> PartialEq for Fixed<CHUNKS,Frac>{
|
|
fn eq(&self,other:&Self)->bool{
|
|
self.bits.eq(&other.bits)
|
|
}
|
|
}
|
|
impl<const CHUNKS:usize,Frac> Eq for Fixed<CHUNKS,Frac>{}
|
|
|
|
impl<const CHUNKS:usize,Frac> PartialOrd for Fixed<CHUNKS,Frac>{
|
|
fn partial_cmp(&self,other:&Self)->Option<std::cmp::Ordering>{
|
|
self.bits.partial_cmp(&other.bits)
|
|
}
|
|
}
|
|
impl<const CHUNKS:usize,Frac> Ord for Fixed<CHUNKS,Frac>{
|
|
fn cmp(&self,other:&Self)->std::cmp::Ordering{
|
|
self.bits.cmp(&other.bits)
|
|
}
|
|
}
|
|
|
|
impl<const CHUNKS:usize,Frac> std::ops::Neg for Fixed<CHUNKS,Frac>{
|
|
type Output=Self;
|
|
fn neg(self)->Self{
|
|
Self{
|
|
bits:self.bits.neg(),
|
|
frac:PhantomData,
|
|
}
|
|
}
|
|
}
|
|
|
|
macro_rules! impl_operator {
|
|
( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
|
|
impl<const CHUNKS:usize,Frac> core::ops::$trait for $struct<CHUNKS,Frac>{
|
|
type Output = $output;
|
|
|
|
fn $method(self, other: Self) -> Self::Output {
|
|
Self {
|
|
bits:self.bits.$method(other.bits),
|
|
frac:PhantomData,
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
macro_rules! impl_assign_operator {
|
|
( $struct: ident, $trait: ident, $method: ident ) => {
|
|
impl<const CHUNKS:usize,Frac> core::ops::$trait for $struct<CHUNKS,Frac>{
|
|
fn $method(&mut self, other: Self) {
|
|
self.bits.$method(other.bits);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
// Impl arithmetic pperators
|
|
impl_assign_operator!( Fixed, AddAssign, add_assign );
|
|
impl_operator!( Fixed, Add, add, Self );
|
|
impl_assign_operator!( Fixed, SubAssign, sub_assign );
|
|
impl_operator!( Fixed, Sub, sub, Self );
|
|
impl_assign_operator!( Fixed, MulAssign, mul_assign );
|
|
impl_operator!( Fixed, Mul, mul, Self );
|
|
impl_assign_operator!( Fixed, DivAssign, div_assign );
|
|
impl_operator!( Fixed, Div, div, Self );
|
|
impl_assign_operator!( Fixed, RemAssign, rem_assign );
|
|
impl_operator!( Fixed, Rem, rem, Self );
|
|
|
|
// Impl bitwise operators
|
|
impl_assign_operator!( Fixed, BitAndAssign, bitand_assign );
|
|
impl_operator!( Fixed, BitAnd, bitand, Self );
|
|
impl_assign_operator!( Fixed, BitOrAssign, bitor_assign );
|
|
impl_operator!( Fixed, BitOr, bitor, Self );
|
|
impl_assign_operator!( Fixed, BitXorAssign, bitxor_assign );
|
|
impl_operator!( Fixed, BitXor, bitxor, Self );
|
|
|
|
macro_rules! impl_shift_operator {
|
|
( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
|
|
impl<const CHUNKS:usize,Frac> core::ops::$trait<u32> for $struct<CHUNKS,Frac>{
|
|
type Output = $output;
|
|
|
|
fn $method(self, other: u32) -> Self::Output {
|
|
Self {
|
|
bits:self.bits.$method(other),
|
|
frac:PhantomData,
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
macro_rules! impl_shift_assign_operator {
|
|
( $struct: ident, $trait: ident, $method: ident ) => {
|
|
impl<const CHUNKS:usize,Frac> core::ops::$trait<u32> for $struct<CHUNKS,Frac>{
|
|
fn $method(&mut self, other: u32) {
|
|
self.bits.$method(other);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
impl_shift_assign_operator!( Fixed, ShlAssign, shl_assign );
|
|
impl_shift_operator!( Fixed, Shl, shl, Self );
|
|
impl_shift_assign_operator!( Fixed, ShrAssign, shr_assign );
|
|
impl_shift_operator!( Fixed, Shr, shr, Self );
|
|
|
|
macro_rules! impl_sqrt {
|
|
( $struct: ident, $chunks: expr) => {
|
|
impl<Frac:Unsigned> $struct<$chunks,Frac>{
|
|
pub fn sqrt(self)->$struct<{$chunks/2+1},typenum::PartialDiv<Frac,typenum::U2>>{
|
|
$struct{
|
|
bits:self.bits.sqrt(),
|
|
frac:PhantomData,
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
|
|
impl_sqrt!(Fixed,1);impl_sqrt!(Fixed,2);impl_sqrt!(Fixed,3);impl_sqrt!(Fixed,4);impl_sqrt!(Fixed,5);impl_sqrt!(Fixed,6);impl_sqrt!(Fixed,7);impl_sqrt!(Fixed,8);
|
|
impl_sqrt!(Fixed,9);impl_sqrt!(Fixed,10);impl_sqrt!(Fixed,11);impl_sqrt!(Fixed,12);impl_sqrt!(Fixed,13);impl_sqrt!(Fixed,14);impl_sqrt!(Fixed,15);impl_sqrt!(Fixed,16);
|