I hate GCC.

Why the hell it does not have std::is_trivially_constructible until
version 5?!

src/Magnum/Math/BoolVector.h

@@ -74,9 +74,7 @@ template<std::size_t size> class BoolVector {
         constexpr /*implicit*/ BoolVector(ZeroInitT = ZeroInit): _data{} {}
 
         /** @brief Construct without initializing the contents */
-        explicit BoolVector(NoInitT) {
+        explicit BoolVector(NoInitT) {}
-            static_assert(std::is_trivially_constructible<decltype(_data)>{}, "");
-        }
 
         /**
          * @brief Construct boolean vector from segment values

src/Magnum/Math/Complex.h

@@ -146,10 +146,7 @@ template<class T> class Complex {
         constexpr explicit Complex(ZeroInitT): _real{}, _imaginary{} {}
 
         /** @brief Construct without initializing the contents */
-        explicit Complex(NoInitT) {
+        explicit Complex(NoInitT) {}
-            static_assert(std::is_trivially_constructible<decltype(_real)>{}, "");
-            static_assert(std::is_trivially_constructible<decltype(_imaginary)>{}, "");
-        }
 
         /**
          * @brief Construct complex number from real and imaginary part

src/Magnum/Math/Dual.h

@@ -58,7 +58,7 @@ template<class T> class Dual {
         #ifdef DOXYGEN_GENERATING_OUTPUT
         explicit Dual(NoInitT);
         #else
-        template<class U = T, class = typename std::enable_if<std::is_trivially_constructible<U>{}>::type> Dual(NoInitT) {}
+        template<class U = T, class = typename std::enable_if<std::is_pod<U>{}>::type> Dual(NoInitT) {}
         template<class U = T, class V = T, class = typename std::enable_if<std::is_constructible<U, NoInitT>{}>::type> Dual(NoInitT): _real{NoInit}, _dual{NoInit} {}
         #endif
 

src/Magnum/Math/Quaternion.h

@@ -203,9 +203,7 @@ template<class T> class Quaternion {
         constexpr explicit Quaternion(ZeroInitT): _vector{ZeroInit}, _scalar{T{0}} {}
 
         /** @brief Construct without initializing the contents */
-        explicit Quaternion(NoInitT): _vector{NoInit} {
+        explicit Quaternion(NoInitT): _vector{NoInit} {}
-            static_assert(std::is_trivially_constructible<decltype(_scalar)>{}, "");
-        }
 
         /**
          * @brief Construct quaternion from vector and scalar

src/Magnum/Math/Unit.h

@@ -50,9 +50,7 @@ template<template<class> class Derived, class T> class Unit {
         constexpr /*implicit*/ Unit(ZeroInitT = ZeroInit): _value(T(0)) {}
 
         /** @brief Construct without initializing the contents */
-        explicit Unit(NoInitT) {
+        explicit Unit(NoInitT) {}
-            static_assert(std::is_trivially_constructible<decltype(_value)>{}, "");
-        }
 
         /** @brief Explicit conversion from unitless type */
         constexpr explicit Unit(T value): _value(value) {}

src/Magnum/Math/Vector.h

@@ -149,9 +149,7 @@ template<std::size_t size, class T> class Vector {
         constexpr /*implicit*/ Vector(ZeroInitT = ZeroInit): _data{} {}
 
         /** @brief Construct vector without initializing the contents */
-        explicit Vector(NoInitT) {
+        explicit Vector(NoInitT) {}
-            static_assert(std::is_trivially_constructible<decltype(_data)>{}, "");
-        }
 
         /** @todo Creating Vector from combination of vector and scalar types */