div_euclid

fixed_wide/Cargo.lock

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

fixed_wide/Cargo.toml

@@ -1,7 +1,11 @@
 [package]
 name = "fixed_wide"
-version = "0.1.0"
+version = "0.1.1"
 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=[]
@@ -13,4 +17,4 @@ zeroes=["dep:arrayvec"]
 bnum = "0.12.0"
 arrayvec = { version = "0.7.6", optional = true }
 paste = "1.0.15"
-ratio_ops = { path = "../ratio_ops", optional = true }
+ratio_ops = { version = "0.1.0", path = "../ratio_ops", registry = "strafesnet", optional = true }

fixed_wide/src/fixed.rs

@@ -65,19 +65,27 @@ impl<const F:usize> Fixed<1,F>{
 	}
 	#[inline]
 	pub const fn to_raw(self)->i64{
-		self.to_bits().to_bits().digits()[0] as i64
+		let &[digit]=self.to_bits().to_bits().digits();
+		digit as i64
 	}
 }
 
-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)
-	}
+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_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]
@@ -165,7 +173,7 @@ macro_rules! impl_into_float {
 					msb_offset<<($mantissa_bits-1)
 				};
 				let digits=unsigned.digits();
-				let digit_index=most_significant_bit>>DIGIT_SHIFT;
+				let digit_index=most_significant_bit.saturating_sub(1)>>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);
@@ -189,6 +197,97 @@ 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>{
@@ -313,7 +412,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/BInt::from(other))
+				Self::from_bits(self.bits.div_euclid(BInt::from(other)))
 			}
 		}
 	}
@@ -323,11 +422,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(rhs).as_())
+				Self::from_bits(lhs.div_euclid(rhs).as_())
 			}
 			}
 		}
@@ -347,28 +446,28 @@ macro_rules! impl_divide_operator_not_const_generic {
 }
 
 macro_rules! impl_multiplicative_operator {
-	( $struct: ident, $trait: ident, $method: ident, $output: ty ) => {
+	( $struct: ident, $trait: ident, $method: ident, $inner_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.$method(BInt::<N>::from(other)))
+			fn $method(self,other:U)->Self::Output{
+				Self::from_bits(self.bits.$inner_method(BInt::<N>::from(other)))
 			}
 		}
 	};
 }
 macro_rules! impl_multiplicative_assign_operator {
-	( $struct: ident, $trait: ident, $method: ident ) => {
+	( $struct: ident, $trait: ident, $method: ident, $not_assign_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.$method(BInt::<N>::from(other));
+			fn $method(&mut self,other:U){
+				self.bits=self.bits.$not_assign_method(BInt::<N>::from(other));
 			}
 		}
 	};
@@ -396,10 +495,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 );
-impl_multiplicative_operator!( Fixed, Mul, mul, Self );
-impl_multiplicative_assign_operator!( Fixed, DivAssign, div_assign );
-impl_multiplicative_operator!( 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 );
 #[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)<<32;
+	let a=I256F256::from(237946589723468975i64)<<16;
 	let f:f32=a.into();
-	assert_eq!(f,237946589723468975f32*2.0f32.powi(32));
+	assert_eq!(f,237946589723468975f32*2.0f32.powi(16));
 }
 
 #[test]
@@ -32,9 +32,62 @@ fn to_f64(){
 	let a=I256F256::from(0);
 	let f:f64=(-a).into();
 	assert_eq!(f,0f64);
-	let a=I256F256::from(237946589723468975i64)<<32;
+	let a=I256F256::from(237946589723468975i64)<<16;
 	let f:f64=a.into();
-	assert_eq!(f,237946589723468975f64*2.0f64.powi(32));
+	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));
 }
 
 #[test]

linear_ops/Cargo.lock

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

linear_ops/Cargo.toml

@@ -2,6 +2,10 @@
 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"]
@@ -10,9 +14,9 @@ fixed-wide=["dep:fixed_wide","dep:paste"]
 deferred-division=["dep:ratio_ops"]
 
 [dependencies]
-ratio_ops = { path = "../ratio_ops", optional = true }
-fixed_wide = { path = "../fixed_wide", optional = true }
+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 }
 paste = { version = "1.0.15", optional = true }
 
 [dev-dependencies]
-fixed_wide = { path = "../fixed_wide", features = ["wide-mul"] }
+fixed_wide = { version = "0.1.0", path = "../fixed_wide", registry = "strafesnet", features = ["wide-mul"] }

linear_ops/LICENSE-APACHE

@@ -0,0 +1,176 @@
+                              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

@@ -0,0 +1,23 @@
+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,5 +2,9 @@
 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

@@ -0,0 +1,176 @@
+                              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

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