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

	#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)

			-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()
