Fixed consistency of std::ops usage

RLado · RLado · commit 647927180dd8 · 2025-03-09T21:18:48.000+01:00
diff --git a/src/data.rs b/src/data.rs
@@ -1,11 +1,9 @@
 //! Data structures for rsparse
-//!
 
 use crate::{add, multiply, scpmat, scxmat};
 use std::fmt;
 use std::fs::File;
-use std::io::Write;
-use std::io::{BufRead, BufReader};
+use std::io::{BufRead, BufReader, Write};
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};
 
 // Define a generic Numeric trait compatible with `Sprs` matrices
@@ -120,14 +118,14 @@ pub trait Numeric<F>:
     + Default
     + Zero
     + One
+    + Add<Output = F>
+    + Sub<Output = F>
+    + Mul<Output = F>
+    + Div<Output = F>
+    + Neg<Output = F>
+    + std::iter::Sum
     + fmt::Display
     + fmt::Debug
-    + std::ops::Add<Output = F>
-    + std::ops::Sub<Output = F>
-    + std::ops::Mul<Output = F>
-    + std::ops::Div<Output = F>
-    + std::ops::Neg<Output = F>
-    + std::iter::Sum
     + From<F>
 {
     fn abs(self) -> F;
@@ -526,7 +524,7 @@ impl<T: Numeric<T>> Default for Sprs<T> {
 
 // Implementing operators for `Sprs`
 
-impl<T: Numeric<T>> std::ops::Add for Sprs<T> {
+impl<T: Numeric<T>> Add for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `+` operator. Adds two sparse matrices
@@ -536,7 +534,7 @@ impl<T: Numeric<T>> std::ops::Add for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Add<&Sprs<T>> for Sprs<T> {
+impl<T: Numeric<T>> Add<&Sprs<T>> for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `+` operator.
@@ -546,7 +544,7 @@ impl<T: Numeric<T>> std::ops::Add<&Sprs<T>> for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Add for &Sprs<T> {
+impl<T: Numeric<T>> Add for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `+` operator. Adds two references to sparse matrices
@@ -556,7 +554,7 @@ impl<T: Numeric<T>> std::ops::Add for &Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Add<Sprs<T>> for &Sprs<T> {
+impl<T: Numeric<T>> Add<Sprs<T>> for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `+` operator.
@@ -566,7 +564,7 @@ impl<T: Numeric<T>> std::ops::Add<Sprs<T>> for &Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Sub for Sprs<T> {
+impl<T: Numeric<T>> Sub for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `-` operator. Subtracts two sparse matrices
@@ -576,7 +574,7 @@ impl<T: Numeric<T>> std::ops::Sub for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Sub<&Sprs<T>> for Sprs<T> {
+impl<T: Numeric<T>> Sub<&Sprs<T>> for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `-` operator.
@@ -586,7 +584,7 @@ impl<T: Numeric<T>> std::ops::Sub<&Sprs<T>> for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Sub for &Sprs<T> {
+impl<T: Numeric<T>> Sub for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `-` operator. Subtracts two references to sparse matrices
@@ -596,7 +594,7 @@ impl<T: Numeric<T>> std::ops::Sub for &Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Sub<Sprs<T>> for &Sprs<T> {
+impl<T: Numeric<T>> Sub<Sprs<T>> for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `-` operator.
@@ -606,7 +604,7 @@ impl<T: Numeric<T>> std::ops::Sub<Sprs<T>> for &Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Mul for Sprs<T> {
+impl<T: Numeric<T>> Mul for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `*` operator. Multiplies two sparse matrices
@@ -616,7 +614,7 @@ impl<T: Numeric<T>> std::ops::Mul for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Mul<&Sprs<T>> for Sprs<T> {
+impl<T: Numeric<T>> Mul<&Sprs<T>> for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `*` operator.
@@ -626,7 +624,7 @@ impl<T: Numeric<T>> std::ops::Mul<&Sprs<T>> for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Mul for &Sprs<T> {
+impl<T: Numeric<T>> Mul for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `*` operator. Multiplies two references to sparse matrices
@@ -636,7 +634,7 @@ impl<T: Numeric<T>> std::ops::Mul for &Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Mul<Sprs<T>> for &Sprs<T> {
+impl<T: Numeric<T>> Mul<Sprs<T>> for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `*` operator.
@@ -648,7 +646,7 @@ impl<T: Numeric<T>> std::ops::Mul<Sprs<T>> for &Sprs<T> {
 
 // Implementing operators for `Sprs` and `T` types
 
-impl<T: Numeric<T>> std::ops::Add<T> for Sprs<T> {
+impl<T: Numeric<T>> Add<T> for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `+` operator. Adds an `T` value to all elements of a
@@ -659,7 +657,7 @@ impl<T: Numeric<T>> std::ops::Add<T> for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Add<T> for &Sprs<T> {
+impl<T: Numeric<T>> Add<T> for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `+` operator. Adds an `T` value to all elements of a
@@ -670,7 +668,7 @@ impl<T: Numeric<T>> std::ops::Add<T> for &Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Sub<T> for Sprs<T> {
+impl<T: Numeric<T>> Sub<T> for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `-` operator. Subtracts an `T` value to all elements of
@@ -681,7 +679,7 @@ impl<T: Numeric<T>> std::ops::Sub<T> for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Sub<T> for &Sprs<T> {
+impl<T: Numeric<T>> Sub<T> for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `-` operator. Subtracts an `T` value to all elements of
@@ -692,7 +690,7 @@ impl<T: Numeric<T>> std::ops::Sub<T> for &Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Mul<T> for Sprs<T> {
+impl<T: Numeric<T>> Mul<T> for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `*` operator. Multiplies an `T` value to all elements of
@@ -703,7 +701,7 @@ impl<T: Numeric<T>> std::ops::Mul<T> for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Mul<T> for &Sprs<T> {
+impl<T: Numeric<T>> Mul<T> for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `*` operator. Multiplies an `T` value to all elements of
@@ -714,7 +712,7 @@ impl<T: Numeric<T>> std::ops::Mul<T> for &Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Div<T> for Sprs<T> {
+impl<T: Numeric<T>> Div<T> for Sprs<T> {
     type Output = Self;
 
     /// Overloads the `/` operator. Divides by an `T` value to all elements of
@@ -725,7 +723,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for Sprs<T> {
     }
 }
 
-impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {
+impl<T: Numeric<T>> Div<T> for &Sprs<T> {
     type Output = Sprs<T>;
 
     /// Overloads the `/` operator. Divides by an `T` value to all elements of
@@ -738,7 +736,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {
 
 // Implementing operators for `T` and `Sprs<T>` types
 
-// impl <T: Numeric<T>> std::ops::Add<Sprs<T>> for T {
+// impl <T: Numeric<T>> Add<Sprs<T>> for T {
 //     type Output = Sprs<T>;
 
 //     /// Overloads the `+` operator. Adds an `T` value to all elements of a
@@ -749,7 +747,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {
 //     }
 // }
 
-// impl <T: Numeric<T>> std::ops::Add<&Sprs<T>> for T {
+// impl <T: Numeric<T>> Add<&Sprs<T>> for T {
 //     type Output = Sprs<T>;
 
 //     /// Overloads the `+` operator. Adds an `T` value to all elements of a
@@ -760,7 +758,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {
 //     }
 // }
 
-// impl <T: Numeric<T>> std::ops::Sub<Sprs<T>> for T {
+// impl <T: Numeric<T>> Sub<Sprs<T>> for T {
 //     type Output = Sprs<T>;
 
 //     /// Overloads the `-` operator. Subtracts an `T` value to all elements of
@@ -771,7 +769,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {
 //     }
 // }
 
-// impl <T: Numeric<T>> std::ops::Sub<&Sprs<T>> for T {
+// impl <T: Numeric<T>> Sub<&Sprs<T>> for T {
 //     type Output = Sprs<T>;
 
 //     /// Overloads the `-` operator. Subtracts an `T` value to all elements of
@@ -782,7 +780,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {
 //     }
 // }
 
-// impl <T: Numeric<T>> std::ops::Mul<Sprs<T>> for T {
+// impl <T: Numeric<T>> Mul<Sprs<T>> for T {
 //     type Output = Sprs<T>;
 
 //     /// Overloads the `*` operator. Multiplies an `T` value to all elements of
@@ -793,7 +791,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {
 //     }
 // }
 
-// impl <T: Numeric<T>> std::ops::Mul<&Sprs<T>> for T {
+// impl <T: Numeric<T>> Mul<&Sprs<T>> for T {
 //     type Output = Sprs<T>;
 
 //     /// Overloads the `*` operator. Multiplies an `T` value to all elements of

Original file line number	Diff line number	Diff line change
`@@ -1,11 +1,9 @@`
`1`	`1`	`//! Data structures for rsparse`
`2`		`-//!`
`3`	`2`
`4`	`3`	`use crate::{add, multiply, scpmat, scxmat};`
`5`	`4`	`use std::fmt;`
`6`	`5`	`use std::fs::File;`
`7`		`-use std::io::Write;`
`8`		`-use std::io::{BufRead, BufReader};`
	`6`	`+use std::io::{BufRead, BufReader, Write};`
`9`	`7`	`use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Neg, Sub, SubAssign};`
`10`	`8`
`11`	`9`	// Define a generic Numeric trait compatible with `Sprs` matrices
`@@ -120,14 +118,14 @@ pub trait Numeric<F>:`
`120`	`118`	`+ Default`
`121`	`119`	`+ Zero`
`122`	`120`	`+ One`
	`121`	`+ + Add<Output = F>`
	`122`	`+ + Sub<Output = F>`
	`123`	`+ + Mul<Output = F>`
	`124`	`+ + Div<Output = F>`
	`125`	`+ + Neg<Output = F>`
	`126`	`+ + std::iter::Sum`
`123`	`127`	`+ fmt::Display`
`124`	`128`	`+ fmt::Debug`
`125`		`- + std::ops::Add<Output = F>`
`126`		`- + std::ops::Sub<Output = F>`
`127`		`- + std::ops::Mul<Output = F>`
`128`		`- + std::ops::Div<Output = F>`
`129`		`- + std::ops::Neg<Output = F>`
`130`		`- + std::iter::Sum`
`131`	`129`	`+ From<F>`
`132`	`130`	`{`
`133`	`131`	`fn abs(self) -> F;`
`@@ -526,7 +524,7 @@ impl<T: Numeric<T>> Default for Sprs<T> {`
`526`	`524`
`527`	`525`	// Implementing operators for `Sprs`
`528`	`526`
`529`		`-impl<T: Numeric<T>> std::ops::Add for Sprs<T> {`
	`527`	`+impl<T: Numeric<T>> Add for Sprs<T> {`
`530`	`528`	`type Output = Self;`
`531`	`529`
`532`	`530`	/// Overloads the `+` operator. Adds two sparse matrices
`@@ -536,7 +534,7 @@ impl<T: Numeric<T>> std::ops::Add for Sprs<T> {`
`536`	`534`	`}`
`537`	`535`	`}`
`538`	`536`
`539`		`-impl<T: Numeric<T>> std::ops::Add<&Sprs<T>> for Sprs<T> {`
	`537`	`+impl<T: Numeric<T>> Add<&Sprs<T>> for Sprs<T> {`
`540`	`538`	`type Output = Self;`
`541`	`539`
`542`	`540`	/// Overloads the `+` operator.
`@@ -546,7 +544,7 @@ impl<T: Numeric<T>> std::ops::Add<&Sprs<T>> for Sprs<T> {`
`546`	`544`	`}`
`547`	`545`	`}`
`548`	`546`
`549`		`-impl<T: Numeric<T>> std::ops::Add for &Sprs<T> {`
	`547`	`+impl<T: Numeric<T>> Add for &Sprs<T> {`
`550`	`548`	`type Output = Sprs<T>;`
`551`	`549`
`552`	`550`	/// Overloads the `+` operator. Adds two references to sparse matrices
`@@ -556,7 +554,7 @@ impl<T: Numeric<T>> std::ops::Add for &Sprs<T> {`
`556`	`554`	`}`
`557`	`555`	`}`
`558`	`556`
`559`		`-impl<T: Numeric<T>> std::ops::Add<Sprs<T>> for &Sprs<T> {`
	`557`	`+impl<T: Numeric<T>> Add<Sprs<T>> for &Sprs<T> {`
`560`	`558`	`type Output = Sprs<T>;`
`561`	`559`
`562`	`560`	/// Overloads the `+` operator.
`@@ -566,7 +564,7 @@ impl<T: Numeric<T>> std::ops::Add<Sprs<T>> for &Sprs<T> {`
`566`	`564`	`}`
`567`	`565`	`}`
`568`	`566`
`569`		`-impl<T: Numeric<T>> std::ops::Sub for Sprs<T> {`
	`567`	`+impl<T: Numeric<T>> Sub for Sprs<T> {`
`570`	`568`	`type Output = Self;`
`571`	`569`
`572`	`570`	/// Overloads the `-` operator. Subtracts two sparse matrices
`@@ -576,7 +574,7 @@ impl<T: Numeric<T>> std::ops::Sub for Sprs<T> {`
`576`	`574`	`}`
`577`	`575`	`}`
`578`	`576`
`579`		`-impl<T: Numeric<T>> std::ops::Sub<&Sprs<T>> for Sprs<T> {`
	`577`	`+impl<T: Numeric<T>> Sub<&Sprs<T>> for Sprs<T> {`
`580`	`578`	`type Output = Self;`
`581`	`579`
`582`	`580`	/// Overloads the `-` operator.
`@@ -586,7 +584,7 @@ impl<T: Numeric<T>> std::ops::Sub<&Sprs<T>> for Sprs<T> {`
`586`	`584`	`}`
`587`	`585`	`}`
`588`	`586`
`589`		`-impl<T: Numeric<T>> std::ops::Sub for &Sprs<T> {`
	`587`	`+impl<T: Numeric<T>> Sub for &Sprs<T> {`
`590`	`588`	`type Output = Sprs<T>;`
`591`	`589`
`592`	`590`	/// Overloads the `-` operator. Subtracts two references to sparse matrices
`@@ -596,7 +594,7 @@ impl<T: Numeric<T>> std::ops::Sub for &Sprs<T> {`
`596`	`594`	`}`
`597`	`595`	`}`
`598`	`596`
`599`		`-impl<T: Numeric<T>> std::ops::Sub<Sprs<T>> for &Sprs<T> {`
	`597`	`+impl<T: Numeric<T>> Sub<Sprs<T>> for &Sprs<T> {`
`600`	`598`	`type Output = Sprs<T>;`
`601`	`599`
`602`	`600`	/// Overloads the `-` operator.
`@@ -606,7 +604,7 @@ impl<T: Numeric<T>> std::ops::Sub<Sprs<T>> for &Sprs<T> {`
`606`	`604`	`}`
`607`	`605`	`}`
`608`	`606`
`609`		`-impl<T: Numeric<T>> std::ops::Mul for Sprs<T> {`
	`607`	`+impl<T: Numeric<T>> Mul for Sprs<T> {`
`610`	`608`	`type Output = Self;`
`611`	`609`
`612`	`610`	/// Overloads the `*` operator. Multiplies two sparse matrices
`@@ -616,7 +614,7 @@ impl<T: Numeric<T>> std::ops::Mul for Sprs<T> {`
`616`	`614`	`}`
`617`	`615`	`}`
`618`	`616`
`619`		`-impl<T: Numeric<T>> std::ops::Mul<&Sprs<T>> for Sprs<T> {`
	`617`	`+impl<T: Numeric<T>> Mul<&Sprs<T>> for Sprs<T> {`
`620`	`618`	`type Output = Self;`
`621`	`619`
`622`	`620`	/// Overloads the `*` operator.
`@@ -626,7 +624,7 @@ impl<T: Numeric<T>> std::ops::Mul<&Sprs<T>> for Sprs<T> {`
`626`	`624`	`}`
`627`	`625`	`}`
`628`	`626`
`629`		`-impl<T: Numeric<T>> std::ops::Mul for &Sprs<T> {`
	`627`	`+impl<T: Numeric<T>> Mul for &Sprs<T> {`
`630`	`628`	`type Output = Sprs<T>;`
`631`	`629`
`632`	`630`	/// Overloads the `*` operator. Multiplies two references to sparse matrices
`@@ -636,7 +634,7 @@ impl<T: Numeric<T>> std::ops::Mul for &Sprs<T> {`
`636`	`634`	`}`
`637`	`635`	`}`
`638`	`636`
`639`		`-impl<T: Numeric<T>> std::ops::Mul<Sprs<T>> for &Sprs<T> {`
	`637`	`+impl<T: Numeric<T>> Mul<Sprs<T>> for &Sprs<T> {`
`640`	`638`	`type Output = Sprs<T>;`
`641`	`639`
`642`	`640`	/// Overloads the `*` operator.
`@@ -648,7 +646,7 @@ impl<T: Numeric<T>> std::ops::Mul<Sprs<T>> for &Sprs<T> {`
`648`	`646`
`649`	`647`	// Implementing operators for `Sprs` and `T` types
`650`	`648`
`651`		`-impl<T: Numeric<T>> std::ops::Add<T> for Sprs<T> {`
	`649`	`+impl<T: Numeric<T>> Add<T> for Sprs<T> {`
`652`	`650`	`type Output = Self;`
`653`	`651`
`654`	`652`	/// Overloads the `+` operator. Adds an `T` value to all elements of a
`@@ -659,7 +657,7 @@ impl<T: Numeric<T>> std::ops::Add<T> for Sprs<T> {`
`659`	`657`	`}`
`660`	`658`	`}`
`661`	`659`
`662`		`-impl<T: Numeric<T>> std::ops::Add<T> for &Sprs<T> {`
	`660`	`+impl<T: Numeric<T>> Add<T> for &Sprs<T> {`
`663`	`661`	`type Output = Sprs<T>;`
`664`	`662`
`665`	`663`	/// Overloads the `+` operator. Adds an `T` value to all elements of a
`@@ -670,7 +668,7 @@ impl<T: Numeric<T>> std::ops::Add<T> for &Sprs<T> {`
`670`	`668`	`}`
`671`	`669`	`}`
`672`	`670`
`673`		`-impl<T: Numeric<T>> std::ops::Sub<T> for Sprs<T> {`
	`671`	`+impl<T: Numeric<T>> Sub<T> for Sprs<T> {`
`674`	`672`	`type Output = Self;`
`675`	`673`
`676`	`674`	/// Overloads the `-` operator. Subtracts an `T` value to all elements of
`@@ -681,7 +679,7 @@ impl<T: Numeric<T>> std::ops::Sub<T> for Sprs<T> {`
`681`	`679`	`}`
`682`	`680`	`}`
`683`	`681`
`684`		`-impl<T: Numeric<T>> std::ops::Sub<T> for &Sprs<T> {`
	`682`	`+impl<T: Numeric<T>> Sub<T> for &Sprs<T> {`
`685`	`683`	`type Output = Sprs<T>;`
`686`	`684`
`687`	`685`	/// Overloads the `-` operator. Subtracts an `T` value to all elements of
`@@ -692,7 +690,7 @@ impl<T: Numeric<T>> std::ops::Sub<T> for &Sprs<T> {`
`692`	`690`	`}`
`693`	`691`	`}`
`694`	`692`
`695`		`-impl<T: Numeric<T>> std::ops::Mul<T> for Sprs<T> {`
	`693`	`+impl<T: Numeric<T>> Mul<T> for Sprs<T> {`
`696`	`694`	`type Output = Self;`
`697`	`695`
`698`	`696`	/// Overloads the `*` operator. Multiplies an `T` value to all elements of
`@@ -703,7 +701,7 @@ impl<T: Numeric<T>> std::ops::Mul<T> for Sprs<T> {`
`703`	`701`	`}`
`704`	`702`	`}`
`705`	`703`
`706`		`-impl<T: Numeric<T>> std::ops::Mul<T> for &Sprs<T> {`
	`704`	`+impl<T: Numeric<T>> Mul<T> for &Sprs<T> {`
`707`	`705`	`type Output = Sprs<T>;`
`708`	`706`
`709`	`707`	/// Overloads the `*` operator. Multiplies an `T` value to all elements of
`@@ -714,7 +712,7 @@ impl<T: Numeric<T>> std::ops::Mul<T> for &Sprs<T> {`
`714`	`712`	`}`
`715`	`713`	`}`
`716`	`714`
`717`		`-impl<T: Numeric<T>> std::ops::Div<T> for Sprs<T> {`
	`715`	`+impl<T: Numeric<T>> Div<T> for Sprs<T> {`
`718`	`716`	`type Output = Self;`
`719`	`717`
`720`	`718`	/// Overloads the `/` operator. Divides by an `T` value to all elements of
`@@ -725,7 +723,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for Sprs<T> {`
`725`	`723`	`}`
`726`	`724`	`}`
`727`	`725`
`728`		`-impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {`
	`726`	`+impl<T: Numeric<T>> Div<T> for &Sprs<T> {`
`729`	`727`	`type Output = Sprs<T>;`
`730`	`728`
`731`	`729`	/// Overloads the `/` operator. Divides by an `T` value to all elements of
`@@ -738,7 +736,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {`
`738`	`736`
`739`	`737`	// Implementing operators for `T` and `Sprs<T>` types
`740`	`738`
`741`		`-// impl <T: Numeric<T>> std::ops::Add<Sprs<T>> for T {`
	`739`	`+// impl <T: Numeric<T>> Add<Sprs<T>> for T {`
`742`	`740`	`// type Output = Sprs<T>;`
`743`	`741`
`744`	`742`	// /// Overloads the `+` operator. Adds an `T` value to all elements of a
`@@ -749,7 +747,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {`
`749`	`747`	`// }`
`750`	`748`	`// }`
`751`	`749`
`752`		`-// impl <T: Numeric<T>> std::ops::Add<&Sprs<T>> for T {`
	`750`	`+// impl <T: Numeric<T>> Add<&Sprs<T>> for T {`
`753`	`751`	`// type Output = Sprs<T>;`
`754`	`752`
`755`	`753`	// /// Overloads the `+` operator. Adds an `T` value to all elements of a
`@@ -760,7 +758,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {`
`760`	`758`	`// }`
`761`	`759`	`// }`
`762`	`760`
`763`		`-// impl <T: Numeric<T>> std::ops::Sub<Sprs<T>> for T {`
	`761`	`+// impl <T: Numeric<T>> Sub<Sprs<T>> for T {`
`764`	`762`	`// type Output = Sprs<T>;`
`765`	`763`
`766`	`764`	// /// Overloads the `-` operator. Subtracts an `T` value to all elements of
`@@ -771,7 +769,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {`
`771`	`769`	`// }`
`772`	`770`	`// }`
`773`	`771`
`774`		`-// impl <T: Numeric<T>> std::ops::Sub<&Sprs<T>> for T {`
	`772`	`+// impl <T: Numeric<T>> Sub<&Sprs<T>> for T {`
`775`	`773`	`// type Output = Sprs<T>;`
`776`	`774`
`777`	`775`	// /// Overloads the `-` operator. Subtracts an `T` value to all elements of
`@@ -782,7 +780,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {`
`782`	`780`	`// }`
`783`	`781`	`// }`
`784`	`782`
`785`		`-// impl <T: Numeric<T>> std::ops::Mul<Sprs<T>> for T {`
	`783`	`+// impl <T: Numeric<T>> Mul<Sprs<T>> for T {`
`786`	`784`	`// type Output = Sprs<T>;`
`787`	`785`
`788`	`786`	// /// Overloads the `*` operator. Multiplies an `T` value to all elements of
`@@ -793,7 +791,7 @@ impl<T: Numeric<T>> std::ops::Div<T> for &Sprs<T> {`
`793`	`791`	`// }`
`794`	`792`	`// }`
`795`	`793`
`796`		`-// impl <T: Numeric<T>> std::ops::Mul<&Sprs<T>> for T {`
	`794`	`+// impl <T: Numeric<T>> Mul<&Sprs<T>> for T {`
`797`	`795`	`// type Output = Sprs<T>;`
`798`	`796`
`799`	`797`	// /// Overloads the `*` operator. Multiplies an `T` value to all elements of