From: Mikko Rasa <tdb@tdb.fi>
Date: Sat, 15 Oct 2022 10:38:19 +0000 (+0300)
Subject: Don't use references to angles
X-Git-Url: https://git.tdb.fi/?a=commitdiff_plain;h=7bf588b92f7ee6c6253e155755d9373ac0f6748a;p=libs%2Fmath.git

Don't use references to angles

It holds a single scalar and is trivial to copy, so can be passed in a
register.
---

diff --git a/source/geometry/affinetransform.h b/source/geometry/affinetransform.h
index 1cd4011..1d48a5d 100644
--- a/source/geometry/affinetransform.h
+++ b/source/geometry/affinetransform.h
@@ -30,7 +30,7 @@ protected:
 	AffineTransformOps() { }
 
 public:
-	static AffineTransform<T, 2> rotation(const Angle<T> &);
+	static AffineTransform<T, 2> rotation(Angle<T>);
 };
 
 template<typename T>
@@ -40,7 +40,7 @@ protected:
 	AffineTransformOps() { }
 
 public:
-	static AffineTransform<T, 3> rotation(const Angle<T> &, const LinAl::Vector<T, 3> &);
+	static AffineTransform<T, 3> rotation(Angle<T>, const LinAl::Vector<T, 3> &);
 };
 
 
@@ -112,7 +112,7 @@ AffineTransform<T, D> AffineTransform<T, D>::shear(const LinAl::Vector<T, D> &no
 }
 
 template<typename T>
-AffineTransform<T, 2> AffineTransformOps<T, 2>::rotation(const Angle<T> &angle)
+AffineTransform<T, 2> AffineTransformOps<T, 2>::rotation(Angle<T> angle)
 {
 	AffineTransform<T, 2> r;
 	T c = cos(angle);
@@ -125,7 +125,7 @@ AffineTransform<T, 2> AffineTransformOps<T, 2>::rotation(const Angle<T> &angle)
 }
 
 template<typename T>
-AffineTransform<T, 3> AffineTransformOps<T, 3>::rotation(const Angle<T> &angle, const LinAl::Vector<T, 3> &axis)
+AffineTransform<T, 3> AffineTransformOps<T, 3>::rotation(Angle<T> angle, const LinAl::Vector<T, 3> &axis)
 {
 	AffineTransform<T, 3> r;
 	LinAl::Vector<T, 3> axn = normalize(axis);
diff --git a/source/geometry/angle.h b/source/geometry/angle.h
index fe4895c..bcd7cca 100644
--- a/source/geometry/angle.h
+++ b/source/geometry/angle.h
@@ -20,7 +20,7 @@ private:
 public:
 	Angle(): value(0) { }
 	template<typename U>
-	Angle(const Angle<U> &other): value(other.radians()) { }
+	Angle(Angle<U> other): value(other.radians()) { }
 
 	static Angle from_degrees(T);
 	static Angle from_radians(T);
@@ -37,19 +37,19 @@ public:
 	T radians() const { return value; }
 	T turns() const { return value/6.28318530717958647692; }
 
-	Angle &operator+=(const Angle &);
-	Angle &operator-=(const Angle &);
+	Angle &operator+=(Angle);
+	Angle &operator-=(Angle);
 	Angle &operator*=(T);
 	Angle &operator/=(T);
 
-	bool operator==(const Angle &other) const { return value==other.value; }
-	bool operator!=(const Angle &other) const { return value!=other.value; }
-	bool operator<(const Angle &other) const { return value<other.value; }
-	bool operator<=(const Angle &other) const { return value<=other.value; }
-	bool operator>(const Angle &other) const { return value>other.value; }
-	bool operator>=(const Angle &other) const { return value>=other.value; }
+	bool operator==(Angle other) const { return value==other.value; }
+	bool operator!=(Angle other) const { return value!=other.value; }
+	bool operator<(Angle other) const { return value<other.value; }
+	bool operator<=(Angle other) const { return value<=other.value; }
+	bool operator>(Angle other) const { return value>other.value; }
+	bool operator>=(Angle other) const { return value>=other.value; }
 
-	Angle &wrap_with_base(const Angle &);
+	Angle &wrap_with_base(Angle);
 	Angle &wrap_positive();
 	Angle &wrap_balanced();
 };
@@ -73,35 +73,35 @@ inline Angle<T> Angle<T>::from_turns(T t)
 }
 
 template<typename T>
