hodasemi/cgmath
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge pull request #548 from gents83/master

Browse source 
Fixing clippy warnings
This commit is contained in:
aloucks 2022-04-16 13:32:31 -04:00 committed by GitHub
commit d5e765db61
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 20 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

16
src/macros.rs
View file

@ -24,7 +24,10 @@ macro_rules! default_fn {
#[cfg(not(feature = "simd"))] #[cfg(not(feature = "simd"))]
macro_rules! default_fn { macro_rules! default_fn {
{ $($tt:tt)* } => { fn $( $tt )* }; { $($tt:tt)* } => {
#[inline]
fn $( $tt )*
};
} }
/// Generates a binary operator implementation for the permutations of by-ref and by-val /// Generates a binary operator implementation for the permutations of by-ref and by-val
@ -35,7 +38,6 @@ macro_rules! impl_operator {
}) => { }) => {
impl<$S: $Constraint> $Op for $Lhs { impl<$S: $Constraint> $Op for $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!($op(self) -> $Output { default_fn!($op(self) -> $Output {
let $x = self; $body let $x = self; $body
}); });
@ -43,7 +45,6 @@ macro_rules! impl_operator {
impl<'a, $S: $Constraint> $Op for &'a $Lhs { impl<'a, $S: $Constraint> $Op for &'a $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!($op(self) -> $Output { default_fn!($op(self) -> $Output {
let $x = self; $body let $x = self; $body
}); });
@ -55,7 +56,6 @@ macro_rules! impl_operator {
}) => { }) => {
impl<$S: $Constraint> $Op<$Rhs> for $Lhs { impl<$S: $Constraint> $Op<$Rhs> for $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!($op(self, other: $Rhs) -> $Output { default_fn!($op(self, other: $Rhs) -> $Output {
let ($lhs, $rhs) = (self, other); $body let ($lhs, $rhs) = (self, other); $body
}); });
@ -63,7 +63,6 @@ macro_rules! impl_operator {
impl<'a, $S: $Constraint> $Op<$Rhs> for &'a $Lhs { impl<'a, $S: $Constraint> $Op<$Rhs> for &'a $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!($op(self, other: $Rhs) -> $Output { default_fn!($op(self, other: $Rhs) -> $Output {
let ($lhs, $rhs) = (self, other); $body let ($lhs, $rhs) = (self, other); $body
}); });
@ -75,7 +74,6 @@ macro_rules! impl_operator {
}) => { }) => {
impl<$S: $Constraint> $Op<$Rhs> for $Lhs { impl<$S: $Constraint> $Op<$Rhs> for $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!( $op(self, other: $Rhs) -> $Output { default_fn!( $op(self, other: $Rhs) -> $Output {
let ($lhs, $rhs) = (self, other); $body let ($lhs, $rhs) = (self, other); $body
}); });
@ -83,7 +81,6 @@ macro_rules! impl_operator {
impl<'a, $S: $Constraint> $Op<&'a $Rhs> for $Lhs { impl<'a, $S: $Constraint> $Op<&'a $Rhs> for $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!( $op(self, other: &'a $Rhs) -> $Output { default_fn!( $op(self, other: &'a $Rhs) -> $Output {
let ($lhs, $rhs) = (self, other); $body let ($lhs, $rhs) = (self, other); $body
}); });
@ -91,7 +88,6 @@ macro_rules! impl_operator {
impl<'a, $S: $Constraint> $Op<$Rhs> for &'a $Lhs { impl<'a, $S: $Constraint> $Op<$Rhs> for &'a $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!( $op(self, other: $Rhs) -> $Output { default_fn!( $op(self, other: $Rhs) -> $Output {
let ($lhs, $rhs) = (self, other); $body let ($lhs, $rhs) = (self, other); $body
}); });
@ -99,7 +95,6 @@ macro_rules! impl_operator {
impl<'a, 'b, $S: $Constraint> $Op<&'a $Rhs> for &'b $Lhs { impl<'a, 'b, $S: $Constraint> $Op<&'a $Rhs> for &'b $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!( $op(self, other: &'a $Rhs) -> $Output { default_fn!( $op(self, other: &'a $Rhs) -> $Output {
let ($lhs, $rhs) = (self, other); $body let ($lhs, $rhs) = (self, other); $body
}); });
@ -111,7 +106,6 @@ macro_rules! impl_operator {
}) => { }) => {
impl $Op<$Rhs<$S>> for $Lhs { impl $Op<$Rhs<$S>> for $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!( $op(self, other: $Rhs<$S>) -> $Output { default_fn!( $op(self, other: $Rhs<$S>) -> $Output {
let ($lhs, $rhs) = (self, other); $body let ($lhs, $rhs) = (self, other); $body
}); });
@ -119,7 +113,6 @@ macro_rules! impl_operator {
impl<'a> $Op<&'a $Rhs<$S>> for $Lhs { impl<'a> $Op<&'a $Rhs<$S>> for $Lhs {
type Output = $Output; type Output = $Output;
#[inline]
default_fn!( $op(self, other: &'a $Rhs<$S>) -> $Output { default_fn!( $op(self, other: &'a $Rhs<$S>) -> $Output {
let ($lhs, $rhs) = (self, other); $body let ($lhs, $rhs) = (self, other); $body
}); });
@ -132,7 +125,6 @@ macro_rules! impl_assignment_operator {
fn $op:ident(&mut $lhs:ident, $rhs:ident) $body:block fn $op:ident(&mut $lhs:ident, $rhs:ident) $body:block
}) => { }) => {
impl<$S: $Constraint + $Op<$S>> $Op<$Rhs> for $Lhs { impl<$S: $Constraint + $Op<$S>> $Op<$Rhs> for $Lhs {
#[inline]
default_fn!( $op(&mut $lhs, $rhs: $Rhs) $body ); default_fn!( $op(&mut $lhs, $rhs: $Rhs) $body );
} }
}; };

1
src/quaternion.rs
View file

@ -238,7 +238,6 @@ impl<S: NumCast + Copy> Quaternion<S> {
} }
impl<S: BaseFloat> InnerSpace for Quaternion<S> { impl<S: BaseFloat> InnerSpace for Quaternion<S> {
#[inline]
default_fn!( dot(self, other: Quaternion<S>) -> S { default_fn!( dot(self, other: Quaternion<S>) -> S {
self.s * other.s + self.v.dot(other.v) self.s * other.s + self.v.dot(other.v)
} ); } );

33
src/vector.rs
View file

@ -209,7 +209,6 @@ macro_rules! impl_vector {
impl<S: Neg<Output = S>> Neg for $VectorN<S> { impl<S: Neg<Output = S>> Neg for $VectorN<S> {
type Output = $VectorN<S>; type Output = $VectorN<S>;
#[inline]
default_fn!( neg(self) -> $VectorN<S> { $VectorN::new($(-self.$field),+) } ); default_fn!( neg(self) -> $VectorN<S> { $VectorN::new($(-self.$field),+) } );
} }
@ -309,30 +308,30 @@ macro_rules! impl_vector {
}); });
impl<S: BaseNum> ElementWise for $VectorN<S> { impl<S: BaseNum> ElementWise for $VectorN<S> {
#[inline] default_fn!( add_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field + rhs.$field),+) } ); default_fn!( add_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field + rhs.$field),+) } );
#[inline] default_fn!( sub_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field - rhs.$field),+) } ); default_fn!( sub_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field - rhs.$field),+) } );
#[inline] default_fn!( mul_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field * rhs.$field),+) } ); default_fn!( mul_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field * rhs.$field),+) } );
#[inline] default_fn!( div_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field / rhs.$field),+) } ); default_fn!( div_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field / rhs.$field),+) } );
#[inline] fn rem_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field % rhs.$field),+) } #[inline] fn rem_element_wise(self, rhs: $VectorN<S>) -> $VectorN<S> { $VectorN::new($(self.$field % rhs.$field),+) }
#[inline] default_fn!( add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ } ); default_fn!( add_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field += rhs.$field);+ } );
#[inline] default_fn!( sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ } ); default_fn!( sub_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field -= rhs.$field);+ } );
#[inline] default_fn!( mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ } ); default_fn!( mul_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field *= rhs.$field);+ } );
#[inline] default_fn!( div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ } ); default_fn!( div_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field /= rhs.$field);+ } );
#[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ } #[inline] fn rem_assign_element_wise(&mut self, rhs: $VectorN<S>) { $(self.$field %= rhs.$field);+ }
} }
impl<S: BaseNum> ElementWise<S> for $VectorN<S> { impl<S: BaseNum> ElementWise<S> for $VectorN<S> {
#[inline] default_fn!( add_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field + rhs),+) } ); default_fn!( add_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field + rhs),+) } );
#[inline] default_fn!( sub_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field - rhs),+) } ); default_fn!( sub_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field - rhs),+) } );
#[inline] default_fn!( mul_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field * rhs),+) } ); default_fn!( mul_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field * rhs),+) } );
#[inline] default_fn!( div_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field / rhs),+) } ); default_fn!( div_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field / rhs),+) } );
#[inline] fn rem_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field % rhs),+) } #[inline] fn rem_element_wise(self, rhs: S) -> $VectorN<S> { $VectorN::new($(self.$field % rhs),+) }
#[inline] default_fn!( add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ } ); default_fn!( add_assign_element_wise(&mut self, rhs: S) { $(self.$field += rhs);+ } );
#[inline] default_fn!( sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ } ); default_fn!( sub_assign_element_wise(&mut self, rhs: S) { $(self.$field -= rhs);+ } );
#[inline] default_fn!( mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ } ); default_fn!( mul_assign_element_wise(&mut self, rhs: S) { $(self.$field *= rhs);+ } );
#[inline] default_fn!( div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ } ); default_fn!( div_assign_element_wise(&mut self, rhs: S) { $(self.$field /= rhs);+ } );
#[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ } #[inline] fn rem_assign_element_wise(&mut self, rhs: S) { $(self.$field %= rhs);+ }
} }