diff --git a/AllChapters/Code/quat.cpp b/AllChapters/Code/quat.cpp
index 4261e91..760e013 100644
--- a/AllChapters/Code/quat.cpp
+++ b/AllChapters/Code/quat.cpp
@@ -92,7 +92,7 @@ bool operator==(const quat& left, const quat& right) {
 	return (fabsf(left.x - right.x) <= QUAT_EPSILON && 
 		    fabsf(left.y - right.y) <= QUAT_EPSILON && 
 		    fabsf(left.z - right.z) <= QUAT_EPSILON && 
-		    fabsf(left.w - left.w) <= QUAT_EPSILON);
+		    fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -101,9 +101,9 @@ bool operator!=(const quat& a, const quat& b) {
 
 bool sameOrientation(const quat& left, const quat& right) {
 	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && 
-		    fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
+		    fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
 		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && 
-			fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+			fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/AllChapters/Code/vec3.cpp b/AllChapters/Code/vec3.cpp
index 136b001..3d7084c 100644
--- a/AllChapters/Code/vec3.cpp
+++ b/AllChapters/Code/vec3.cpp
@@ -73,7 +73,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -87,7 +87,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter02/Sample00/Code/vec3.cpp b/Chapter02/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter02/Sample00/Code/vec3.cpp
+++ b/Chapter02/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter03/Sample00/Code/vec3.cpp b/Chapter03/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter03/Sample00/Code/vec3.cpp
+++ b/Chapter03/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter04/Sample00/Code/quat.cpp b/Chapter04/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter04/Sample00/Code/quat.cpp
+++ b/Chapter04/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter04/Sample00/Code/vec3.cpp b/Chapter04/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter04/Sample00/Code/vec3.cpp
+++ b/Chapter04/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter05/Sample00/Code/quat.cpp b/Chapter05/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter05/Sample00/Code/quat.cpp
+++ b/Chapter05/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter05/Sample00/Code/vec3.cpp b/Chapter05/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter05/Sample00/Code/vec3.cpp
+++ b/Chapter05/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter06/Sample00/Code/quat.cpp b/Chapter06/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter06/Sample00/Code/quat.cpp
+++ b/Chapter06/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter06/Sample00/Code/vec3.cpp b/Chapter06/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter06/Sample00/Code/vec3.cpp
+++ b/Chapter06/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter06/Sample01/Code/quat.cpp b/Chapter06/Sample01/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter06/Sample01/Code/quat.cpp
+++ b/Chapter06/Sample01/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter06/Sample01/Code/vec3.cpp b/Chapter06/Sample01/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter06/Sample01/Code/vec3.cpp
+++ b/Chapter06/Sample01/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter07/Sample00/Code/quat.cpp b/Chapter07/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter07/Sample00/Code/quat.cpp
+++ b/Chapter07/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter07/Sample00/Code/vec3.cpp b/Chapter07/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter07/Sample00/Code/vec3.cpp
+++ b/Chapter07/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter08/Sample00/Code/quat.cpp b/Chapter08/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter08/Sample00/Code/quat.cpp
+++ b/Chapter08/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter08/Sample00/Code/vec3.cpp b/Chapter08/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter08/Sample00/Code/vec3.cpp
+++ b/Chapter08/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter08/Sample01/Code/quat.cpp b/Chapter08/Sample01/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter08/Sample01/Code/quat.cpp
+++ b/Chapter08/Sample01/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter08/Sample01/Code/vec3.cpp b/Chapter08/Sample01/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter08/Sample01/Code/vec3.cpp
+++ b/Chapter08/Sample01/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter09/Sample00/Code/quat.cpp b/Chapter09/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter09/Sample00/Code/quat.cpp
+++ b/Chapter09/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter09/Sample00/Code/vec3.cpp b/Chapter09/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter09/Sample00/Code/vec3.cpp
+++ b/Chapter09/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter09/Sample01/Code/quat.cpp b/Chapter09/Sample01/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter09/Sample01/Code/quat.cpp
+++ b/Chapter09/Sample01/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter09/Sample01/Code/vec3.cpp b/Chapter09/Sample01/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter09/Sample01/Code/vec3.cpp
+++ b/Chapter09/Sample01/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter10/Sample00/Code/quat.cpp b/Chapter10/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter10/Sample00/Code/quat.cpp
+++ b/Chapter10/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter10/Sample00/Code/vec3.cpp b/Chapter10/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter10/Sample00/Code/vec3.cpp
+++ b/Chapter10/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter10/Sample01/Code/quat.cpp b/Chapter10/Sample01/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter10/Sample01/Code/quat.cpp
+++ b/Chapter10/Sample01/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter10/Sample01/Code/vec3.cpp b/Chapter10/Sample01/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter10/Sample01/Code/vec3.cpp
+++ b/Chapter10/Sample01/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter10/Sample02/Code/quat.cpp b/Chapter10/Sample02/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter10/Sample02/Code/quat.cpp
+++ b/Chapter10/Sample02/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter10/Sample02/Code/vec3.cpp b/Chapter10/Sample02/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter10/Sample02/Code/vec3.cpp
+++ b/Chapter10/Sample02/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter11/Sample00/Code/quat.cpp b/Chapter11/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter11/Sample00/Code/quat.cpp
+++ b/Chapter11/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter11/Sample00/Code/vec3.cpp b/Chapter11/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter11/Sample00/Code/vec3.cpp
+++ b/Chapter11/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter11/Sample01/Code/quat.cpp b/Chapter11/Sample01/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter11/Sample01/Code/quat.cpp
+++ b/Chapter11/Sample01/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter11/Sample01/Code/vec3.cpp b/Chapter11/Sample01/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter11/Sample01/Code/vec3.cpp
+++ b/Chapter11/Sample01/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter11/Sample02/Code/quat.cpp b/Chapter11/Sample02/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter11/Sample02/Code/quat.cpp
+++ b/Chapter11/Sample02/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter11/Sample02/Code/vec3.cpp b/Chapter11/Sample02/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter11/Sample02/Code/vec3.cpp
+++ b/Chapter11/Sample02/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter11/Sample03/Code/quat.cpp b/Chapter11/Sample03/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter11/Sample03/Code/quat.cpp
+++ b/Chapter11/Sample03/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter11/Sample03/Code/vec3.cpp b/Chapter11/Sample03/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter11/Sample03/Code/vec3.cpp
+++ b/Chapter11/Sample03/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter12/Sample00/Code/quat.cpp b/Chapter12/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter12/Sample00/Code/quat.cpp
+++ b/Chapter12/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter12/Sample00/Code/vec3.cpp b/Chapter12/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter12/Sample00/Code/vec3.cpp
+++ b/Chapter12/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter12/Sample01/Code/quat.cpp b/Chapter12/Sample01/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter12/Sample01/Code/quat.cpp
+++ b/Chapter12/Sample01/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter12/Sample01/Code/vec3.cpp b/Chapter12/Sample01/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter12/Sample01/Code/vec3.cpp
+++ b/Chapter12/Sample01/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter12/Sample02/Code/quat.cpp b/Chapter12/Sample02/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter12/Sample02/Code/quat.cpp
+++ b/Chapter12/Sample02/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter12/Sample02/Code/vec3.cpp b/Chapter12/Sample02/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter12/Sample02/Code/vec3.cpp
+++ b/Chapter12/Sample02/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter12/Sample03/Code/quat.cpp b/Chapter12/Sample03/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter12/Sample03/Code/quat.cpp
+++ b/Chapter12/Sample03/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter12/Sample03/Code/vec3.cpp b/Chapter12/Sample03/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter12/Sample03/Code/vec3.cpp
+++ b/Chapter12/Sample03/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter13/Sample00/Code/quat.cpp b/Chapter13/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter13/Sample00/Code/quat.cpp
+++ b/Chapter13/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter13/Sample00/Code/vec3.cpp b/Chapter13/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter13/Sample00/Code/vec3.cpp
+++ b/Chapter13/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter13/Sample01/Code/quat.cpp b/Chapter13/Sample01/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter13/Sample01/Code/quat.cpp
+++ b/Chapter13/Sample01/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter13/Sample01/Code/vec3.cpp b/Chapter13/Sample01/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter13/Sample01/Code/vec3.cpp
+++ b/Chapter13/Sample01/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter13/Sample02/Code/quat.cpp b/Chapter13/Sample02/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter13/Sample02/Code/quat.cpp
+++ b/Chapter13/Sample02/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter13/Sample02/Code/vec3.cpp b/Chapter13/Sample02/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter13/Sample02/Code/vec3.cpp
+++ b/Chapter13/Sample02/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter13/Sample03/Code/quat.cpp b/Chapter13/Sample03/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter13/Sample03/Code/quat.cpp
+++ b/Chapter13/Sample03/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter13/Sample03/Code/vec3.cpp b/Chapter13/Sample03/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter13/Sample03/Code/vec3.cpp
+++ b/Chapter13/Sample03/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter14/Sample00/Code/quat.cpp b/Chapter14/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter14/Sample00/Code/quat.cpp
+++ b/Chapter14/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter14/Sample00/Code/vec3.cpp b/Chapter14/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter14/Sample00/Code/vec3.cpp
+++ b/Chapter14/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter14/Sample01/Code/quat.cpp b/Chapter14/Sample01/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter14/Sample01/Code/quat.cpp
+++ b/Chapter14/Sample01/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter14/Sample01/Code/vec3.cpp b/Chapter14/Sample01/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter14/Sample01/Code/vec3.cpp
+++ b/Chapter14/Sample01/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter15/Sample00/Code/quat.cpp b/Chapter15/Sample00/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter15/Sample00/Code/quat.cpp
+++ b/Chapter15/Sample00/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter15/Sample00/Code/vec3.cpp b/Chapter15/Sample00/Code/vec3.cpp
index ebf6f8a..e59ed84 100644
--- a/Chapter15/Sample00/Code/vec3.cpp
+++ b/Chapter15/Sample00/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
diff --git a/Chapter15/Sample01/Code/quat.cpp b/Chapter15/Sample01/Code/quat.cpp
index 3320cb1..3f9d795 100644
--- a/Chapter15/Sample01/Code/quat.cpp
+++ b/Chapter15/Sample01/Code/quat.cpp
@@ -90,7 +90,7 @@ quat operator-(const quat& q) {
 }
 
 bool operator==(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON);
 }
 
 bool operator!=(const quat& a, const quat& b) {
@@ -98,8 +98,8 @@ bool operator!=(const quat& a, const quat& b) {
 }
 
 bool sameOrientation(const quat& left, const quat& right) {
-	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - left.w) <= QUAT_EPSILON)
-		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + left.w) <= QUAT_EPSILON);
+	return (fabsf(left.x - right.x) <= QUAT_EPSILON && fabsf(left.y - right.y) <= QUAT_EPSILON && fabsf(left.z - right.z) <= QUAT_EPSILON && fabsf(left.w - right.w) <= QUAT_EPSILON)
+		|| (fabsf(left.x + right.x) <= QUAT_EPSILON && fabsf(left.y + right.y) <= QUAT_EPSILON && fabsf(left.z + right.z) <= QUAT_EPSILON && fabsf(left.w + right.w) <= QUAT_EPSILON);
 }
 
 float dot(const quat& a, const quat& b) {
diff --git a/Chapter15/Sample01/Code/vec3.cpp b/Chapter15/Sample01/Code/vec3.cpp
index ebf6f8a..33ce460 100644
--- a/Chapter15/Sample01/Code/vec3.cpp
+++ b/Chapter15/Sample01/Code/vec3.cpp
@@ -74,7 +74,7 @@ float angle(const vec3& l, const vec3& r) {
 }
 
 vec3 project(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -88,7 +88,7 @@ vec3 reject(const vec3& a, const vec3& b) {
 }
 
 vec3 reflect(const vec3& a, const vec3& b) {
-	float magBSq = len(b);
+	float magBSq = lenSq(b);
 	if (magBSq < VEC3_EPSILON) {
 		return vec3();
 	}
@@ -146,4 +146,4 @@ bool operator==(const vec3& l, const vec3& r) {
 
 bool operator!=(const vec3& l, const vec3& r) {
 	return !(l == r);
-}
\ No newline at end of file
+}