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 1cd40119a04d8c211c1313486641b1320990e0b2..1d48a5d84f0396b7538ff7b0c569864b798d41fd 100644 (file)
--- 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 fe4895cfe7635ebe85e58e83b353b81dc2561208..bcd7ccad72985ec1dc65208094299e65c9fc44e5 100644 (file)
--- 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());