appropriate types

absrel/Cargo.toml

@@ -0,0 +1,6 @@
+[package]
+name = "absrel"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]

absrel/src/abs.rs

@@ -0,0 +1,4 @@
+/// This type represents an absolute value, such as a coordinate for a world position.
+/// This is called a euclidean point in Geometric Algebra.
+/// The most appropriate type here is a fixed-point value.
+pub struct Absolute<T>(T);

absrel/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod abs;
+pub mod rel;

absrel/src/rel.rs

@@ -0,0 +1,8 @@
+/// This type represents the difference between two absolute values.
+/// This is called an ideal point in Geometric Algebra.
+/// After you get your time delta or position delta,
+/// implement your number-crunching logic using this type.
+/// Once the calculation is complete, it can be added to an absolute value
+/// with the effect of offsetting the value to a new absolute value.
+/// The most appropriate type here is a floating point value.
+pub struct Relative<T>(T);

fixed_wide/Cargo.lock

@@ -16,7 +16,7 @@ checksum = "50202def95bf36cb7d1d7a7962cea1c36a3f8ad42425e5d2b71d7acb8041b5b8"
 
 [[package]]
 name = "fixed_wide"
-version = "0.1.1"
+version = "0.1.0"
 dependencies = [
  "arrayvec",
  "bnum",

fixed_wide/Cargo.toml

@@ -1,11 +1,7 @@
 [package]
 name = "fixed_wide"
-version = "0.1.1"
+version = "0.1.0"
 edition = "2021"
-repository = "https://git.itzana.me/StrafesNET/fixed_wide_vectors"
-license = "MIT OR Apache-2.0"
-description = "Fixed point numbers with optional widening Mul operator."
-authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [features]
 default=[]
@@ -17,4 +13,4 @@ zeroes=["dep:arrayvec"]
 bnum = "0.12.0"
 arrayvec = { version = "0.7.6", optional = true }
 paste = "1.0.15"
-ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
+ratio_ops = { path = "../ratio_ops", optional = true }

fixed_wide/src/fixed.rs

@@ -65,27 +65,19 @@ impl<const F:usize> Fixed<1,F>{
 	}
 	#[inline]
 	pub const fn to_raw(self)->i64{
-		let &[digit]=self.to_bits().to_bits().digits();
-		digit as i64
+		self.to_bits().to_bits().digits()[0] as i64
 	}
 }
 