-inline Angle<T> &Angle<T>::operator+=(const Angle &a)
+inline Angle<T> &Angle<T>::operator+=(Angle a)
 {
 	value += a.value;
 	return *this;
 }
 
 template<typename T>
-inline Angle<T> operator+(const Angle<T> &a1, const Angle<T> &a2)
+inline Angle<T> operator+(Angle<T> a1, Angle<T> a2)
 {
 	Angle<T> r(a1);
 	return r += a2;
 }
 
 template<typename T>
-inline Angle<T> &Angle<T>::operator-=(const Angle &a)
+inline Angle<T> &Angle<T>::operator-=(Angle a)
 {
 	value -= a.value;
 	return *this;
 }
 
 template<typename T>
-inline Angle<T> operator-(const Angle<T> &a1, const Angle<T> &a2)
+inline Angle<T> operator-(Angle<T> a1, Angle<T> a2)
 {
 	Angle<T> r(a1);
 	return r -= a2;
 }
 
 template<typename T>
-inline Angle<T> operator-(const Angle<T> &a)
+inline Angle<T> operator-(Angle<T> a)
 {
 	return Angle<T>::zero()-a;
 }
@@ -114,14 +114,14 @@ inline Angle<T> &Angle<T>::operator*=(T s)
 }
 
 template<typename T>
-inline Angle<T> operator*(const Angle<T> &a, T s)
+inline Angle<T> operator*(Angle<T> a, T s)
 {
 	Angle<T> r(a);
 	return r *= s;
 }
 
 template<typename T>
-inline Angle<T> operator*(T s, const Angle<T> &a)
+inline Angle<T> operator*(T s, Angle<T> a)
 {
 	return a*s;
 }
@@ -134,26 +134,26 @@ inline Angle<T> &Angle<T>::operator/=(T s)
 }
 
 template<typename T>
-inline Angle<T> operator/(const Angle<T> &a, T s)
+inline Angle<T> operator/(Angle<T> a, T s)
 {
 	Angle<T> r(a);
 	return r /= s;
 }
 
 template<typename T>
-inline Angle<T> operator/(T s, const Angle<T> &a)
+inline Angle<T> operator/(T s, Angle<T> a)
 {
 	return a/s;
 }
 
 template<typename T>
-inline T operator/(const Angle<T> &a1, const Angle<T> &a2)
+inline T operator/(Angle<T> a1, Angle<T> a2)
 {
 	return a1.radians()/a2.radians();
 }
 
 template<typename T>
-inline Angle<T> &Angle<T>::wrap_with_base(const Angle<T> &b)
+inline Angle<T> &Angle<T>::wrap_with_base(Angle<T> b)
 {
 	const T two_pi = 6.28318530717958647692;
 	while(value<b.value)
@@ -176,35 +176,35 @@ inline Angle<T> &Angle<T>::wrap_balanced()
 }
 
 template<typename T>
-inline Angle<T> wrap_with_base(const Angle<T> &a, const Angle<T> &b)
+inline Angle<T> wrap_with_base(Angle<T> a, Angle<T> b)
 {
 	Angle<T> r = a;
 	return r.wrap_with_base(b);
 }
 
 template<typename T>
-inline Angle<T> wrap_positive(const Angle<T> &a)
+inline Angle<T> wrap_positive(Angle<T> a)
 {
 	Angle<T> r = a;
 	return r.wrap_positive();
 }
 
 template<typename T>
-inline Angle<T> wrap_balanced(const Angle<T> &a)
+inline Angle<T> wrap_balanced(Angle<T> a)
 {
 	Angle<T> r = a;
 	return r.wrap_balanced();
 }
 
 template<typename T>
-inline Angle<T> abs(const Angle<T> &angle)
+inline Angle<T> abs(Angle<T> angle)
 {
 	using std::abs;
 	return Angle<T>::from_radians(abs(angle.radians()));
 }
 
 template<typename T>
-inline T sin(const Angle<T> &angle)
+inline T sin(Angle<T> angle)
 {
 	using std::sin;
 	return sin(angle.radians());
@@ -218,7 +218,7 @@ inline Angle<T> asin(T s)
 }
 
 template<typename T>
-inline T cos(const Angle<T> &angle)
+inline T cos(Angle<T> angle)
 {
 	using std::cos;
 	return cos(angle.radians());
@@ -232,7 +232,7 @@ inline Angle<T> acos(T s)
 }
 
 template<typename T>
-inline T tan(const Angle<T> &angle)
+inline T tan(Angle<T> angle)
 {
 	using std::tan;
 	return tan(angle.radians());