Royiex/strafe-client-jed
1
Fork 0
forked from StrafesNET/strafe-project
Code Pull Requests 1 Activity

lol idk #1

Open
Quaternions wants to merge 826 commits from StrafesNET/strafe-project:master into master
pull from: StrafesNET/strafe-project:master
merge into: Royiex:master
Conversation 0 Commits 826 Files Changed 206 +75 -93
7 changed files with 75 additions and 93 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files
Showing only changes of commit e0dba8840e - Show all commits

7
fixed_wide/Cargo.lock generated
View File

@ -21,7 +21,6 @@ dependencies = [
"arrayvec",
"bnum",
"paste",
"typenum",
]
[[package]]
@ -29,9 +28,3 @@ name = "paste"
version = "1.0.15"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"
[[package]]
name = "typenum"
version = "1.17.0"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "42ff0bf0c66b8238c6f3b578df37d0b7848e55df8577b3f74f92a69acceeb825"

1
fixed_wide/Cargo.toml
View File

@ -10,6 +10,5 @@ zeroes=["ratio","dep:arrayvec"]
[dependencies]
bnum = "0.11.0"
typenum = "1.17.0"
arrayvec = { version = "0.7.6", optional = true }
paste = "1.0.15"

118
fixed_wide/src/fixed.rs
View File