-macro_rules! impl_from {
-	($($from:ty),*)=>{
-		$(
-		impl<const N:usize,const F:usize> From<$from> for Fixed<N,F>{
-			#[inline]
-			fn from(value:$from)->Self{
-				Self::from_bits(BInt::<{N}>::from(value)<<F as u32)
-			}
-		}
-		)*
-	};
+impl<const N:usize,const F:usize,T> From<T> for Fixed<N,F>
+	where
+		BInt<N>:From<T>
+{
+	#[inline]
+	fn from(value:T)->Self{
+		Self::from_bits(BInt::<{N}>::from(value)<<F as u32)
+	}
 }
-impl_from!(
-	u8,u16,u32,u64,u128,usize,
-	i8,i16,i32,i64,i128,isize
-);
 
 impl<const N:usize,const F:usize> PartialEq for Fixed<N,F>{
 	#[inline]
@@ -173,7 +165,7 @@ macro_rules! impl_into_float {
 					msb_offset<<($mantissa_bits-1)
 				};
 				let digits=unsigned.digits();
-				let digit_index=most_significant_bit.saturating_sub(1)>>DIGIT_SHIFT;
+				let digit_index=most_significant_bit>>DIGIT_SHIFT;
 				let digit=digits[digit_index as usize];
 				//How many bits does the mantissa take from this digit
 				let take_bits=most_significant_bit-(digit_index<<DIGIT_SHIFT);
@@ -197,97 +189,6 @@ macro_rules! impl_into_float {
 impl_into_float!(f32,u32,8,24);
 impl_into_float!(f64,u64,11,53);
 
-#[inline]
-fn integer_decode_f32(f: f32) -> (u64, i16, bool) {
-	let bits: u32 = f.to_bits();
-	let sign: bool = bits & (1<<31) != 0;
-	let mut exponent: i16 = ((bits >> 23) & 0xff) as i16;
-	let mantissa = if exponent == 0 {
-		(bits & 0x7fffff) << 1
-	} else {
-		(bits & 0x7fffff) | 0x800000
-	};
-	// Exponent bias + mantissa shift
-	exponent -= 127 + 23;
-	(mantissa as u64, exponent, sign)
-}
-#[inline]
-fn integer_decode_f64(f: f64) -> (u64, i16, bool) {
-	let bits: u64 = f.to_bits();
-	let sign: bool = bits & (1u64<<63) != 0;
-	let mut exponent: i16 = ((bits >> 52) & 0x7ff) as i16;
-	let mantissa = if exponent == 0 {
-		(bits & 0xfffffffffffff) << 1
-	} else {
-		(bits & 0xfffffffffffff) | 0x10000000000000
-	};
-	// Exponent bias + mantissa shift
-	exponent -= 1023 + 52;
-	(mantissa, exponent, sign)
-}
-#[derive(Debug,Eq,PartialEq)]
-pub enum FixedFromFloatError{
-	Nan,
-	Infinite,
-	Overflow,
-	Underflow,
-}
-impl FixedFromFloatError{
-	pub fn underflow_to_zero<const N:usize,const F:usize>(self)->Result<Fixed<N,F>,Self>{
-		match self{
-			FixedFromFloatError::Underflow=>Ok(Fixed::ZERO),
-			_=>Err(self),
-		}
-	}
-}
-macro_rules! impl_from_float {
-	( $decode:ident, $input: ty, $mantissa_bits:expr ) => {
-		impl<const N:usize,const F:usize> TryFrom<$input> for Fixed<N,F>{
-			type Error=FixedFromFloatError;
-			#[inline]
-			fn try_from(value:$input)->Result<Self,Self::Error>{
-				const DIGIT_SHIFT:u32=6;
-				match value.classify(){
-					std::num::FpCategory::Nan=>Err(FixedFromFloatError::Nan),
-					std::num::FpCategory::Infinite=>Err(FixedFromFloatError::Infinite),
-					std::num::FpCategory::Zero=>Ok(Self::ZERO),
-					std::num::FpCategory::Subnormal
-					|std::num::FpCategory::Normal
-					=>{
-						let (m,e,s)=$decode(value);
-						let mut digits=[0u64;N];
-						let most_significant_bit=e as i32+$mantissa_bits as i32+F as i32;
-						if most_significant_bit<0{
-							return Err(FixedFromFloatError::Underflow);
-						}
-						let digit_index=most_significant_bit>>DIGIT_SHIFT;
-						let digit=digits.get_mut(digit_index as usize).ok_or(FixedFromFloatError::Overflow)?;
-						let take_bits=most_significant_bit-(digit_index<<DIGIT_SHIFT);
-						let rest_of_mantissa=-($mantissa_bits as i32-(take_bits as i32));
-						*digit=signed_shift(m,rest_of_mantissa);
-						if rest_of_mantissa<0&&digit_index!=0{
-							//we don't care if some float bits are partially truncated
-							if let Some(digit)=digits.get_mut((digit_index-1) as usize){
-								let take_bits=most_significant_bit-((digit_index-1)<<DIGIT_SHIFT);
-								let rest_of_mantissa=-($mantissa_bits as i32-(take_bits as i32));
-								*digit=signed_shift(m,rest_of_mantissa);
-							}
-						}
-						let bits=BInt::from_bits(bnum::BUint::from_digits(digits));
-						Ok(if s{
-							Self::from_bits(bits.overflowing_neg().0)
-						}else{
-							Self::from_bits(bits)
-						})
-					},
-				}
-			}
-		}
-	}
-}
-impl_from_float!(integer_decode_f32,f32,24);
-impl_from_float!(integer_decode_f64,f64,53);
-
 impl<const N:usize,const F:usize> core::fmt::Display for Fixed<N,F>{
 	#[inline]
 	fn fmt(&self,f:&mut core::fmt::Formatter)->Result<(),core::fmt::Error>{
@@ -412,7 +313,7 @@ macro_rules! impl_multiply_operator_not_const_generic {
 			type Output=Self;
 			#[inline]
 			fn divide(self, other: i64)->Self::Output{
-				Self::from_bits(self.bits.div_euclid(BInt::from(other)))
+				Self::from_bits(self.bits/BInt::from(other))
 			}
 		}
 	}
@@ -422,11 +323,11 @@ macro_rules! impl_divide_operator_not_const_generic {
 		impl<const F:usize> $struct<$width,F>{
 			paste::item!{
 			#[inline]
-			pub fn [<fixed_ $method>](self,other:Self)->Self{
+			pub fn [<fixed_ $method>](self, other: Self) -> Self {
 				//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_euclid(rhs).as_())
+				Self::from_bits(lhs.div(rhs).as_())
 			}
 			}
 		}
@@ -446,28 +347,28 @@ macro_rules! impl_divide_operator_not_const_generic {
 }
 
 macro_rules! impl_multiplicative_operator {
-	( $struct: ident, $trait: ident, $method: ident, $inner_method: ident, $output: ty ) => {
+	( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
 		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
 			where
 				BInt::<N>:From<U>+core::ops::$trait,
 		{
 			type Output = $output;
 			#[inline]
-			fn $method(self,other:U)->Self::Output{
-				Self::from_bits(self.bits.$inner_method(BInt::<N>::from(other)))
+			fn $method(self, other: U) -> Self::Output {
+				Self::from_bits(self.bits.$method(BInt::<N>::from(other)))
 			}
 		}
 	};
 }
 macro_rules! impl_multiplicative_assign_operator {
-	( $struct: ident, $trait: ident, $method: ident, $not_assign_method: ident ) => {
+	( $struct: ident, $trait: ident, $method: ident ) => {
 		impl<const N:usize,const F:usize,U> core::ops::$trait<U> for $struct<N,F>
 			where
 				BInt::<N>:From<U>+core::ops::$trait,
 		{
 			#[inline]
-			fn $method(&mut self,other:U){
-				self.bits=self.bits.$not_assign_method(BInt::<N>::from(other));
+			fn $method(&mut self, other: U) {
+				self.bits.$method(BInt::<N>::from(other));
 			}
 		}
 	};
@@ -495,10 +396,10 @@ macro_16!( impl_multiplicative_assign_operator_not_const_generic, (Fixed, MulAss
 macro_16!( impl_multiply_operator_not_const_generic, (Fixed, Mul, mul, Self) );
 macro_16!( impl_multiplicative_assign_operator_not_const_generic, (Fixed, DivAssign, div_assign, div) );
 macro_16!( impl_divide_operator_not_const_generic, (Fixed, Div, div, Self) );
-impl_multiplicative_assign_operator!( Fixed, MulAssign, mul_assign, mul );
-impl_multiplicative_operator!( Fixed, Mul, mul, mul, Self );
-impl_multiplicative_assign_operator!( Fixed, DivAssign, div_assign, div_euclid );
-impl_multiplicative_operator!( Fixed, Div, div, div_euclid, Self );
+impl_multiplicative_assign_operator!( Fixed, MulAssign, mul_assign );
+impl_multiplicative_operator!( Fixed, Mul, mul, Self );
+impl_multiplicative_assign_operator!( Fixed, DivAssign, div_assign );
+impl_multiplicative_operator!( Fixed, Div, div, Self );
 #[cfg(feature="deferred-division")]
 impl<const LHS_N:usize,const LHS_F:usize,const RHS_N:usize,const RHS_F:usize> core::ops::Div<Fixed<RHS_N,RHS_F>> for Fixed<LHS_N,LHS_F>{
 	type Output=ratio_ops::ratio::Ratio<Fixed<LHS_N,LHS_F>,Fixed<RHS_N,RHS_F>>;

fixed_wide/src/tests.rs

@@ -17,9 +17,9 @@ fn to_f32(){
 	let a=I256F256::from(0);
 	let f:f32=(-a).into();
 	assert_eq!(f,0f32);
-	let a=I256F256::from(237946589723468975i64)<<16;
+	let a=I256F256::from(237946589723468975i64)<<32;
 	let f:f32=a.into();
-	assert_eq!(f,237946589723468975f32*2.0f32.powi(16));
+	assert_eq!(f,237946589723468975f32*2.0f32.powi(32));
 }
 
 #[test]
@@ -32,62 +32,9 @@ fn to_f64(){
 	let a=I256F256::from(0);
 	let f:f64=(-a).into();
 	assert_eq!(f,0f64);
-	let a=I256F256::from(237946589723468975i64)<<16;
+	let a=I256F256::from(237946589723468975i64)<<32;
 	let f:f64=a.into();
-	assert_eq!(f,237946589723468975f64*2.0f64.powi(16));
-}
-
-#[test]
-fn from_f32(){
-	let a=I256F256::from(1)>>2;
-	let b:Result<I256F256,_>=0.25f32.try_into();
-	assert_eq!(b,Ok(a));
-	let a=I256F256::from(-1)>>2;
-	let b:Result<I256F256,_>=(-0.25f32).try_into();
-	assert_eq!(b,Ok(a));
-	let a=I256F256::from(0);
-	let b:Result<I256F256,_>=0.try_into();
-	assert_eq!(b,Ok(a));
-	let a=I256F256::from(0b101011110101001010101010000000000000000000000000000i64)<<16;
-	let b:Result<I256F256,_>=(0b101011110101001010101010000000000000000000000000000u64 as f32*2.0f32.powi(16)).try_into();
-	assert_eq!(b,Ok(a));
-	//I32F32::MAX into f32 is truncated into this value
-	let a=I32F32::raw(0b111111111111111111111111000000000000000000000000000000000000000i64);
-	let b:Result<I32F32,_>=Into::<f32>::into(I32F32::MAX).try_into();
-	assert_eq!(b,Ok(a));
-	//I32F32::MIN hits a special case since it's not representable as a positive signed integer
-	//TODO: don't return an overflow because this is technically possible
-	let a=I32F32::MIN;
-	let b:Result<I32F32,_>=Into::<f32>::into(I32F32::MIN).try_into();
-	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
-	//16 is within the 24 bits of float precision
-	let b:Result<I32F32,_>=Into::<f32>::into(-I32F32::MIN.fix_2()).try_into();
-	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Overflow));
-	let b:Result<I32F32,_>=f32::MIN_POSITIVE.try_into();
-	assert_eq!(b,Err(crate::fixed::FixedFromFloatError::Underflow));
-	//test many cases
-	for i in 0..64{
-		let a=crate::fixed::Fixed::<2,64>::raw_digit(0b111111111111111111111111000000000000000000000000000000000000000i64)<<i;
-		let f:f32=a.into();
-		let b:Result<crate::fixed::Fixed<2,64>,_>=f.try_into();
-		assert_eq!(b,Ok(a));
-	}
-}
-
-#[test]
-fn from_f64(){
-	let a=I256F256::from(1)>>2;
-	let b:Result<I256F256,_>=0.25f64.try_into();
-	assert_eq!(b,Ok(a));
-	let a=I256F256::from(-1)>>2;
-	let b:Result<I256F256,_>=(-0.25f64).try_into();
-	assert_eq!(b,Ok(a));
-	let a=I256F256::from(0);
-	let b:Result<I256F256,_>=0.try_into();
-	assert_eq!(b,Ok(a));
-	let a=I256F256::from(0b101011110101001010101010000000000000000000000000000i64)<<16;
-	let b:Result<I256F256,_>=(0b101011110101001010101010000000000000000000000000000u64 as f64*2.0f64.powi(16)).try_into();
-	assert_eq!(b,Ok(a));
+	assert_eq!(f,237946589723468975f64*2.0f64.powi(32));
 }
 
 #[test]

linear_ops/Cargo.lock

@@ -10,7 +10,7 @@ checksum = "50202def95bf36cb7d1d7a7962cea1c36a3f8ad42425e5d2b71d7acb8041b5b8"
 
 [[package]]
 name = "fixed_wide"
-version = "0.1.1"
+version = "0.1.0"
 dependencies = [
  "bnum",
  "paste",

linear_ops/Cargo.toml

@@ -2,10 +2,6 @@
 name = "linear_ops"
 version = "0.1.0"
 edition = "2021"
-repository = "https://git.itzana.me/StrafesNET/fixed_wide_vectors"
-license = "MIT OR Apache-2.0"
-description = "Vector/Matrix operations using trait bounds."
-authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [features]
 default=["named-fields","fixed-wide"]
@@ -14,9 +10,9 @@ fixed-wide=["dep:fixed_wide","dep:paste"]
 deferred-division=["dep:ratio_ops"]
 
 [dependencies]
-ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }
-fixed_wide = { version = "0.1.0", path = "../fixed_wide", registry = "strafesnet", optional = true }
+ratio_ops = { path = "../ratio_ops", optional = true }
+fixed_wide = { path = "../fixed_wide", optional = true }
 paste = { version = "1.0.15", optional = true }
 
 [dev-dependencies]
-fixed_wide = { version = "0.1.0", path = "../fixed_wide", registry = "strafesnet", features = ["wide-mul"] }
+fixed_wide = { path = "../fixed_wide", features = ["wide-mul"] }

linear_ops/LICENSE-APACHE

@@ -1,176 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS

linear_ops/LICENSE-MIT

@@ -1,23 +0,0 @@
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

ratio_ops/Cargo.toml

@@ -2,9 +2,5 @@
 name = "ratio_ops"
 version = "0.1.0"
 edition = "2021"
-repository = "https://git.itzana.me/StrafesNET/fixed_wide_vectors"
-license = "MIT OR Apache-2.0"
-description = "Ratio operations using trait bounds for avoiding division like the plague."
-authors = ["Rhys Lloyd <krakow20@gmail.com>"]
 
 [dependencies]

ratio_ops/LICENSE-APACHE

@@ -1,176 +0,0 @@
-                              Apache License
-                        Version 2.0, January 2004
-                     http://www.apache.org/licenses/
-
-TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-1. Definitions.
-
-   "License" shall mean the terms and conditions for use, reproduction,
-   and distribution as defined by Sections 1 through 9 of this document.
-
-   "Licensor" shall mean the copyright owner or entity authorized by
-   the copyright owner that is granting the License.
-
-   "Legal Entity" shall mean the union of the acting entity and all
-   other entities that control, are controlled by, or are under common
-   control with that entity. For the purposes of this definition,
-   "control" means (i) the power, direct or indirect, to cause the
-   direction or management of such entity, whether by contract or
-   otherwise, or (ii) ownership of fifty percent (50%) or more of the
-   outstanding shares, or (iii) beneficial ownership of such entity.
-
-   "You" (or "Your") shall mean an individual or Legal Entity
-   exercising permissions granted by this License.
-
-   "Source" form shall mean the preferred form for making modifications,
-   including but not limited to software source code, documentation
-   source, and configuration files.
-
-   "Object" form shall mean any form resulting from mechanical
-   transformation or translation of a Source form, including but
-   not limited to compiled object code, generated documentation,
-   and conversions to other media types.
-
-   "Work" shall mean the work of authorship, whether in Source or
-   Object form, made available under the License, as indicated by a
-   copyright notice that is included in or attached to the work
-   (an example is provided in the Appendix below).
-
-   "Derivative Works" shall mean any work, whether in Source or Object
-   form, that is based on (or derived from) the Work and for which the
-   editorial revisions, annotations, elaborations, or other modifications
-   represent, as a whole, an original work of authorship. For the purposes
-   of this License, Derivative Works shall not include works that remain
-   separable from, or merely link (or bind by name) to the interfaces of,
-   the Work and Derivative Works thereof.
-
-   "Contribution" shall mean any work of authorship, including
-   the original version of the Work and any modifications or additions
-   to that Work or Derivative Works thereof, that is intentionally
-   submitted to Licensor for inclusion in the Work by the copyright owner
-   or by an individual or Legal Entity authorized to submit on behalf of
-   the copyright owner. For the purposes of this definition, "submitted"
-   means any form of electronic, verbal, or written communication sent
-   to the Licensor or its representatives, including but not limited to
-   communication on electronic mailing lists, source code control systems,
-   and issue tracking systems that are managed by, or on behalf of, the
-   Licensor for the purpose of discussing and improving the Work, but
-   excluding communication that is conspicuously marked or otherwise
-   designated in writing by the copyright owner as "Not a Contribution."
-
-   "Contributor" shall mean Licensor and any individual or Legal Entity
-   on behalf of whom a Contribution has been received by Licensor and
-   subsequently incorporated within the Work.
-
-2. Grant of Copyright License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   copyright license to reproduce, prepare Derivative Works of,
-   publicly display, publicly perform, sublicense, and distribute the
-   Work and such Derivative Works in Source or Object form.
-
-3. Grant of Patent License. Subject to the terms and conditions of
-   this License, each Contributor hereby grants to You a perpetual,
-   worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-   (except as stated in this section) patent license to make, have made,
-   use, offer to sell, sell, import, and otherwise transfer the Work,
-   where such license applies only to those patent claims licensable
-   by such Contributor that are necessarily infringed by their
-   Contribution(s) alone or by combination of their Contribution(s)
-   with the Work to which such Contribution(s) was submitted. If You
-   institute patent litigation against any entity (including a
-   cross-claim or counterclaim in a lawsuit) alleging that the Work
-   or a Contribution incorporated within the Work constitutes direct
-   or contributory patent infringement, then any patent licenses
-   granted to You under this License for that Work shall terminate
-   as of the date such litigation is filed.
-
-4. Redistribution. You may reproduce and distribute copies of the
-   Work or Derivative Works thereof in any medium, with or without
-   modifications, and in Source or Object form, provided that You
-   meet the following conditions:
-
-   (a) You must give any other recipients of the Work or
-       Derivative Works a copy of this License; and
-
-   (b) You must cause any modified files to carry prominent notices
-       stating that You changed the files; and
-
-   (c) You must retain, in the Source form of any Derivative Works
-       that You distribute, all copyright, patent, trademark, and
-       attribution notices from the Source form of the Work,
-       excluding those notices that do not pertain to any part of
-       the Derivative Works; and
-
-   (d) If the Work includes a "NOTICE" text file as part of its
-       distribution, then any Derivative Works that You distribute must
-       include a readable copy of the attribution notices contained
-       within such NOTICE file, excluding those notices that do not
-       pertain to any part of the Derivative Works, in at least one
-       of the following places: within a NOTICE text file distributed
-       as part of the Derivative Works; within the Source form or
-       documentation, if provided along with the Derivative Works; or,
-       within a display generated by the Derivative Works, if and
-       wherever such third-party notices normally appear. The contents
-       of the NOTICE file are for informational purposes only and
-       do not modify the License. You may add Your own attribution
-       notices within Derivative Works that You distribute, alongside
-       or as an addendum to the NOTICE text from the Work, provided
-       that such additional attribution notices cannot be construed
-       as modifying the License.
-
-   You may add Your own copyright statement to Your modifications and
-   may provide additional or different license terms and conditions
-   for use, reproduction, or distribution of Your modifications, or
-   for any such Derivative Works as a whole, provided Your use,
-   reproduction, and distribution of the Work otherwise complies with
-   the conditions stated in this License.
-
-5. Submission of Contributions. Unless You explicitly state otherwise,
-   any Contribution intentionally submitted for inclusion in the Work
-   by You to the Licensor shall be under the terms and conditions of
-   this License, without any additional terms or conditions.
-   Notwithstanding the above, nothing herein shall supersede or modify
-   the terms of any separate license agreement you may have executed
-   with Licensor regarding such Contributions.
-
-6. Trademarks. This License does not grant permission to use the trade
-   names, trademarks, service marks, or product names of the Licensor,
-   except as required for reasonable and customary use in describing the
-   origin of the Work and reproducing the content of the NOTICE file.
-
-7. Disclaimer of Warranty. Unless required by applicable law or
-   agreed to in writing, Licensor provides the Work (and each
-   Contributor provides its Contributions) on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-   implied, including, without limitation, any warranties or conditions
-   of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-   PARTICULAR PURPOSE. You are solely responsible for determining the
-   appropriateness of using or redistributing the Work and assume any
-   risks associated with Your exercise of permissions under this License.
-
-8. Limitation of Liability. In no event and under no legal theory,
-   whether in tort (including negligence), contract, or otherwise,
-   unless required by applicable law (such as deliberate and grossly
-   negligent acts) or agreed to in writing, shall any Contributor be
-   liable to You for damages, including any direct, indirect, special,
-   incidental, or consequential damages of any character arising as a
-   result of this License or out of the use or inability to use the
-   Work (including but not limited to damages for loss of goodwill,
-   work stoppage, computer failure or malfunction, or any and all
-   other commercial damages or losses), even if such Contributor
-   has been advised of the possibility of such damages.
-
-9. Accepting Warranty or Additional Liability. While redistributing
-   the Work or Derivative Works thereof, You may choose to offer,
-   and charge a fee for, acceptance of support, warranty, indemnity,
-   or other liability obligations and/or rights consistent with this
-   License. However, in accepting such obligations, You may act only
-   on Your own behalf and on Your sole responsibility, not on behalf
-   of any other Contributor, and only if You agree to indemnify,
-   defend, and hold each Contributor harmless for any liability
-   incurred by, or claims asserted against, such Contributor by reason
-   of your accepting any such warranty or additional liability.
-
-END OF TERMS AND CONDITIONS

ratio_ops/LICENSE-MIT

@@ -1,23 +0,0 @@
-Permission is hereby granted, free of charge, to any
-person obtaining a copy of this software and associated
-documentation files (the "Software"), to deal in the
-Software without restriction, including without
-limitation the rights to use, copy, modify, merge,
-publish, distribute, sublicense, and/or sell copies of
-the Software, and to permit persons to whom the Software
-is furnished to do so, subject to the following
-conditions:
-
-The above copyright notice and this permission notice
-shall be included in all copies or substantial portions
-of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
-ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
-TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
-PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
-SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
-CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
-OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR
-IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
-DEALINGS IN THE SOFTWARE.

ratio_ops/src/ratio.rs

@@ -251,35 +251,32 @@ impl_ratio_assign_operator!(RemAssign,rem_assign);
 // Only implement PartialEq<Self>
 // Rust's operators aren't actually that good
 
-impl<LhsNum,LhsDen,RhsNum,RhsDen,T,U> PartialEq<Ratio<RhsNum,RhsDen>> for Ratio<LhsNum,LhsDen>
+impl<Num,Den,T> PartialEq for Ratio<Num,Den>
 	where
-		LhsNum:Copy,
-		LhsDen:Copy,
-		RhsNum:Copy,
-		RhsDen:Copy,
-		LhsNum:core::ops::Mul<RhsDen,Output=T>,
-		RhsNum:core::ops::Mul<LhsDen,Output=U>,
-		T:PartialEq<U>,
+		Num:Copy,
+		Den:Copy,
+		Num:core::ops::Mul<Den,Output=T>,
+		T:PartialEq,
 {
 	#[inline]
-	fn eq(&self,other:&Ratio<RhsNum,RhsDen>)->bool{
+	fn eq(&self,&other:&Self)->bool{
 		(self.num*other.den).eq(&(other.num*self.den))
 	}
 }
-impl<Num,Den> Eq for Ratio<Num,Den> where Self:PartialEq{}
-
-impl<LhsNum,LhsDen,RhsNum,RhsDen,T,U> PartialOrd<Ratio<RhsNum,RhsDen>> for Ratio<LhsNum,LhsDen>
+impl<Num,Den> Eq for Ratio<Num,Den>
 	where
-		LhsNum:Copy,
-		LhsDen:Copy,
-		RhsNum:Copy,
-		RhsDen:Copy,
-		LhsNum:core::ops::Mul<RhsDen,Output=T>,
-		RhsNum:core::ops::Mul<LhsDen,Output=U>,
-		T:PartialOrd<U>,
+		Ratio<Num,Den>:PartialEq,
+{}
+
+impl<Num,Den,T> PartialOrd for Ratio<Num,Den>
+	where
+		Num:Copy,
+		Den:Copy,
+		Num:core::ops::Mul<Den,Output=T>,
+		T:PartialOrd,
 {
 	#[inline]
-	fn partial_cmp(&self,other:&Ratio<RhsNum,RhsDen>)->Option<core::cmp::Ordering>{
+	fn partial_cmp(&self,&other:&Self)->Option<core::cmp::Ordering>{
 		(self.num*other.den).partial_cmp(&(other.num*self.den))
 	}
 }