diff --git a/doc/types.dox b/doc/types.dox
index bce7c53ef..f0a721938 100644
--- a/doc/types.dox
+++ b/doc/types.dox
@@ -60,7 +60,7 @@ equivalently (e.g. Math::Vector or Color3 instead of @ref Vector3).
 
 Other types, which don't have their GLSL equivalent, are:
 
- - @ref Rectangle or @ref Rectanglei
+ - @ref Rectangle, @ref Rectanglei or @ref Rectangled
  - @ref Complex or @ref Complexd, @ref DualComplex or @ref DualComplexd
  - @ref Quaternion or @ref Quaterniond, @ref DualQuaternion or @ref DualQuaterniond
 
@@ -68,5 +68,8 @@ These types can be used in GLSL either by extracting values from their
 underlying structure or converting them to types supported by GLSL (e.g.
 quaternion to matrix).
 
+For your convenience, there is also alias for class with often used constants --
+@ref Constants or @ref Constantsd.
+
 */
 }
diff --git a/src/Math/Angle.h b/src/Math/Angle.h
index 3d6e6a319..cc6d4489a 100644
--- a/src/Math/Angle.h
+++ b/src/Math/Angle.h
@@ -109,7 +109,7 @@ std::sin(Float(Rad<Float>(angleInDegrees)); // required explicit conversion hint
                                             // attention (i.e., conversion to radians)
 @endcode
 
-@see Magnum::Deg, Magnum::Rad
+@see Magnum::Deg, Magnum::Degd
 */
 template<class T> class Deg: public Unit<Deg, T> {
     public:
@@ -168,7 +168,7 @@ inline constexpr Deg<Float> operator "" _degf(long double value) { return Deg<Fl
 @brief Angle in radians
 
 See Deg for more information.
-@see Magnum::Rad
+@see Magnum::Rad, Magnum::Radd
 */
 template<class T> class Rad: public Unit<Rad, T> {
     public:
diff --git a/src/Math/Complex.h b/src/Math/Complex.h
index cd3139a0b..97a4c38fb 100644
--- a/src/Math/Complex.h
+++ b/src/Math/Complex.h
@@ -33,7 +33,7 @@ namespace Magnum { namespace Math {
 @tparam T   Data type
 
 Represents 2D rotation. See @ref transformations for brief introduction.
-@see Magnum::Complex, Matrix3
+@see Magnum::Complex, Magnum::Complexd, Matrix3
 */
 template<class T> class Complex {
     public:
diff --git a/src/Math/Constants.h b/src/Math/Constants.h
index bbc8b047c..98057ef5f 100644
--- a/src/Math/Constants.h
+++ b/src/Math/Constants.h
@@ -26,7 +26,7 @@ namespace Magnum { namespace Math {
 /**
 @brief Numeric constants
 
-@see Magnum::Constants
+@see Magnum::Constants, Magnum::Constantsd
 */
 template<class T> struct Constants {
     Constants() = delete;
diff --git a/src/Math/DualComplex.h b/src/Math/DualComplex.h
index 8c47152f4..e25babc85 100644
--- a/src/Math/DualComplex.h
+++ b/src/Math/DualComplex.h
@@ -31,7 +31,7 @@ namespace Magnum { namespace Math {
 
 Represents 2D rotation and translation. See @ref transformations for brief
 introduction.
-@see Magnum::DualComplex, Dual, Complex, Matrix3
+@see Magnum::DualComplex, Magnum::DualComplexd, Dual, Complex, Matrix3
 @todo Can this be done similarly as in dual quaternions? It sort of works, but
     the math beneath is weird.
 */
diff --git a/src/Math/DualQuaternion.h b/src/Math/DualQuaternion.h
index 0cb8bd6d0..6d563cc3e 100644
--- a/src/Math/DualQuaternion.h
+++ b/src/Math/DualQuaternion.h
@@ -31,7 +31,7 @@ namespace Magnum { namespace Math {
 
 Represents 3D rotation and translation. See @ref transformations for brief
 introduction.
-@see Magnum::DualQuaternion, Dual, Quaternion, Matrix4
+@see Magnum::DualQuaternion, Magnum::DualQuaterniond, Dual, Quaternion, Matrix4
 */
 template<class T> class DualQuaternion: public Dual<Quaternion<T>> {
     public:
diff --git a/src/Math/Geometry/Rectangle.h b/src/Math/Geometry/Rectangle.h
index c2601383f..1b122497f 100644
--- a/src/Math/Geometry/Rectangle.h
+++ b/src/Math/Geometry/Rectangle.h
@@ -29,7 +29,7 @@ namespace Magnum { namespace Math { namespace Geometry {
 Helper class for storing axis-aligned rectangles consisting of bottom left and
 top right corner positions with origin in bottom left. Bottom/left positions
 are inclusive, while top/right positions are exclusive.
-@see Magnum::Rectangle, Magnum::Rectanglei
+@see Magnum::Rectangle, Magnum::Rectanglei, Magnum::Rectangled
 */
 template<class T> class Rectangle {
     template<class> friend class Rectangle;
diff --git a/src/Math/Matrix.h b/src/Math/Matrix.h
index 89e070f57..ed423e27c 100644
--- a/src/Math/Matrix.h
+++ b/src/Math/Matrix.h
@@ -37,6 +37,7 @@ namespace Implementation {
 See @ref matrix-vector for brief introduction.
 
 @configurationvalueref{Magnum::Math::Matrix}
+@see Magnum::Matrix2, Magnum::Matrix2d
  */
 template<std::size_t size, class T> class Matrix: public RectangularMatrix<size, size, T> {
     public:
diff --git a/src/Math/Quaternion.h b/src/Math/Quaternion.h
index 97024a248..cd4f4b07e 100644
--- a/src/Math/Quaternion.h
+++ b/src/Math/Quaternion.h
@@ -34,7 +34,7 @@ namespace Magnum { namespace Math {
 @tparam T   Underlying data type
 
 Represents 3D rotation. See @ref transformations for brief introduction.
-@see Magnum::Quaternion, DualQuaternion, Matrix4
+@see Magnum::Quaternion, Magnum::Quaterniond, DualQuaternion, Matrix4
 */
 template<class T> class Quaternion {
     public:
diff --git a/src/Math/RectangularMatrix.h b/src/Math/RectangularMatrix.h
index 0702ff57d..982a1fa5d 100644
--- a/src/Math/RectangularMatrix.h
+++ b/src/Math/RectangularMatrix.h
@@ -35,6 +35,9 @@ Vector.
 The data are stored in column-major order, to reflect that, all indices in
 math formulas are in reverse order (i.e. @f$ \boldsymbol A_{ji} @f$ instead
 of @f$ \boldsymbol A_{ij} @f$).
+@see Magnum::Matrix2x3, Magnum::Matrix3x2, Magnum::Matrix2x4, Magnum::Matrix4x2,
+    Magnum::Matrix3x4, Magnum::Matrix4x3, Magnum::Matrix2x3d, Magnum::Matrix3x2d,
+    Magnum::Matrix2x4d, Magnum::Matrix4x2d, Magnum::Matrix3x4d, Magnum::Matrix4x3d
 */
 template<std::size_t cols, std::size_t rows, class T> class RectangularMatrix {
     static_assert(cols != 0 && rows != 0, "RectangularMatrix cannot have zero elements");