@ -1,35 +1,34 @@
use bnum::{BInt,cast::As};
use typenum::{Sum,Unsigned};
#[derive(Clone,Copy,Debug,Hash)]
pub struct Fixed<const CHUNKS:usize,Frac>{
pub(crate)bits:BInt<{CHUNKS}>,
pub(crate)frac:std::marker::PhantomData<Frac>,
/// N is the number of u64s to use
/// F is the number of fractional bits (always N*32 lol)
pub struct Fixed<const N:usize,const F:usize>{
pub(crate)bits:BInt<{N}>,
}
impl<const CHUNKS:usize,Frac:Unsigned> Fixed<CHUNKS,Frac>{
pub const MAX:Self=Self::from_bits(BInt::<CHUNKS>::MAX);
pub const MIN:Self=Self::from_bits(BInt::<CHUNKS>::MIN);
pub const ZERO:Self=Self::from_bits(BInt::<CHUNKS>::ZERO);
pub const EPSILON:Self=Self::from_bits(BInt::<CHUNKS>::ONE);
pub const NEG_EPSILON:Self=Self::from_bits(BInt::<CHUNKS>::NEG_ONE);
pub const ONE:Self=Self::from_bits(BInt::<CHUNKS>::ONE.shl(Frac::U32));
pub const TWO:Self=Self::from_bits(BInt::<CHUNKS>::TWO.shl(Frac::U32));
pub const HALF:Self=Self::from_bits(BInt::<CHUNKS>::ONE.shl(Frac::U32-1));
pub const NEG_ONE:Self=Self::from_bits(BInt::<CHUNKS>::NEG_ONE.shl(Frac::U32));
pub const NEG_TWO:Self=Self::from_bits(BInt::<CHUNKS>::NEG_TWO.shl(Frac::U32));
pub const NEG_HALF:Self=Self::from_bits(BInt::<CHUNKS>::NEG_ONE.shl(Frac::U32-1));
impl<const N:usize,const F:usize> Fixed<N,F>{
pub const MAX:Self=Self::from_bits(BInt::<N>::MAX);
pub const MIN:Self=Self::from_bits(BInt::<N>::MIN);
pub const ZERO:Self=Self::from_bits(BInt::<N>::ZERO);
pub const EPSILON:Self=Self::from_bits(BInt::<N>::ONE);
pub const NEG_EPSILON:Self=Self::from_bits(BInt::<N>::NEG_ONE);
pub const ONE:Self=Self::from_bits(BInt::<N>::ONE.shl(F as u32));
pub const TWO:Self=Self::from_bits(BInt::<N>::TWO.shl(F as u32));
pub const HALF:Self=Self::from_bits(BInt::<N>::ONE.shl(F as u32-1));
pub const NEG_ONE:Self=Self::from_bits(BInt::<N>::NEG_ONE.shl(F as u32));
pub const NEG_TWO:Self=Self::from_bits(BInt::<N>::NEG_TWO.shl(F as u32));
pub const NEG_HALF:Self=Self::from_bits(BInt::<N>::NEG_ONE.shl(F as u32-1));
}
impl<const CHUNKS:usize,Frac> Fixed<CHUNKS,Frac>{
impl<const N:usize,const F:usize> Fixed<N,F>{
#[inline]
pub const fn from_bits(bits:BInt::<CHUNKS>)->Self{
pub const fn from_bits(bits:BInt::<N>)->Self{
Self{
bits,
frac:std::marker::PhantomData,
}
}
#[inline]
pub const fn to_bits(self)->BInt<CHUNKS>{
pub const fn to_bits(self)->BInt<N>{
self.bits
}
#[inline]
@ -38,34 +37,34 @@ impl<const CHUNKS:usize,Frac> Fixed<CHUNKS,Frac>{
}
}
impl<const CHUNKS:usize,Frac:Unsigned,T> From<T> for Fixed<CHUNKS,Frac>
impl<const N:usize,const F:usize,T> From<T> for Fixed<N,F>
where
BInt<CHUNKS>:From<T>
BInt<N>:From<T>
{
fn from(value:T)->Self{
Self::from_bits(BInt::<{CHUNKS}>::from(value)<<Frac::U32)
Self::from_bits(BInt::<{N}>::from(value)<<F as u32)
}
}
impl<const CHUNKS:usize,Frac> PartialEq for Fixed<CHUNKS,Frac>{
impl<const N:usize,const F:usize> PartialEq for Fixed<N,F>{
fn eq(&self,other:&Self)->bool{
self.bits.eq(&other.bits)
}
}
impl<const CHUNKS:usize,Frac> Eq for Fixed<CHUNKS,Frac>{}
impl<const N:usize,const F:usize> Eq for Fixed<N,F>{}
impl<const CHUNKS:usize,Frac> PartialOrd for Fixed<CHUNKS,Frac>{
impl<const N:usize,const F:usize> PartialOrd for Fixed<N,F>{
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>{
impl<const N:usize,const F:usize> Ord for Fixed<N,F>{
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>{
impl<const N:usize,const F:usize> std::ops::Neg for Fixed<N,F>{
type Output=Self;
fn neg(self)->Self{
Self::from_bits(self.bits.neg())
@ -74,38 +73,38 @@ impl<const CHUNKS:usize,Frac> std::ops::Neg for Fixed<CHUNKS,Frac>{
macro_rules! impl_additive_operator {
( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
impl<const CHUNKS:usize,Frac> core::ops::$trait for $struct<CHUNKS,Frac>{
impl<const N:usize,const F:usize> core::ops::$trait for $struct<N,F>{
type Output = $output;
fn $method(self, other: Self) -> Self::Output {
Self::from_bits(self.bits.$method(other.bits))
}
}
impl<const CHUNKS:usize,Frac:Unsigned,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
where
BInt::<CHUNKS>:From<U>,
BInt::<N>:From<U>,
{
type Output = $output;
fn $method(self, other: U) -> Self::Output {
Self::from_bits(self.bits.$method(BInt::<CHUNKS>::from(other)<<Frac::U32))
Self::from_bits(self.bits.$method(BInt::<N>::from(other).shl(F as u32)))
}
}
};
}
macro_rules! impl_additive_assign_operator {
( $struct: ident, $trait: ident, $method: ident ) => {
impl<const CHUNKS:usize,Frac> core::ops::$trait for $struct<CHUNKS,Frac>{
impl<const N:usize,const F:usize> core::ops::$trait for $struct<N,F>{
fn $method(&mut self, other: Self) {
self.bits.$method(other.bits);
}
}
impl<const CHUNKS:usize,Frac:Unsigned,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
where
BInt::<CHUNKS>:From<U>,
BInt::<N>:From<U>,
{
fn $method(&mut self, other: U) {
self.bits.$method(BInt::<CHUNKS>::from(other)<<Frac::U32);
self.bits.$method(BInt::<N>::from(other)<<F as u32);
}
}
};
@ -129,21 +128,21 @@ impl_additive_operator!( Fixed, BitXor, bitxor, Self );
macro_rules! impl_multiply_operator_const {
( $width:expr, $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
impl<Frac:Unsigned> core::ops::$trait for $struct<$width,Frac>{
impl<const F:usize> core::ops::$trait for $struct<$width,F>{
type Output = $output;
fn $method(self, other: Self) -> Self::Output {
//this can be done better but that is a job for later
let lhs=self.bits.as_::<BInt::<{$width*2}>>();
let rhs=other.bits.as_::<BInt::<{$width*2}>>();
Self::from_bits(lhs.mul(rhs).shr(Frac::U32).as_())
Self::from_bits(lhs.mul(rhs).shr(F as u32).as_())
}
}
};
}
macro_rules! impl_multiply_assign_operator_const {
( $width:expr, $struct: ident, $trait: ident, $method: ident ) => {
impl<Frac> core::ops::$trait for $struct<$width,Frac>{
impl<const F:usize> core::ops::$trait for $struct<$width,F>{
fn $method(&mut self, other: Self) {
self.bits.$method(other.bits);
}
@ -153,13 +152,13 @@ macro_rules! impl_multiply_assign_operator_const {
macro_rules! impl_divide_operator_const {
( $width:expr, $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
impl<Frac:Unsigned> core::ops::$trait for $struct<$width,Frac>{
impl<const F:usize> core::ops::$trait for $struct<$width,F>{
type Output = $output;
fn $method(self, other: Self) -> Self::Output {
//this can be done better but that is a job for later
//this only needs to be $width+Frac::U32/64+1 but MUH CONST GENERICS!!!!!
let lhs=self.bits.as_::<BInt::<{$width*2}>>().shl(Frac::U32);
//this only needs to be $width+F as u32/64+1 but MUH CONST GENERICS!!!!!
let lhs=self.bits.as_::<BInt::<{$width*2}>>().shl(F as u32);
let rhs=other.bits.as_::<BInt::<{$width*2}>>();
Self::from_bits(lhs.div(rhs).as_())
}
@ -168,7 +167,7 @@ macro_rules! impl_divide_operator_const {
}
macro_rules! impl_divide_assign_operator_const {
( $width:expr, $struct: ident, $trait: ident, $method: ident ) => {
impl<Frac> core::ops::$trait for $struct<$width,Frac>{
impl<const F:usize> core::ops::$trait for $struct<$width,F>{
fn $method(&mut self, other: Self) {
self.bits.$method(other.bits);
}
@ -178,26 +177,26 @@ macro_rules! impl_divide_assign_operator_const {
macro_rules! impl_multiplicatave_operator {
( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
impl<const CHUNKS:usize,Frac,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
where
BInt::<CHUNKS>:From<U>+core::ops::$trait,
BInt::<N>:From<U>+core::ops::$trait,
{
type Output = $output;
fn $method(self, other: U) -> Self::Output {
Self::from_bits(self.bits.$method(BInt::<CHUNKS>::from(other)))
Self::from_bits(self.bits.$method(BInt::<N>::from(other)))
}
}
};
}
macro_rules! impl_multiplicatave_assign_operator {
( $struct: ident, $trait: ident, $method: ident ) => {
impl<const CHUNKS:usize,Frac,U> core::ops::$trait<U> for $struct<CHUNKS,Frac>
impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
where
BInt::<CHUNKS>:From<U>+core::ops::$trait,
BInt::<N>:From<U>+core::ops::$trait,
{
fn $method(&mut self, other: U) {
self.bits.$method(BInt::<CHUNKS>::from(other));
self.bits.$method(BInt::<N>::from(other));
}
}
};
@ -255,7 +254,7 @@ impl_multiplicatave_operator!( Fixed, Div, div, 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>{
impl<const N:usize,const F:usize> core::ops::$trait<u32> for $struct<N,F>{
type Output = $output;
fn $method(self, other: u32) -> Self::Output {
@ -266,7 +265,7 @@ macro_rules! impl_shift_operator {
}
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>{
impl<const N:usize,const F:usize> core::ops::$trait<u32> for $struct<N,F>{
fn $method(&mut self, other: u32) {
self.bits.$method(other);
}
@ -283,13 +282,10 @@ impl_shift_operator!( Fixed, Shr, shr, Self );
// let b:I64F64 = a.wide_mul(a);
macro_rules! impl_wide_mul{
($lhs:expr,$rhs:expr)=>{
impl<A> Fixed<$lhs,A>
impl Fixed<$lhs,{$lhs*32}>
{
paste::item!{
pub fn [<wide_mul_ $lhs _ $rhs>]<B>(self,rhs:Fixed<$rhs,B>)->Fixed<{$lhs+$rhs},Sum<A,B>>
where
A:std::ops::Add<B>,
B:Unsigned,{
pub fn [<wide_mul_ $lhs _ $rhs>](self,rhs:Fixed<$rhs,{$rhs*32}>)->Fixed<{$lhs+$rhs},{($lhs+$rhs)*32}>{
Fixed::from_bits(self.bits.as_::<BInt<{$lhs+$rhs}>>()*rhs.bits.as_::<BInt<{$lhs+$rhs}>>())
}
}
@ -316,15 +312,15 @@ impl_wide_mul_all!(
(1,7),(2,7),(3,7),(4,7),(5,7),(6,7),(7,7),(8,7),
(1,8),(2,8),(3,8),(4,8),(5,8),(6,8),(7,8),(8,8)
);
impl<const SRC:usize,Frac> Fixed<SRC,Frac>{
pub fn resize_into<const DST:usize>(self)->Fixed<DST,Frac>{
impl<const SRC:usize,const F:usize> Fixed<SRC,F>{
pub fn resize_into<const DST:usize>(self)->Fixed<DST,F>{
Fixed::from_bits(self.bits.as_::<BInt<DST>>())
}
}
macro_rules! impl_const{
($n:expr)=>{
impl<F:Unsigned+std::ops::Add> Fixed<$n,F>{
impl Fixed<$n,{$n*32}>{
paste::item!{
pub fn sqrt_unchecked(self)->Self{
//1<<max_shift must be the minimum power of two which when squared is greater than self
@ -333,8 +329,8 @@ macro_rules! impl_const{
//2. divide by 2 via >>1 (sqrt-ish)
//3. add on fractional offset
//Voila
let used_bits=self.bits.bits() as i32-1-F::I32;
let max_shift=((used_bits>>1)+F::I32) as u32;
let used_bits=self.bits.bits() as i32-1-($n*32) as i32;
let max_shift=((used_bits>>1)+($n*32) as i32) as u32;
let mut result=Self::ZERO;
//multiply by one to make the types match (hack)

4
fixed_wide/src/lib.rs
View File

@ -1,10 +1,6 @@
pub mod fixed;
pub mod types;
pub mod typenum{
pub use typenum::Unsigned;
}
#[cfg(feature="zeroes")]
pub mod zeroes;
#[cfg(feature="ratio")]

6
fixed_wide/src/tests.rs
View File

@ -3,7 +3,7 @@ use crate::types::I32F32;
#[test]
fn test_wide_mul(){
let a=I32F32::ONE;
let aa=a.wide_mul(a);
let aa=a.wide_mul_1_1(a);
assert_eq!(aa,crate::types::I64F64::ONE);
}
@ -39,10 +39,10 @@ fn find_equiv_sqrt_via_f64(n:I32F32)->I32F32{
let r=I32F32::from_bits(bnum::BInt::<1>::from(i));
//mimic the behaviour of the algorithm,
//return the result if it truncates to the exact answer
if (r+I32F32::EPSILON).wide_mul(r+I32F32::EPSILON)==n.wide_mul(I32F32::ONE){
if (r+I32F32::EPSILON).wide_mul_1_1(r+I32F32::EPSILON)==n.wide_mul_1_1(I32F32::ONE){
return r+I32F32::EPSILON;
}
if (r-I32F32::EPSILON).wide_mul(r-I32F32::EPSILON)==n.wide_mul(I32F32::ONE){
if (r-I32F32::EPSILON).wide_mul_1_1(r-I32F32::EPSILON)==n.wide_mul_1_1(I32F32::ONE){
return r-I32F32::EPSILON;
}
return r;

8
fixed_wide/src/types.rs
View File

@ -1,4 +1,4 @@
pub type I32F32=crate::fixed::Fixed<1,typenum::consts::U32>;
pub type I64F64=crate::fixed::Fixed<2,typenum::consts::U64>;
pub type I128F128=crate::fixed::Fixed<4,typenum::consts::U128>;
pub type I256F256=crate::fixed::Fixed<8,typenum::consts::U256>;
pub type I32F32=crate::fixed::Fixed<1,32>;
pub type I64F64=crate::fixed::Fixed<2,64>;
pub type I128F128=crate::fixed::Fixed<4,128>;
pub type I256F256=crate::fixed::Fixed<8,256>;

24
fixed_wide/src/zeroes.rs
View File

@ -1,30 +1,27 @@
use crate::fixed::Fixed;
use crate::ratio::Ratio;
use typenum::{Sum,Unsigned};
use arrayvec::ArrayVec;
use std::cmp::Ordering;
macro_rules! impl_zeroes{
($n:expr)=>{
impl<F> Fixed<$n,F>
where
F:Unsigned+std::ops::Add,
<F as std::ops::Add>::Output:Unsigned,
{
impl Fixed<$n,{$n*32}>{
paste::item!{
#[inline]
pub fn zeroes2(a0:Self,a1:Self,a2:Self)->ArrayVec<Ratio<Self,Self>,2>{
let a2pos=match a2.cmp(&Self::ZERO){
Ordering::Greater=>true,
Ordering::Equal=>return ArrayVec::from_iter($crate::zeroes::zeroes1(a0,a1).into_iter()),
Ordering::Equal=>return ArrayVec::from_iter(Self::zeroes1(a0,a1).into_iter()),
Ordering::Less=>true,
};
let radicand=a1.[<wide_mul_ $n _ $n>](a1)-a2.[<wide_mul_ $n _ $n>](a0)*4;
match radicand.cmp(&Fixed::<{$n*2},Sum<F,F>>::ZERO){
match radicand.cmp(&Fixed::<{$n*2},{$n*2*32}>::ZERO){
Ordering::Greater=>{
//start with f64 sqrt
//failure case: 2^63 < sqrt(2^127)
let planar_radicand=radicand.sqrt();
let planar_radicand_wide=radicand.sqrt();
//lazy hack
let planar_radicand=Self::from_bits(bnum::cast::As::as_(planar_radicand_wide.bits.shr($n*32)));
//TODO: one or two newtons
//sort roots ascending and avoid taking the difference of large numbers
match (a2pos,Self::ZERO<a1){
@ -54,7 +51,8 @@ impl_zeroes!(1);
impl_zeroes!(2);
impl_zeroes!(3);
impl_zeroes!(4);
impl_zeroes!(5);
impl_zeroes!(6);
impl_zeroes!(7);
impl_zeroes!(8);
//sqrt doubles twice!
//impl_zeroes!(5);
//impl_zeroes!(6);
//impl_zeroes!(7);
//impl_zeroes!(8);