 			-Float4(1, 2, 3, 4),
 			Float4(-simd_float4(1, 2, 3, 4))
 		)
+	}
+	
+	func testSimpleAngleAxisConstructors()
+	{
+		for (rotationIndex, (angle_rad, axis)) in Self._angleAxisRotationSimpleTestValues.enumerated() {
+			let simdQuaternion = simd_quaternion(angle_rad, axis.simdValue)
+			let vucktQuaternion = FloatQuaternion(angle: angle_rad, axis: axis)
+			let vucktMatrix3 = Float3x3(rotationAngle: angle_rad, axis: axis)
+			
+			for (valueIndex, vector) in Self._float3SimpleTestValues.enumerated() {
+				let vector = Float3(array: vector)
+				
+				let expectedRotatedValue = Float3(array: Self._float3SimpleRotatedExpectedValues[rotationIndex][valueIndex])
+				
+				let simdQuaternionRotatedVector = Float3(simd_act(simdQuaternion, vector.simdValue))
+				let vucktQuaternionRotatedVector = vucktQuaternion * vector
+				let vucktMatrixRotatedVector = vucktMatrix3 * vector
+				
+				assertAlmostEqual(simdQuaternionRotatedVector, expectedRotatedValue,
+					"\"\(simdQuaternionRotatedVector)\" is not almost equal to (\"\(expectedRotatedValue)\")"
+				)
+				assertAlmostEqual(vucktQuaternionRotatedVector, expectedRotatedValue,
+					"\"\(vucktQuaternionRotatedVector)\" is not almost equal to (\"\(expectedRotatedValue)\")"
+				)
+				assertAlmostEqual(vucktMatrixRotatedVector, expectedRotatedValue,
+					"\"\(vucktMatrixRotatedVector)\" is not almost equal to (\"\(expectedRotatedValue)\")"
+				)
+			}
+		}
+	}
+	
+	func testAngleAxisConstructors()
+	{
+		for (rotationIndex, (angle_rad, axis)) in Self._angleAxisRotationTestValues.enumerated() {
+			let glmQuaternion = Self._angleAxisRotationGLMComputedQuaternions[rotationIndex]
+			let glmMatrix = Self._angleAxisRotationGLMComputedMatrixes[rotationIndex]
+			
+			let simdQuaternion = simd_quaternion(angle_rad, axis.simdValue)
+			let vucktQuaternion = FloatQuaternion(angle: angle_rad, axis: axis)
+			let vucktMatrix3 = Float3x3(rotationAngle: angle_rad, axis: axis)
+			
+			for (valueIndex, vector) in Self._float3RegularTestValues.enumerated() {
+				let vector = Float3(array: vector)
+				
+				let simdQuaternionRotatedVector = Float3(simd_act(simdQuaternion, vector.simdValue))
+				let glmMatrixRotatedVector = Float3(glmMatrix * vector.simdValue)
+				let glmQuaternionRotatedVector = Float3(simd_act(glmQuaternion, vector.simdValue))
+				let vucktQuaternionRotatedVector = vucktQuaternion * vector
+				let vucktMatrixRotatedVector = vucktMatrix3 * vector
+				
+				assertAlmostEqual(glmMatrixRotatedVector, simdQuaternionRotatedVector,
+					"\"\(glmMatrixRotatedVector)\" is not almost equal to (\"\(simdQuaternionRotatedVector)\")"
+				)
+				assertAlmostEqual(glmQuaternionRotatedVector, simdQuaternionRotatedVector,
+					"\"\(glmQuaternionRotatedVector)\" is not almost equal to (\"\(simdQuaternionRotatedVector)\")"
+				)
+				assertAlmostEqual(vucktQuaternionRotatedVector, simdQuaternionRotatedVector,
+					"\"\(vucktQuaternionRotatedVector)\" is not almost equal to (\"\(simdQuaternionRotatedVector)\")"
+				)
+				assertAlmostEqual(vucktMatrixRotatedVector, simdQuaternionRotatedVector,
+					"\"\(vucktMatrixRotatedVector)\" is not almost equal to (\"\(simdQuaternionRotatedVector)\")"
+				)
+			}
+		}
+	}
+	
+	func testSimpleEulerAnglesXYZConstructors()
+	{
+		for (rotationIndex, eulerAngles_rad) in Self._eulerAnglesRotationSimpleTestValues.enumerated() {
+			let simdQuaternion:simd_quatf = {
+				let zRotation = simd_quaternion(eulerAngles_rad.z, Float3.unitZPositive.simdValue)
+				let yRotation = simd_quaternion(eulerAngles_rad.y, Float3.unitYPositive.simdValue)
+				let xRotation = simd_quaternion(eulerAngles_rad.x, Float3.unitXPositive.simdValue)
+				return zRotation * yRotation * xRotation
+			}()
+			let vucktQuaternion = FloatQuaternion(eulerAngles: eulerAngles_rad, order: .xyz)
+			let vucktMatrix3 = Float3x3(rotationEulerAngles: eulerAngles_rad, order: .xyz)
+			
+			for (valueIndex, vector) in Self._float3SimpleTestValues.enumerated() {
+				let vector = Float3(array: vector)
+				
+				let expectedRotatedValue = Float3(array: Self._float3SimpleRotatedExpectedValues[rotationIndex][valueIndex])
+				
+				let simdQuaternionRotatedVector = Float3(simd_act(simdQuaternion, vector.simdValue))
+				let vucktQuaternionRotatedVector = vucktQuaternion * vector
+				let vucktMatrixRotatedVector = vucktMatrix3 * vector
+				
+				assertAlmostEqual(simdQuaternionRotatedVector, expectedRotatedValue,
+					"\"\(simdQuaternionRotatedVector)\" is not almost equal to (\"\(expectedRotatedValue)\")"
+				)
+				assertAlmostEqual(vucktQuaternionRotatedVector, expectedRotatedValue,
+					"\"\(vucktQuaternionRotatedVector)\" is not almost equal to (\"\(expectedRotatedValue)\")"
+				)
+				assertAlmostEqual(vucktMatrixRotatedVector, expectedRotatedValue,
+					"\"\(vucktMatrixRotatedVector)\" is not almost equal to (\"\(expectedRotatedValue)\")"
+				)
+			}
+		}
+	}
+	
+	func testEulerAnglesXYZConstructors()
+	{
+		for (rotationIndex, eulerAngles_rad) in Self._eulerAnglesRotationTestValues.enumerated() {
+			let glmQuaternion = Self._eulerAnglesRotationGLMComputedXYZQuaternions[rotationIndex]
+			let glmMatrix = Self._eulerAnglesRotationGLMComputedXYZMatrixes[rotationIndex]
+			
+			let simdQuaternion:simd_quatf = {
+				let zRotation = simd_quaternion(eulerAngles_rad.z, Float3.unitZPositive.simdValue)
+				let yRotation = simd_quaternion(eulerAngles_rad.y, Float3.unitYPositive.simdValue)
+				let xRotation = simd_quaternion(eulerAngles_rad.x, Float3.unitXPositive.simdValue)
+				return zRotation * yRotation * xRotation
+			}()
+			let vucktQuaternion = FloatQuaternion(eulerAngles: eulerAngles_rad, order: .xyz)
+			let vucktMatrix3 = Float3x3(rotationEulerAngles: eulerAngles_rad, order: .xyz)
+			
+			for (valueIndex, vector) in Self._float3RegularTestValues.enumerated() {
+				let vector = Float3(array: vector)
+				
+				let simdQuaternionRotatedVector = Float3(simd_act(simdQuaternion, vector.simdValue))
+				let glmMatrixRotatedVector = Float3(glmMatrix * vector.simdValue)
+				let glmQuaternionRotatedVector = Float3(simd_act(glmQuaternion, vector.simdValue))
+				let vucktQuaternionRotatedVector = vucktQuaternion * vector
+				let vucktMatrixRotatedVector = vucktMatrix3 * vector
+				
+				assertAlmostEqual(glmMatrixRotatedVector, simdQuaternionRotatedVector,
+					"\"\(glmMatrixRotatedVector)\" is not almost equal to (\"\(simdQuaternionRotatedVector)\")"
+				)
+				assertAlmostEqual(glmQuaternionRotatedVector, simdQuaternionRotatedVector,
+					"\"\(glmQuaternionRotatedVector)\" is not almost equal to (\"\(simdQuaternionRotatedVector)\")"
+				)
+				assertAlmostEqual(vucktQuaternionRotatedVector, simdQuaternionRotatedVector,
+					"\"\(vucktQuaternionRotatedVector)\" is not almost equal to (\"\(simdQuaternionRotatedVector)\")"
+				)
+				assertAlmostEqual(vucktMatrixRotatedVector, simdQuaternionRotatedVector,
+					"\"\(vucktMatrixRotatedVector)\" is not almost equal to (\"\(simdQuaternionRotatedVector)\")"
+				)
+			}
+		}
 	}
 	
 	func testPerformanceExample()

	#if !NO_OBJC_BRIDGE
	func testNSValueRoundtripping()
	{
		_int2TestValues.map(Int2.init).forEach{
			let nsValue = NSValue(int2: $0)
			let value = nsValue.int2Value
			XCTAssertEqual($0, value)
		}
		
		_int3TestValues.map(Int3.init).forEach{
			let nsValue = NSValue(int3: $0)
			let value = nsValue.int3Value
			XCTAssertEqual($0, value)
		}
		
		_int4TestValues.map(Int4.init).forEach{
			let nsValue = NSValue(int4: $0)
			let value = nsValue.int4Value
			XCTAssertEqual($0, value)
		}
		
		_float2TestValues.map(Float2.init).forEach{
			let nsValue = NSValue(float2: $0)
			let value = nsValue.float2Value
			XCTAssertEqual($0, value)
		}
		
		_float3TestValues.map(Float3.init).forEach{
			let nsValue = NSValue(float3: $0)
			let value = nsValue.float3Value
			XCTAssertEqual($0, value)
		}
		
		_float4TestValues.map(Float4.init).forEach{
			let nsValue = NSValue(float4: $0)
			let value = nsValue.float4Value
			XCTAssertEqual($0, value)

	
	func testSIMDRoundtripping()
	{
		Self._int2TestValues.map(Int2.init).forEach{
			let simdValue = $0.simdValue
			let value = Int2(simdValue)
			XCTAssertEqual($0, value)
		}
		
		Self._int3TestValues.map(Int3.init).forEach{
			let simdValue = $0.simdValue
			let value = Int3(simdValue)
			XCTAssertEqual($0, value)
		}
		
		Self._int4TestValues.map(Int4.init).forEach{
			let simdValue = $0.simdValue
			let value = Int4(simdValue)
			XCTAssertEqual($0, value)
		}
		
		Self._float2TestValues.map(Float2.init).forEach{
			let simdValue = $0.simdValue
			let value = Float2(simdValue)
			XCTAssertEqual($0, value)
		}
		
		Self._float3TestValues.map(Float3.init).forEach{
			let simdValue = $0.simdValue
			let value = Float3(simdValue)
			XCTAssertEqual($0, value)
		}
		
		Self._float4TestValues.map(Float4.init).forEach{
			let simdValue = $0.simdValue
			let value = Float4(simdValue)
			XCTAssertEqual($0, value)
