From b621191698e2cc0c60ac8038a3ce341465b43488 Mon Sep 17 00:00:00 2001
From: Andrey Pokidov <andrey.pokidov@gmail.com>
Date: Mon, 16 Feb 2026 20:41:45 +0700
Subject: [PATCH] =?UTF-8?q?=D0=9F=D0=B5=D1=80=D0=B5=D0=B8=D0=BC=D0=B5?=
 =?UTF-8?q?=D0=BD=D0=BE=D0=B2=D0=B0=D0=BD=D0=B8=D0=B5=20=D0=BC=D0=B5=D1=82?=
 =?UTF-8?q?=D0=BE=D0=B4=D0=BE=D0=B2=20=D0=BD=D0=B0=20=D1=80=D0=B0=D1=81?=
 =?UTF-8?q?=D0=BF=D1=80=D0=BE=D1=81=D1=82=D1=80=D0=B0=D0=BD=D1=91=D0=BD?=
 =?UTF-8?q?=D0=BD=D1=8B=D0=B5=20=D0=BD=D0=B0=D0=B7=D0=B2=D0=B0=D0=BD=D0=B8?=
 =?UTF-8?q?=D1=8F?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 basic-geometry-dev/main.c         |  4 +-
 basic-geometry/basic-geometry.cbp |  8 ++--
 basic-geometry/dual-quaternion.c  |  2 +-
 basic-geometry/dual-quaternion.h  |  6 +--
 basic-geometry/quaternion.c       |  8 ++--
 basic-geometry/quaternion.h       | 56 ++++++++++++-------------
 basic-geometry/slerp3.c           | 36 ++++++++--------
 basic-geometry/slerp3.h           | 40 +++++++++---------
 basic-geometry/turn3.c            | 36 ++++++++--------
 basic-geometry/turn3.h            | 24 +++++------
 basic-geometry/vector2.c          | 16 ++++----
 basic-geometry/vector2.h          | 60 +++++++++++++--------------
 basic-geometry/vector3.c          | 20 ++++-----
 basic-geometry/vector3.h          | 68 +++++++++++++++----------------
 14 files changed, 192 insertions(+), 192 deletions(-)

diff --git a/basic-geometry-dev/main.c b/basic-geometry-dev/main.c
index ae8a901..bd13caf 100644
--- a/basic-geometry-dev/main.c
+++ b/basic-geometry-dev/main.c
@@ -63,12 +63,12 @@ void print_quaternion_fp64(const BGC_FP64_Quaternion* quaternion)
 
 void print_vector_fp32(const BGC_FP32_Vector3* vector)
 {
-    printf("(%f, %f, %f) / %f\n", vector->x1,  vector->x2,  vector->x3,  bgc_fp32_vector3_get_modulus(vector));
+    printf("(%f, %f, %f) / %f\n", vector->x1,  vector->x2,  vector->x3,  bgc_fp32_vector3_get_length(vector));
 }
 
 void print_vector_fp64(const BGC_FP64_Vector3* vector)
 {
-    printf("(%lf, %lf, %lf) / %lf\n", vector->x1,  vector->x2,  vector->x3,  bgc_fp64_vector3_get_modulus(vector));
+    printf("(%lf, %lf, %lf) / %lf\n", vector->x1,  vector->x2,  vector->x3,  bgc_fp64_vector3_get_length(vector));
 }
 
 void list_work(const uint_fast32_t amount, structure_fp32_t* list)
diff --git a/basic-geometry/basic-geometry.cbp b/basic-geometry/basic-geometry.cbp
index 1bc6f94..28ce0a6 100644
--- a/basic-geometry/basic-geometry.cbp
+++ b/basic-geometry/basic-geometry.cbp
@@ -60,14 +60,14 @@
 			<Option compilerVar="CC" />
 		</Unit>
 		<Unit filename="complex.h" />
+		<Unit filename="dual-number.c">
+			<Option compilerVar="CC" />
+		</Unit>
+		<Unit filename="dual-number.h" />
 		<Unit filename="dual-quaternion.c">
 			<Option compilerVar="CC" />
 		</Unit>
 		<Unit filename="dual-quaternion.h" />
-		<Unit filename="dual-scalar.c">
-			<Option compilerVar="CC" />
-		</Unit>
-		<Unit filename="dual-scalar.h" />
 		<Unit filename="dual-vector3.c">
 			<Option compilerVar="CC" />
 		</Unit>
diff --git a/basic-geometry/dual-quaternion.c b/basic-geometry/dual-quaternion.c
index 2047200..ad980cf 100644
--- a/basic-geometry/dual-quaternion.c
+++ b/basic-geometry/dual-quaternion.c
@@ -30,7 +30,7 @@ extern inline void bgc_fp64_dual_quaternion_subtract(BGC_FP64_DualQuaternion* di
 extern inline void bgc_fp32_dual_quaternion_subtract_scaled(BGC_FP32_DualQuaternion* difference, const BGC_FP32_DualQuaternion* base_quaternion, const BGC_FP32_DualQuaternion* scalable_quaternion, const float scale);
 extern inline void bgc_fp64_dual_quaternion_subtract_scaled(BGC_FP64_DualQuaternion* difference, const BGC_FP64_DualQuaternion* base_quaternion, const BGC_FP64_DualQuaternion* scalable_quaternion, const double scale);
 
-extern inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier);
+extern inline void bgc_fp32_dual_quaternion_multiply_by_real_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier);
 extern inline void bgc_fp64_dual_quaternion_multiply_by_real(BGC_FP64_DualQuaternion* product, const BGC_FP64_DualQuaternion* multiplicand, const double multiplier);
 
 extern inline void bgc_fp32_dual_quaternion_multiply_by_dual_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const BGC_FP32_DualNumber* multiplier);
diff --git a/basic-geometry/dual-quaternion.h b/basic-geometry/dual-quaternion.h
index 68de83a..8d3d291 100644
--- a/basic-geometry/dual-quaternion.h
+++ b/basic-geometry/dual-quaternion.h
@@ -146,7 +146,7 @@ inline void bgc_fp64_dual_quaternion_subtract_scaled(BGC_FP64_DualQuaternion* di
 
 // ================== Multiply ================== //
 
-inline void bgc_fp32_dual_quaternion_multiply_by_real(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier)
+inline void bgc_fp32_dual_quaternion_multiply_by_real_number(BGC_FP32_DualQuaternion* product, const BGC_FP32_DualQuaternion* multiplicand, const float multiplier)
 {
     bgc_fp32_quaternion_multiply_by_real(&product->real_part, &multiplicand->real_part, multiplier);
     bgc_fp32_quaternion_multiply_by_real(&product->dual_part, &multiplicand->dual_part, multiplier);
@@ -247,7 +247,7 @@ inline int bgc_fp32_dual_quaternion_divide_by_dual_number(BGC_FP32_DualQuaternio
     }
 
     bgc_fp32_dual_quaternion_multiply_by_conjugate_number(quotient, dividend, divisor);
-    bgc_fp32_dual_quaternion_multiply_by_real(quotient, quotient, 1.0f / square_modulus);
+    bgc_fp32_dual_quaternion_multiply_by_real_number(quotient, quotient, 1.0f / square_modulus);
 
     return BGC_SUCCESS;
 }
@@ -277,7 +277,7 @@ inline int bgc_fp32_dual_quaternion_divide_by_conjugate_number(BGC_FP32_DualQuat
     }
 
     bgc_fp32_dual_quaternion_multiply_by_dual_number(quotient, dividend, divisor_to_conjugate);
-    bgc_fp32_dual_quaternion_multiply_by_real(quotient, quotient, 1.0f / square_modulus);
+    bgc_fp32_dual_quaternion_multiply_by_real_number(quotient, quotient, 1.0f / square_modulus);
 
     return BGC_SUCCESS;
 }
diff --git a/basic-geometry/quaternion.c b/basic-geometry/quaternion.c
index 7e8f495..97a1769 100644
--- a/basic-geometry/quaternion.c
+++ b/basic-geometry/quaternion.c
@@ -10,11 +10,11 @@ extern inline void bgc_fp64_quaternion_make_unit(BGC_FP64_Quaternion* quaternion
 extern inline void bgc_fp32_quaternion_make(BGC_FP32_Quaternion* quaternion, const float s0, const float x1, const float x2, const float x3);
 extern inline void bgc_fp64_quaternion_make(BGC_FP64_Quaternion* quaternion, const double s0, const double x1, const double x2, const double x3);
 
-extern inline float bgc_fp32_quaternion_get_square_modulus(const BGC_FP32_Quaternion* quaternion);
-extern inline double bgc_fp64_quaternion_get_square_modulus(const BGC_FP64_Quaternion* quaternion);
+extern inline float bgc_fp32_quaternion_get_square_magnitude(const BGC_FP32_Quaternion* quaternion);
+extern inline double bgc_fp64_quaternion_get_square_magnitude(const BGC_FP64_Quaternion* quaternion);
 
-extern inline float bgc_fp32_quaternion_get_modulus(const BGC_FP32_Quaternion* quaternion);
-extern inline double bgc_fp64_quaternion_get_modulus(const BGC_FP64_Quaternion* quaternion);
+extern inline float bgc_fp32_quaternion_get_magnitude(const BGC_FP32_Quaternion* quaternion);
+extern inline double bgc_fp64_quaternion_get_magnitude(const BGC_FP64_Quaternion* quaternion);
 
 extern inline int bgc_fp32_quaternion_is_zero(const BGC_FP32_Quaternion* quaternion);
 extern inline int bgc_fp64_quaternion_is_zero(const BGC_FP64_Quaternion* quaternion);
diff --git a/basic-geometry/quaternion.h b/basic-geometry/quaternion.h
index d80ba7a..c4e3fcd 100644
--- a/basic-geometry/quaternion.h
+++ b/basic-geometry/quaternion.h
@@ -64,50 +64,50 @@ inline void bgc_fp64_quaternion_make(BGC_FP64_Quaternion* quaternion, const doub
 
 // ============= Get Square Modulus ============= //
 
-inline float bgc_fp32_quaternion_get_square_modulus(const BGC_FP32_Quaternion* quaternion)
+inline float bgc_fp32_quaternion_get_square_magnitude(const BGC_FP32_Quaternion* quaternion)
 {
     return (quaternion->s0 * quaternion->s0 + quaternion->x1 * quaternion->x1) + (quaternion->x2 * quaternion->x2 + quaternion->x3 * quaternion->x3);
 }
 
-inline double bgc_fp64_quaternion_get_square_modulus(const BGC_FP64_Quaternion* quaternion)
+inline double bgc_fp64_quaternion_get_square_magnitude(const BGC_FP64_Quaternion* quaternion)
 {
     return (quaternion->s0 * quaternion->s0 + quaternion->x1 * quaternion->x1) + (quaternion->x2 * quaternion->x2 + quaternion->x3 * quaternion->x3);
 }
 
 // ================ Get Modulus ================= //
 
-inline float bgc_fp32_quaternion_get_modulus(const BGC_FP32_Quaternion* quaternion)
+inline float bgc_fp32_quaternion_get_magnitude(const BGC_FP32_Quaternion* quaternion)
 {
-    return sqrtf(bgc_fp32_quaternion_get_square_modulus(quaternion));
+    return sqrtf(bgc_fp32_quaternion_get_square_magnitude(quaternion));
 }
 
-inline double bgc_fp64_quaternion_get_modulus(const BGC_FP64_Quaternion* quaternion)
+inline double bgc_fp64_quaternion_get_magnitude(const BGC_FP64_Quaternion* quaternion)
 {
-    return sqrt(bgc_fp64_quaternion_get_square_modulus(quaternion));
+    return sqrt(bgc_fp64_quaternion_get_square_magnitude(quaternion));
 }
 
 // ================== Is Zero =================== //
 
 inline int bgc_fp32_quaternion_is_zero(const BGC_FP32_Quaternion* quaternion)
 {
-    return bgc_fp32_quaternion_get_square_modulus(quaternion) <= BGC_FP32_SQUARE_EPSILON;
+    return bgc_fp32_quaternion_get_square_magnitude(quaternion) <= BGC_FP32_SQUARE_EPSILON;
 }
 
 inline int bgc_fp64_quaternion_is_zero(const BGC_FP64_Quaternion* quaternion)
 {
-    return bgc_fp64_quaternion_get_square_modulus(quaternion) <= BGC_FP64_SQUARE_EPSILON;
+    return bgc_fp64_quaternion_get_square_magnitude(quaternion) <= BGC_FP64_SQUARE_EPSILON;
 }
 
 // ================== Is Unit =================== //
 
 inline int bgc_fp32_quaternion_is_unit(const BGC_FP32_Quaternion* quaternion)
 {
-    return bgc_fp32_is_square_unit(bgc_fp32_quaternion_get_square_modulus(quaternion));
+    return bgc_fp32_is_square_unit(bgc_fp32_quaternion_get_square_magnitude(quaternion));
 }
 
 inline int bgc_fp64_quaternion_is_unit(const BGC_FP64_Quaternion* quaternion)
 {
-    return bgc_fp64_is_square_unit(bgc_fp64_quaternion_get_square_modulus(quaternion));
+    return bgc_fp64_is_square_unit(bgc_fp64_quaternion_get_square_magnitude(quaternion));
 }
 
 // ==================== Copy ==================== //
@@ -358,7 +358,7 @@ inline int bgc_fp64_quaternion_divide_by_real(BGC_FP64_Quaternion* quotient, con
 
 inline int bgc_fp32_quaternion_divide_by_quaternion(BGC_FP32_Quaternion* quotient, const BGC_FP32_Quaternion* divident, const BGC_FP32_Quaternion* divisor)
 {
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(divisor);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(divisor);
 
     if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -372,7 +372,7 @@ inline int bgc_fp32_quaternion_divide_by_quaternion(BGC_FP32_Quaternion* quotien
 
 inline int bgc_fp64_quaternion_divide_by_quaternion(BGC_FP64_Quaternion* quotient, const BGC_FP64_Quaternion* divident, const BGC_FP64_Quaternion* divisor)
 {
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(divisor);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(divisor);
 
     if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -388,7 +388,7 @@ inline int bgc_fp64_quaternion_divide_by_quaternion(BGC_FP64_Quaternion* quotien
 
 inline int bgc_fp32_quaternion_divide_by_conjugate(BGC_FP32_Quaternion* quotient, const BGC_FP32_Quaternion* divident, const BGC_FP32_Quaternion* divisor_to_conjugate)
 {
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(divisor_to_conjugate);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(divisor_to_conjugate);
 
     if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -402,7 +402,7 @@ inline int bgc_fp32_quaternion_divide_by_conjugate(BGC_FP32_Quaternion* quotient
 
 inline int bgc_fp64_quaternion_divide_by_conjugate(BGC_FP64_Quaternion* quotient, const BGC_FP64_Quaternion* divident, const BGC_FP64_Quaternion* divisor_to_conjugate)
 {
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(divisor_to_conjugate);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(divisor_to_conjugate);
 
     if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -542,7 +542,7 @@ inline void bgc_fp64_quaternion_get_reverse(BGC_FP64_Quaternion* reverse, const
 
 inline int bgc_fp32_quaternion_get_inverse(BGC_FP32_Quaternion* inverse, const BGC_FP32_Quaternion* quaternion)
 {
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -560,7 +560,7 @@ inline int bgc_fp32_quaternion_get_inverse(BGC_FP32_Quaternion* inverse, const B
 
 inline int bgc_fp64_quaternion_get_inverse(BGC_FP64_Quaternion* inverse, const BGC_FP64_Quaternion* quaternion)
 {
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -590,7 +590,7 @@ inline int bgc_fp64_quaternion_invert(BGC_FP64_Quaternion* quaternion)
 
 inline int bgc_fp32_quaternion_normalize(BGC_FP32_Quaternion* quaternion)
 {
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -612,7 +612,7 @@ inline int bgc_fp32_quaternion_normalize(BGC_FP32_Quaternion* quaternion)
 
 inline int bgc_fp64_quaternion_normalize(BGC_FP64_Quaternion* quaternion)
 {
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -634,7 +634,7 @@ inline int bgc_fp64_quaternion_normalize(BGC_FP64_Quaternion* quaternion)
 
 inline int bgc_fp32_quaternion_get_normalized(BGC_FP32_Quaternion* normalized, const BGC_FP32_Quaternion* quaternion)
 {
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         bgc_fp32_quaternion_reset(normalized);
@@ -652,7 +652,7 @@ inline int bgc_fp32_quaternion_get_normalized(BGC_FP32_Quaternion* normalized, c
 
 inline int bgc_fp64_quaternion_get_normalized(BGC_FP64_Quaternion* normalized, const BGC_FP64_Quaternion* quaternion)
 {
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         bgc_fp64_quaternion_reset(normalized);
@@ -746,7 +746,7 @@ inline void _bgc_fp64_quaternion_turn_vector_back_roughly(BGC_FP64_Vector3* turn
 
 inline int bgc_fp32_quaternion_turn_vector(BGC_FP32_Vector3* turned_vector, const BGC_FP32_Quaternion* quaternion, const BGC_FP32_Vector3* original_vector)
 {
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus < BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -772,7 +772,7 @@ inline int bgc_fp32_quaternion_turn_vector(BGC_FP32_Vector3* turned_vector, cons
 
 inline int bgc_fp64_quaternion_turn_vector(BGC_FP64_Vector3* turned_vector, const BGC_FP64_Quaternion* quaternion, const BGC_FP64_Vector3* original_vector)
 {
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus < BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -800,7 +800,7 @@ inline int bgc_fp64_quaternion_turn_vector(BGC_FP64_Vector3* turned_vector, cons
 
 inline int bgc_fp32_quaternion_turn_vector_back(BGC_FP32_Vector3* turned_vector, const BGC_FP32_Quaternion* quaternion, const BGC_FP32_Vector3* original_vector)
 {
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus < BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -826,7 +826,7 @@ inline int bgc_fp32_quaternion_turn_vector_back(BGC_FP32_Vector3* turned_vector,
 
 inline int bgc_fp64_quaternion_turn_vector_back(BGC_FP64_Vector3* turned_vector, const BGC_FP64_Quaternion* quaternion, const BGC_FP64_Vector3* original_vector)
 {
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
 
     if (square_modulus < BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -1049,8 +1049,8 @@ inline int bgc_fp32_quaternion_are_close(const BGC_FP32_Quaternion* quaternion1,
     const float dx2 = quaternion1->x2 - quaternion2->x2;
     const float dx3 = quaternion1->x3 - quaternion2->x3;
 
-    const float square_modulus1 = bgc_fp32_quaternion_get_square_modulus(quaternion1);
-    const float square_modulus2 = bgc_fp32_quaternion_get_square_modulus(quaternion2);
+    const float square_modulus1 = bgc_fp32_quaternion_get_square_magnitude(quaternion1);
+    const float square_modulus2 = bgc_fp32_quaternion_get_square_magnitude(quaternion2);
     const float square_distance = (ds0 * ds0 + dx1 * dx1) + (dx2 * dx2 + dx3 * dx3);
 
     if (square_modulus1 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT) {
@@ -1067,8 +1067,8 @@ inline int bgc_fp64_quaternion_are_close(const BGC_FP64_Quaternion* quaternion1,
     const double dx2 = quaternion1->x2 - quaternion2->x2;
     const double dx3 = quaternion1->x3 - quaternion2->x3;
 
-    const double square_modulus1 = bgc_fp64_quaternion_get_square_modulus(quaternion1);
-    const double square_modulus2 = bgc_fp64_quaternion_get_square_modulus(quaternion2);
+    const double square_modulus1 = bgc_fp64_quaternion_get_square_magnitude(quaternion1);
+    const double square_modulus2 = bgc_fp64_quaternion_get_square_magnitude(quaternion2);
     const double square_distance = (ds0 * ds0 + dx1 * dx1) + (dx2 * dx2 + dx3 * dx3);
 
     if (square_modulus1 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT) {
diff --git a/basic-geometry/slerp3.c b/basic-geometry/slerp3.c
index 8161d27..d951539 100644
--- a/basic-geometry/slerp3.c
+++ b/basic-geometry/slerp3.c
@@ -1,32 +1,32 @@
 #include "./slerp3.h"
 
-extern inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp);
-extern inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp);
+extern inline void bgc_fp32_slerp3_reset(BGC_FP32_Slerp3* slerp);
+extern inline void bgc_fp64_slerp3_reset(BGC_FP64_Slerp3* slerp);
 
-extern inline void bgc_fp32_slerp_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
-extern inline void bgc_fp64_slerp_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
+extern inline void bgc_fp32_slerp3_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
+extern inline void bgc_fp64_slerp3_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
 
-extern inline void bgc_fp32_slerp_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
-extern inline void bgc_fp64_slerp_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
+extern inline void bgc_fp32_slerp3_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end);
+extern inline void bgc_fp64_slerp3_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end);
 
-extern inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* versor, const BGC_FP32_Slerp3* slerp, const float phase);
-extern inline void bgc_fp64_slerp_get_phase_turn(BGC_FP64_Turn3* versor, const BGC_FP64_Slerp3* slerp, const double phase);
+extern inline void bgc_fp32_slerp3_get_phase_turn(BGC_FP32_Turn3* versor, const BGC_FP32_Slerp3* slerp, const float phase);
+extern inline void bgc_fp64_slerp3_get_phase_turn(BGC_FP64_Turn3* versor, const BGC_FP64_Slerp3* slerp, const double phase);
 
-extern inline void bgc_fp32_slerp_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
-extern inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
+extern inline void bgc_fp32_slerp3_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
+extern inline void bgc_fp64_slerp3_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
 
-extern inline void bgc_fp32_slerp_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
-extern inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
+extern inline void bgc_fp32_slerp3_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
+extern inline void bgc_fp64_slerp3_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
 
-extern inline void bgc_fp32_slerp_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
-extern inline void bgc_fp64_slerp_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
+extern inline void bgc_fp32_slerp3_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase);
+extern inline void bgc_fp64_slerp3_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase);
 
-void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment)
+void bgc_fp32_slerp3_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment)
 {
     const float square_vector = augment->_versor.x1 * augment->_versor.x1 + augment->_versor.x2 * augment->_versor.x2 + augment->_versor.x3 * augment->_versor.x3;
 
     if (isnan(square_vector)) {
-        bgc_fp32_slerp_reset(slerp);
+        bgc_fp32_slerp3_reset(slerp);
         return;
     }
 
@@ -62,12 +62,12 @@ void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, co
     slerp->_sine_weight.x3 =  multiplier * (augment->_versor.x3 * start->_versor.s0 - augment->_versor.x2 * start->_versor.x1 + augment->_versor.x1 * start->_versor.x2);
 }
 
-void bgc_fp64_slerp_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment)
+void bgc_fp64_slerp3_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment)
 {
     const double square_vector = augment->_versor.x1 * augment->_versor.x1 + augment->_versor.x2 * augment->_versor.x2 + augment->_versor.x3 * augment->_versor.x3;
 
     if (isnan(square_vector)) {
-        bgc_fp64_slerp_reset(slerp);
+        bgc_fp64_slerp3_reset(slerp);
         return;
     }
 
diff --git a/basic-geometry/slerp3.h b/basic-geometry/slerp3.h
index 0af260d..ffc1e13 100644
--- a/basic-geometry/slerp3.h
+++ b/basic-geometry/slerp3.h
@@ -7,7 +7,7 @@
 
 // =================== Reset ==================== //
 
-inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp)
+inline void bgc_fp32_slerp3_reset(BGC_FP32_Slerp3* slerp)
 {
     slerp->_cosine_weight.s0 = 1.0f;
     slerp->_cosine_weight.x1 = 0.0f;
@@ -22,7 +22,7 @@ inline void bgc_fp32_slerp_reset(BGC_FP32_Slerp3* slerp)
     slerp->radians = 0.0f;
 }
 
-inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp)
+inline void bgc_fp64_slerp3_reset(BGC_FP64_Slerp3* slerp)
 {
     slerp->_cosine_weight.s0 = 1.0;
     slerp->_cosine_weight.x1 = 0.0;
@@ -39,54 +39,54 @@ inline void bgc_fp64_slerp_reset(BGC_FP64_Slerp3* slerp)
 
 // ==================== Make ==================== //
 
-void bgc_fp32_slerp_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment);
-void bgc_fp64_slerp_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment);
+void bgc_fp32_slerp3_make(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* augment);
+void bgc_fp64_slerp3_make(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* augment);
 
 // ================= Make Full ================== //
 
-inline void bgc_fp32_slerp_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
+inline void bgc_fp32_slerp3_make_full(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
 {
     BGC_FP32_Turn3 augment;
 
     bgc_fp32_turn3_exclude(&augment, end, start);
 
-    bgc_fp32_slerp_make(slerp, start, &augment);
+    bgc_fp32_slerp3_make(slerp, start, &augment);
 }
 
-inline void bgc_fp64_slerp_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
+inline void bgc_fp64_slerp3_make_full(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
 {
     BGC_FP64_Turn3 augment;
 
     bgc_fp64_turn3_exclude(&augment, end, start);
 
-    bgc_fp64_slerp_make(slerp, start, &augment);
+    bgc_fp64_slerp3_make(slerp, start, &augment);
 }
 
 // =============== Make Shortened =============== //
 
-inline void bgc_fp32_slerp_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
+inline void bgc_fp32_slerp3_make_shortened(BGC_FP32_Slerp3* slerp, const BGC_FP32_Turn3* start, const BGC_FP32_Turn3* end)
 {
     BGC_FP32_Turn3 augment;
 
     bgc_fp32_turn3_exclude(&augment, end, start);
     bgc_fp32_turn3_shorten(&augment);
 
-    bgc_fp32_slerp_make(slerp, start, &augment);
+    bgc_fp32_slerp3_make(slerp, start, &augment);
 }
 
-inline void bgc_fp64_slerp_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
+inline void bgc_fp64_slerp3_make_shortened(BGC_FP64_Slerp3* slerp, const BGC_FP64_Turn3* start, const BGC_FP64_Turn3* end)
 {
     BGC_FP64_Turn3 augment;
 
     bgc_fp64_turn3_exclude(&augment, end, start);
     bgc_fp64_turn3_shorten(&augment);
 
-    bgc_fp64_slerp_make(slerp, start, &augment);
+    bgc_fp64_slerp3_make(slerp, start, &augment);
 }
 
 // =============== Get Phase Turn =============== //
 
-inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_Slerp3* slerp, const float phase)
+inline void bgc_fp32_slerp3_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_Slerp3* slerp, const float phase)
 {
     const float angle = slerp->radians * phase;
     const float cosine = cosf(angle);
@@ -100,7 +100,7 @@ inline void bgc_fp32_slerp_get_phase_turn(BGC_FP32_Turn3* turn, const BGC_FP32_S
     bgc_fp32_turn3_set_quaternion(turn, &q);
 }
 
-inline void bgc_fp64_slerp_get_phase_turn(BGC_FP64_Turn3* turn, const BGC_FP64_Slerp3* slerp, const double phase)
+inline void bgc_fp64_slerp3_get_phase_turn(BGC_FP64_Turn3* turn, const BGC_FP64_Slerp3* slerp, const double phase)
 {
     const double angle = slerp->radians * phase;
     const double cosine = cos(angle);
@@ -116,7 +116,7 @@ inline void bgc_fp64_slerp_get_phase_turn(BGC_FP64_Turn3* turn, const BGC_FP64_S
 
 // ========= Get Phase Rotation Matrix ========== //
 
-inline void bgc_fp32_slerp_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
+inline void bgc_fp32_slerp3_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotation_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
 {
     const float angle = slerp->radians * phase;
     const float cosine = cosf(angle);
@@ -130,7 +130,7 @@ inline void bgc_fp32_slerp_get_phase_rotation_matrix(BGC_FP32_Matrix3x3* rotatio
     bgc_fp32_quaternion_get_rotation_matrix(rotation_matrix, &q);
 }
 
-inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
+inline void bgc_fp64_slerp3_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotation_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
 {
     const double angle = slerp->radians * phase;
     const double cosine = cos(angle);
@@ -146,7 +146,7 @@ inline void bgc_fp64_slerp_get_phase_rotation_matrix(BGC_FP64_Matrix3x3* rotatio
 
 // ========== Get Phase Reverse Matrix ========== //
 
-inline void bgc_fp32_slerp_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
+inline void bgc_fp32_slerp3_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
 {
     const float angle = slerp->radians * phase;
     const float cosine = cosf(angle);
@@ -160,7 +160,7 @@ inline void bgc_fp32_slerp_get_phase_reverse_matrix(BGC_FP32_Matrix3x3* reverse_
     bgc_fp32_quaternion_get_reverse_matrix(reverse_matrix, &q);
 }
 
-inline void bgc_fp64_slerp_get_phase_reverse_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
+inline void bgc_fp64_slerp3_get_phase_reverse_matrix(BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
 {
     const double angle = slerp->radians * phase;
     const double cosine = cos(angle);
@@ -176,7 +176,7 @@ inline void bgc_fp64_slerp_get_phase_reverse_matrix(BGC_FP64_Matrix3x3* reverse_
 
 // ========== Get Phase Both Matrices =========== //
 
-inline void bgc_fp32_slerp_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
+inline void bgc_fp32_slerp3_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_matrix, BGC_FP32_Matrix3x3* reverse_matrix, const BGC_FP32_Slerp3* slerp, const float phase)
 {
     const float angle = slerp->radians * phase;
     const float cosine = cosf(angle);
@@ -190,7 +190,7 @@ inline void bgc_fp32_slerp_get_phase_both_matrices(BGC_FP32_Matrix3x3* rotation_
     bgc_fp32_quaternion_get_both_matrices(rotation_matrix, reverse_matrix, &q);
 }
 
-inline void bgc_fp64_slerp_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
+inline void bgc_fp64_slerp3_get_phase_both_matrices(BGC_FP64_Matrix3x3* rotation_matrix, BGC_FP64_Matrix3x3* reverse_matrix, const BGC_FP64_Slerp3* slerp, const double phase)
 {
     const double angle = slerp->radians * phase;
     const double cosine = cos(angle);
diff --git a/basic-geometry/turn3.c b/basic-geometry/turn3.c
index ecc7369..cc3a8ea 100644
--- a/basic-geometry/turn3.c
+++ b/basic-geometry/turn3.c
@@ -166,7 +166,7 @@ void bgc_fp32_turn3_set_rotation(BGC_FP32_Turn3* turn, const float x1, const flo
 
     bgc_fp32_quaternion_make(&turn->_versor, cosf(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
 
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&turn->_versor);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&turn->_versor);
 
     if (!bgc_fp32_is_square_unit(square_modulus)) {
         _bgc_fp32_turn3_normalize(turn, square_modulus);
@@ -195,7 +195,7 @@ void bgc_fp64_turn3_set_rotation(BGC_FP64_Turn3* turn, const double x1, const do
 
     bgc_fp64_quaternion_make(&turn->_versor, cos(half_angle), x1 * multiplier, x2 * multiplier, x3 * multiplier);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&turn->_versor);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&turn->_versor);
 
     if (!bgc_fp64_is_square_unit(square_modulus)) {
         _bgc_fp64_turn3_normalize(turn, square_modulus);
@@ -206,7 +206,7 @@ void bgc_fp64_turn3_set_rotation(BGC_FP64_Turn3* turn, const double x1, const do
 
 int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP32_Vector3* first, const BGC_FP32_Vector3* second)
 {
-    const float first_square_modulus = bgc_fp32_vector3_get_square_modulus(first);
+    const float first_square_modulus = bgc_fp32_vector3_get_squared_length(first);
 
     bgc_fp32_turn3_reset(turn);
 
@@ -214,7 +214,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP3
         return BGC_ERROR_TURN3_FIRST_VECTOR_ZERO;
     }
 
-    const float second_square_modulus = bgc_fp32_vector3_get_square_modulus(second);
+    const float second_square_modulus = bgc_fp32_vector3_get_squared_length(second);
 
     if (second_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
         return BGC_ERROR_TURN3_SECOND_VECTOR_ZERO;
@@ -226,7 +226,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP3
 
     const float square_product = first_square_modulus * second_square_modulus;
     const float dot_product = bgc_fp32_vector3_get_dot_product(first, second);
-    const float axis_square_modulus = bgc_fp32_vector3_get_square_modulus(&axis);
+    const float axis_square_modulus = bgc_fp32_vector3_get_squared_length(&axis);
 
     if (axis_square_modulus <= BGC_FP32_SQUARE_EPSILON * square_product) {
         if (dot_product < 0.0f) {
@@ -250,7 +250,7 @@ int bgc_fp32_turn3_find_direction_difference(BGC_FP32_Turn3* turn, const BGC_FP3
 
 int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP64_Vector3* first, const BGC_FP64_Vector3* second)
 {
-    const double first_square_modulus = bgc_fp64_vector3_get_square_modulus(first);
+    const double first_square_modulus = bgc_fp64_vector3_get_squared_length(first);
 
     bgc_fp64_turn3_reset(turn);
 
@@ -258,7 +258,7 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP6
         return BGC_ERROR_TURN3_FIRST_VECTOR_ZERO;
     }
 
-    const double second_square_modulus = bgc_fp64_vector3_get_square_modulus(second);
+    const double second_square_modulus = bgc_fp64_vector3_get_squared_length(second);
 
     if (second_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
         return BGC_ERROR_TURN3_SECOND_VECTOR_ZERO;
@@ -270,7 +270,7 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP6
 
     const double square_product = first_square_modulus * second_square_modulus;
     const double dot_product = bgc_fp64_vector3_get_dot_product(first, second);
-    const double axis_square_modulus = bgc_fp64_vector3_get_square_modulus(&axis);
+    const double axis_square_modulus = bgc_fp64_vector3_get_squared_length(&axis);
 
     if (axis_square_modulus <= BGC_FP64_SQUARE_EPSILON * square_product) {
         bgc_fp64_turn3_reset(turn);
@@ -297,13 +297,13 @@ int bgc_fp64_turn3_find_direction_difference(BGC_FP64_Turn3* turn, const BGC_FP6
 
 static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_main, BGC_FP32_Vector3* unit_branch, const BGC_FP32_Vector3* main, const BGC_FP32_Vector3* branch)
 {
-    const float main_square_modulus = bgc_fp32_vector3_get_square_modulus(main);
+    const float main_square_modulus = bgc_fp32_vector3_get_squared_length(main);
 
     if (main_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
         return _BGC_ERROR_TURN3_EMPTY_MAIN;
     }
 
-    const float branch_square_modulus = bgc_fp32_vector3_get_square_modulus(branch);
+    const float branch_square_modulus = bgc_fp32_vector3_get_squared_length(branch);
 
     if (branch_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
         return _BGC_ERROR_TURN3_EMPTY_BRANCH;
@@ -313,7 +313,7 @@ static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_mai
 
     bgc_fp32_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp32_vector3_get_dot_product(branch, unit_main));
 
-    const float orthogonal_square_modulus = bgc_fp32_vector3_get_square_modulus(unit_branch);
+    const float orthogonal_square_modulus = bgc_fp32_vector3_get_squared_length(unit_branch);
 
     if (orthogonal_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
         return _BGC_ERROR_TURN3_PAIR_PARALLEL;
@@ -326,13 +326,13 @@ static inline int _bgc_fp32_turn3_get_orthogonal_pair(BGC_FP32_Vector3* unit_mai
 
 static inline int _bgc_fp64_turn3_get_orthogonal_pair(BGC_FP64_Vector3* unit_main, BGC_FP64_Vector3* unit_branch, const BGC_FP64_Vector3* main, const BGC_FP64_Vector3* branch)
 {
-    const double main_square_modulus = bgc_fp64_vector3_get_square_modulus(main);
+    const double main_square_modulus = bgc_fp64_vector3_get_squared_length(main);
 
     if (main_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
         return _BGC_ERROR_TURN3_EMPTY_MAIN;
     }
 
-    const double branch_square_modulus = bgc_fp64_vector3_get_square_modulus(branch);
+    const double branch_square_modulus = bgc_fp64_vector3_get_squared_length(branch);
 
     if (branch_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
         return _BGC_ERROR_TURN3_EMPTY_BRANCH;
@@ -342,7 +342,7 @@ static inline int _bgc_fp64_turn3_get_orthogonal_pair(BGC_FP64_Vector3* unit_mai
 
     bgc_fp64_vector3_add_scaled(unit_branch, branch, unit_main, -bgc_fp64_vector3_get_dot_product(branch, unit_main));
 
-    const double orthogonal_square_modulus = bgc_fp64_vector3_get_square_modulus(unit_branch);
+    const double orthogonal_square_modulus = bgc_fp64_vector3_get_squared_length(unit_branch);
 
     if (orthogonal_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
         return _BGC_ERROR_TURN3_PAIR_PARALLEL;
@@ -363,7 +363,7 @@ static inline void _bgc_fp32_turn3_get_turning_quaternion(BGC_FP32_Quaternion* q
 
     const float dot_product = bgc_fp32_vector3_get_dot_product(unit_start, unit_end);
 
-    const float axis_square_modulus = bgc_fp32_vector3_get_square_modulus(&axis);
+    const float axis_square_modulus = bgc_fp32_vector3_get_squared_length(&axis);
 
     // unit_start and unit_end are parallel
     if (axis_square_modulus <= BGC_FP32_SQUARE_EPSILON) {
@@ -404,7 +404,7 @@ static inline void _bgc_fp64_turn3_get_turning_quaternion(BGC_FP64_Quaternion* q
 
     const double dot_product = bgc_fp64_vector3_get_dot_product(unit_start, unit_end);
 
-    const double axis_square_modulus = bgc_fp64_vector3_get_square_modulus(&axis);
+    const double axis_square_modulus = bgc_fp64_vector3_get_squared_length(&axis);
 
     // unit_start and unit_end are parallel
     if (axis_square_modulus <= BGC_FP64_SQUARE_EPSILON) {
@@ -477,7 +477,7 @@ int bgc_fp32_turn3_find_pair_difference(
     bgc_fp32_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1);
 
     // Making a final versor (a normalized quaternion)
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&turn->_versor);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&turn->_versor);
 
     if (!bgc_fp32_is_square_unit(square_modulus)) {
         _bgc_fp32_turn3_normalize(turn, square_modulus);
@@ -524,7 +524,7 @@ int bgc_fp64_turn3_find_pair_difference(
     bgc_fp64_quaternion_multiply_by_quaternion(&turn->_versor, &q2, &q1);
 
     // Making a final versor (a normalized quaternion)
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&turn->_versor);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&turn->_versor);
 
     if (!bgc_fp64_is_square_unit(square_modulus)) {
         _bgc_fp64_turn3_normalize(turn, square_modulus);
diff --git a/basic-geometry/turn3.h b/basic-geometry/turn3.h
index c063495..33b1c58 100644
--- a/basic-geometry/turn3.h
+++ b/basic-geometry/turn3.h
@@ -91,7 +91,7 @@ inline void bgc_fp32_turn3_set_quaternion(BGC_FP32_Turn3* turn, const BGC_FP32_Q
 {
     bgc_fp32_quaternion_copy(&turn->_versor, quaternion);
 
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(quaternion);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(quaternion);
 
     if (!bgc_fp32_is_square_unit(square_modulus)) {
         _bgc_fp32_turn3_normalize(turn, square_modulus);
@@ -102,7 +102,7 @@ inline void bgc_fp64_turn3_set_quaternion(BGC_FP64_Turn3* turn, const BGC_FP64_Q
 {
     bgc_fp64_quaternion_copy(&turn->_versor, quaternion);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(quaternion);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(quaternion);
 
     if (!bgc_fp64_is_square_unit(square_modulus)) {
         _bgc_fp64_turn3_normalize(turn, square_modulus);
@@ -187,7 +187,7 @@ inline void bgc_fp32_turn3_convert_to_fp64(BGC_FP64_Turn3* destination, const BG
 {
     bgc_fp32_quaternion_convert_to_fp64(&destination->_versor, &source->_versor);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&destination->_versor);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&destination->_versor);
 
     if (!bgc_fp64_is_square_unit(square_modulus)) {
         _bgc_fp64_turn3_normalize(destination, square_modulus);
@@ -198,7 +198,7 @@ inline void bgc_fp64_turn3_convert_to_fp32(BGC_FP32_Turn3* destination, const BG
 {
     bgc_fp64_quaternion_convert_to_fp32(&destination->_versor, &source->_versor);
 
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&destination->_versor);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&destination->_versor);
 
     if (!bgc_fp32_is_square_unit(square_modulus)) {
         _bgc_fp32_turn3_normalize(destination, square_modulus);
@@ -297,7 +297,7 @@ inline void bgc_fp32_turn3_combine(BGC_FP32_Turn3* combination, const BGC_FP32_T
 {
     bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor);
 
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&combination->_versor);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&combination->_versor);
 
     if (!bgc_fp32_is_square_unit(square_modulus)) {
         _bgc_fp32_turn3_normalize(combination, square_modulus);
@@ -308,7 +308,7 @@ inline void bgc_fp64_turn3_combine(BGC_FP64_Turn3* combination, const BGC_FP64_T
 {
     bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &second->_versor, &first->_versor);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&combination->_versor);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&combination->_versor);
 
     if (!bgc_fp64_is_square_unit(square_modulus)) {
         _bgc_fp64_turn3_normalize(combination, square_modulus);
@@ -325,7 +325,7 @@ inline void bgc_fp32_turn3_combine3(BGC_FP32_Turn3* combination, const BGC_FP32_
 
     bgc_fp32_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product);
 
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&combination->_versor);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&combination->_versor);
 
     if (!bgc_fp32_is_square_unit(square_modulus)) {
         _bgc_fp32_turn3_normalize(combination, square_modulus);
@@ -340,7 +340,7 @@ inline void bgc_fp64_turn3_combine3(BGC_FP64_Turn3* combination, const BGC_FP64_
 
     bgc_fp64_quaternion_multiply_by_quaternion(&combination->_versor, &third->_versor, &product);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&combination->_versor);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&combination->_versor);
 
     if (!bgc_fp64_is_square_unit(square_modulus)) {
         _bgc_fp64_turn3_normalize(combination, square_modulus);
@@ -353,7 +353,7 @@ inline void bgc_fp32_turn3_exclude(BGC_FP32_Turn3* difference, const BGC_FP32_Tu
 {
     bgc_fp32_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor);
 
-    const float square_modulus = bgc_fp32_quaternion_get_square_modulus(&difference->_versor);
+    const float square_modulus = bgc_fp32_quaternion_get_square_magnitude(&difference->_versor);
 
     if (!bgc_fp32_is_square_unit(square_modulus)) {
         _bgc_fp32_turn3_normalize(difference, square_modulus);
@@ -364,7 +364,7 @@ inline void bgc_fp64_turn3_exclude(BGC_FP64_Turn3* difference, const BGC_FP64_Tu
 {
     bgc_fp64_quaternion_multiply_by_conjugate(&difference->_versor, &base->_versor, &excludant->_versor);
 
-    const double square_modulus = bgc_fp64_quaternion_get_square_modulus(&difference->_versor);
+    const double square_modulus = bgc_fp64_quaternion_get_square_magnitude(&difference->_versor);
 
     if (!bgc_fp64_is_square_unit(square_modulus)) {
         _bgc_fp64_turn3_normalize(difference, square_modulus);
@@ -541,14 +541,14 @@ inline int bgc_fp32_turn3_are_close(const BGC_FP32_Turn3* turn1, const BGC_FP32_
 {
     BGC_FP32_Quaternion difference;
     bgc_fp32_quaternion_subtract(&difference, &turn1->_versor, &turn2->_versor);
-    return bgc_fp32_quaternion_get_square_modulus(&difference) <= BGC_FP32_SQUARE_EPSILON;
+    return bgc_fp32_quaternion_get_square_magnitude(&difference) <= BGC_FP32_SQUARE_EPSILON;
 }
 
 inline int bgc_fp64_turn3_are_close(const BGC_FP64_Turn3* turn1, const BGC_FP64_Turn3* turn2)
 {
     BGC_FP64_Quaternion difference;
     bgc_fp64_quaternion_subtract(&difference, &turn1->_versor, &turn2->_versor);
-    return bgc_fp64_quaternion_get_square_modulus(&difference) <= BGC_FP64_SQUARE_EPSILON;
+    return bgc_fp64_quaternion_get_square_magnitude(&difference) <= BGC_FP64_SQUARE_EPSILON;
 }
 
 #endif
diff --git a/basic-geometry/vector2.c b/basic-geometry/vector2.c
index e4f3a3b..baa52fb 100644
--- a/basic-geometry/vector2.c
+++ b/basic-geometry/vector2.c
@@ -6,11 +6,11 @@ extern inline void bgc_fp64_vector2_reset(BGC_FP64_Vector2* vector);
 extern inline void bgc_fp32_vector2_make(BGC_FP32_Vector2* destination, const float x1, const float x2);
 extern inline void bgc_fp64_vector2_make(BGC_FP64_Vector2* destination, const double x1, const double x2);
 
-extern inline float bgc_fp32_vector2_get_square_modulus(const BGC_FP32_Vector2* vector);
-extern inline double bgc_fp64_vector2_get_square_modulus(const BGC_FP64_Vector2* vector);
+extern inline float bgc_fp32_vector2_get_squared_length(const BGC_FP32_Vector2* vector);
+extern inline double bgc_fp64_vector2_get_squared_length(const BGC_FP64_Vector2* vector);
 
-extern inline float bgc_fp32_vector2_get_modulus(const BGC_FP32_Vector2* vector);
-extern inline double bgc_fp64_vector2_get_modulus(const BGC_FP64_Vector2* vector);
+extern inline float bgc_fp32_vector2_get_length(const BGC_FP32_Vector2* vector);
+extern inline double bgc_fp64_vector2_get_length(const BGC_FP64_Vector2* vector);
 
 extern inline int bgc_fp32_vector2_is_zero(const BGC_FP32_Vector2* vector);
 extern inline int bgc_fp64_vector2_is_zero(const BGC_FP64_Vector2* vector);
@@ -103,14 +103,14 @@ extern inline int bgc_fp64_vector2_get_attitude(const BGC_FP64_Vector2* vector1,
 
 float bgc_fp32_vector2_get_angle(const BGC_FP32_Vector2* vector1, const BGC_FP32_Vector2* vector2, const int angle_unit)
 {
-    const float square_modulus1 = bgc_fp32_vector2_get_square_modulus(vector1);
+    const float square_modulus1 = bgc_fp32_vector2_get_squared_length(vector1);
 
     // square_modulus1 != square_modulus1 is check for NaN value at square_modulus1
     if (square_modulus1 <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus1)) {
         return 0.0f;
     }
 
-    const float square_modulus2 = bgc_fp32_vector2_get_square_modulus(vector2);
+    const float square_modulus2 = bgc_fp32_vector2_get_squared_length(vector2);
 
     // square_modulus2 != square_modulus2 is check for NaN value at square_modulus2
     if (square_modulus2 <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus2)) {
@@ -128,14 +128,14 @@ float bgc_fp32_vector2_get_angle(const BGC_FP32_Vector2* vector1, const BGC_FP32
 
 double bgc_fp64_vector2_get_angle(const BGC_FP64_Vector2* vector1, const BGC_FP64_Vector2* vector2, const int angle_unit)
 {
-    const double square_modulus1 = bgc_fp64_vector2_get_square_modulus(vector1);
+    const double square_modulus1 = bgc_fp64_vector2_get_squared_length(vector1);
 
     // square_modulus1 != square_modulus1 is check for NaN value at square_modulus1
     if (square_modulus1 <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus1)) {
         return 0.0;
     }
 
-    const double square_modulus2 = bgc_fp64_vector2_get_square_modulus(vector2);
+    const double square_modulus2 = bgc_fp64_vector2_get_squared_length(vector2);
 
     // square_modulus2 != square_modulus2 is check for NaN value at square_modulus2
     if (square_modulus2 <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus2)) {
diff --git a/basic-geometry/vector2.h b/basic-geometry/vector2.h
index 8be31af..fedf71e 100644
--- a/basic-geometry/vector2.h
+++ b/basic-geometry/vector2.h
@@ -37,46 +37,46 @@ inline void bgc_fp64_vector2_make(BGC_FP64_Vector2* destination, const double x1
 
 // ================== Modulus =================== //
 
-inline float bgc_fp32_vector2_get_square_modulus(const BGC_FP32_Vector2* vector)
+inline float bgc_fp32_vector2_get_squared_length(const BGC_FP32_Vector2* vector)
 {
     return vector->x1 * vector->x1 + vector->x2 * vector->x2;
 }
 
-inline double bgc_fp64_vector2_get_square_modulus(const BGC_FP64_Vector2* vector)
+inline double bgc_fp64_vector2_get_squared_length(const BGC_FP64_Vector2* vector)
 {
     return vector->x1 * vector->x1 + vector->x2 * vector->x2;
 }
 
-inline float bgc_fp32_vector2_get_modulus(const BGC_FP32_Vector2* vector)
+inline float bgc_fp32_vector2_get_length(const BGC_FP32_Vector2* vector)
 {
-    return sqrtf(bgc_fp32_vector2_get_square_modulus(vector));
+    return sqrtf(bgc_fp32_vector2_get_squared_length(vector));
 }
 
-inline double bgc_fp64_vector2_get_modulus(const BGC_FP64_Vector2* vector)
+inline double bgc_fp64_vector2_get_length(const BGC_FP64_Vector2* vector)
 {
-    return sqrt(bgc_fp64_vector2_get_square_modulus(vector));
+    return sqrt(bgc_fp64_vector2_get_squared_length(vector));
 }
 
 // ================= Comparison ================= //
 
 inline int bgc_fp32_vector2_is_zero(const BGC_FP32_Vector2* vector)
 {
-    return bgc_fp32_vector2_get_square_modulus(vector) <= BGC_FP32_SQUARE_EPSILON;
+    return bgc_fp32_vector2_get_squared_length(vector) <= BGC_FP32_SQUARE_EPSILON;
 }
 
 inline int bgc_fp64_vector2_is_zero(const BGC_FP64_Vector2* vector)
 {
-    return bgc_fp64_vector2_get_square_modulus(vector) <= BGC_FP64_SQUARE_EPSILON;
+    return bgc_fp64_vector2_get_squared_length(vector) <= BGC_FP64_SQUARE_EPSILON;
 }
 
 inline int bgc_fp32_vector2_is_unit(const BGC_FP32_Vector2* vector)
 {
-    return bgc_fp32_is_square_unit(bgc_fp32_vector2_get_square_modulus(vector));
+    return bgc_fp32_is_square_unit(bgc_fp32_vector2_get_squared_length(vector));
 }
 
 inline int bgc_fp64_vector2_is_unit(const BGC_FP64_Vector2* vector)
 {
-    return bgc_fp64_is_square_unit(bgc_fp64_vector2_get_square_modulus(vector));
+    return bgc_fp64_is_square_unit(bgc_fp64_vector2_get_squared_length(vector));
 }
 
 // ==================== Copy ==================== //
@@ -339,7 +339,7 @@ inline void bgc_fp64_vector2_get_reverse(BGC_FP64_Vector2* reverse, const BGC_FP
 
 inline int bgc_fp32_vector2_normalize(BGC_FP32_Vector2* vector)
 {
-    const float square_modulus = bgc_fp32_vector2_get_square_modulus(vector);
+    const float square_modulus = bgc_fp32_vector2_get_squared_length(vector);
 
     if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -359,7 +359,7 @@ inline int bgc_fp32_vector2_normalize(BGC_FP32_Vector2* vector)
 
 inline int bgc_fp64_vector2_normalize(BGC_FP64_Vector2* vector)
 {
-    const double square_modulus = bgc_fp64_vector2_get_square_modulus(vector);
+    const double square_modulus = bgc_fp64_vector2_get_squared_length(vector);
 
     if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -379,7 +379,7 @@ inline int bgc_fp64_vector2_normalize(BGC_FP64_Vector2* vector)
 
 inline int bgc_fp32_vector2_get_normalized(BGC_FP32_Vector2* normalized, const BGC_FP32_Vector2* vector)
 {
-    const float square_modulus = bgc_fp32_vector2_get_square_modulus(vector);
+    const float square_modulus = bgc_fp32_vector2_get_squared_length(vector);
 
     if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         bgc_fp32_vector2_reset(normalized);
@@ -397,7 +397,7 @@ inline int bgc_fp32_vector2_get_normalized(BGC_FP32_Vector2* normalized, const B
 
 inline int bgc_fp64_vector2_get_normalized(BGC_FP64_Vector2* normalized, const BGC_FP64_Vector2* vector)
 {
-    const double square_modulus = bgc_fp64_vector2_get_square_modulus(vector);
+    const double square_modulus = bgc_fp64_vector2_get_squared_length(vector);
 
     if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         bgc_fp64_vector2_reset(normalized);
@@ -489,8 +489,8 @@ inline int bgc_fp64_vector2_are_close_enough(const BGC_FP64_Vector2* vector1, co
 
 inline int bgc_fp32_vector2_are_close(const BGC_FP32_Vector2* vector1, const BGC_FP32_Vector2* vector2)
 {
-    const float square_modulus1 = bgc_fp32_vector2_get_square_modulus(vector1);
-    const float square_modulus2 = bgc_fp32_vector2_get_square_modulus(vector2);
+    const float square_modulus1 = bgc_fp32_vector2_get_squared_length(vector1);
+    const float square_modulus2 = bgc_fp32_vector2_get_squared_length(vector2);
     const float square_distance = bgc_fp32_vector2_get_square_distance(vector1, vector2);
 
     if (square_modulus1 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT) {
@@ -502,8 +502,8 @@ inline int bgc_fp32_vector2_are_close(const BGC_FP32_Vector2* vector1, const BGC
 
 inline int bgc_fp64_vector2_are_close(const BGC_FP64_Vector2* vector1, const BGC_FP64_Vector2* vector2)
 {
-    const double square_modulus1 = bgc_fp64_vector2_get_square_modulus(vector1);
-    const double square_modulus2 = bgc_fp64_vector2_get_square_modulus(vector2);
+    const double square_modulus1 = bgc_fp64_vector2_get_squared_length(vector1);
+    const double square_modulus2 = bgc_fp64_vector2_get_squared_length(vector2);
     const double square_distance = bgc_fp64_vector2_get_square_distance(vector1, vector2);
 
     if (square_modulus1 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT) {
@@ -518,13 +518,13 @@ inline int bgc_fp64_vector2_are_close(const BGC_FP64_Vector2* vector1, const BGC
 
 inline int bgc_fp32_vector2_are_parallel(const BGC_FP32_Vector2* vector1, const BGC_FP32_Vector2* vector2)
 {
-    const float square_modulus1 = bgc_fp32_vector2_get_square_modulus(vector1);
+    const float square_modulus1 = bgc_fp32_vector2_get_squared_length(vector1);
 
     if (square_modulus1 <= BGC_FP32_SQUARE_EPSILON) {
         return 1;
     }
 
-    const float square_modulus2 = bgc_fp32_vector2_get_square_modulus(vector2);
+    const float square_modulus2 = bgc_fp32_vector2_get_squared_length(vector2);
 
     if (square_modulus2 <= BGC_FP32_SQUARE_EPSILON) {
         return 1;
@@ -537,13 +537,13 @@ inline int bgc_fp32_vector2_are_parallel(const BGC_FP32_Vector2* vector1, const
 
 inline int bgc_fp64_vector2_are_parallel(const BGC_FP64_Vector2* vector1, const BGC_FP64_Vector2* vector2)
 {
-    const double square_modulus1 = bgc_fp64_vector2_get_square_modulus(vector1);
+    const double square_modulus1 = bgc_fp64_vector2_get_squared_length(vector1);
 
     if (square_modulus1 <= BGC_FP64_SQUARE_EPSILON) {
         return 1;
     }
 
-    const double square_modulus2 = bgc_fp64_vector2_get_square_modulus(vector2);
+    const double square_modulus2 = bgc_fp64_vector2_get_squared_length(vector2);
 
     if (square_modulus2 <= BGC_FP64_SQUARE_EPSILON) {
         return 1;
@@ -558,13 +558,13 @@ inline int bgc_fp64_vector2_are_parallel(const BGC_FP64_Vector2* vector1, const
 
 inline int bgc_fp32_vector2_are_orthogonal(const BGC_FP32_Vector2* vector1, const BGC_FP32_Vector2* vector2)
 {
-    const float square_modulus1 = bgc_fp32_vector2_get_square_modulus(vector1);
+    const float square_modulus1 = bgc_fp32_vector2_get_squared_length(vector1);
 
     if (square_modulus1 <= BGC_FP32_SQUARE_EPSILON) {
         return 1;
     }
 
-    const float square_modulus2 = bgc_fp32_vector2_get_square_modulus(vector2);
+    const float square_modulus2 = bgc_fp32_vector2_get_squared_length(vector2);
 
     if (square_modulus2 <= BGC_FP32_SQUARE_EPSILON) {
         return 1;
@@ -577,13 +577,13 @@ inline int bgc_fp32_vector2_are_orthogonal(const BGC_FP32_Vector2* vector1, cons
 
 inline int bgc_fp64_vector2_are_orthogonal(const BGC_FP64_Vector2* vector1, const BGC_FP64_Vector2* vector2)
 {
-    const double square_modulus1 = bgc_fp64_vector2_get_square_modulus(vector1);
+    const double square_modulus1 = bgc_fp64_vector2_get_squared_length(vector1);
 
     if (square_modulus1 <= BGC_FP64_SQUARE_EPSILON) {
         return 1;
     }
 
-    const double square_modulus2 = bgc_fp64_vector2_get_square_modulus(vector2);
+    const double square_modulus2 = bgc_fp64_vector2_get_squared_length(vector2);
 
     if (square_modulus2 <= BGC_FP64_SQUARE_EPSILON) {
         return 1;
@@ -599,8 +599,8 @@ inline int bgc_fp64_vector2_are_orthogonal(const BGC_FP64_Vector2* vector1, cons
 
 inline int bgc_fp32_vector2_get_attitude(const BGC_FP32_Vector2* vector1, const BGC_FP32_Vector2* vector2)
 {
-    const float square_modulus1 = bgc_fp32_vector2_get_square_modulus(vector1);
-    const float square_modulus2 = bgc_fp32_vector2_get_square_modulus(vector2);
+    const float square_modulus1 = bgc_fp32_vector2_get_squared_length(vector1);
+    const float square_modulus2 = bgc_fp32_vector2_get_squared_length(vector2);
 
     if (square_modulus1 <= BGC_FP32_SQUARE_EPSILON || square_modulus2 <= BGC_FP32_SQUARE_EPSILON) {
         return BGC_ATTITUDE_ZERO;
@@ -625,8 +625,8 @@ inline int bgc_fp32_vector2_get_attitude(const BGC_FP32_Vector2* vector1, const
 
 inline int bgc_fp64_vector2_get_attitude(const BGC_FP64_Vector2* vector1, const BGC_FP64_Vector2* vector2)
 {
-    const double square_modulus1 = bgc_fp64_vector2_get_square_modulus(vector1);
-    const double square_modulus2 = bgc_fp64_vector2_get_square_modulus(vector2);
+    const double square_modulus1 = bgc_fp64_vector2_get_squared_length(vector1);
+    const double square_modulus2 = bgc_fp64_vector2_get_squared_length(vector2);
 
     if (square_modulus1 <= BGC_FP64_SQUARE_EPSILON || square_modulus2 <= BGC_FP64_SQUARE_EPSILON) {
         return BGC_ATTITUDE_ZERO;
diff --git a/basic-geometry/vector3.c b/basic-geometry/vector3.c
index 8c038e2..3a8430c 100644
--- a/basic-geometry/vector3.c
+++ b/basic-geometry/vector3.c
@@ -6,11 +6,11 @@ extern inline void bgc_fp64_vector3_reset(BGC_FP64_Vector3* vector);
 extern inline void bgc_fp32_vector3_make(BGC_FP32_Vector3* destination, const float x1, const float x2, const float x3);
 extern inline void bgc_fp64_vector3_make(BGC_FP64_Vector3* destination, const double x1, const double x2, const double x3);
 
-extern inline float bgc_fp32_vector3_get_square_modulus(const BGC_FP32_Vector3* vector);
-extern inline double bgc_fp64_vector3_get_square_modulus(const BGC_FP64_Vector3* vector);
+extern inline float bgc_fp32_vector3_get_squared_length(const BGC_FP32_Vector3* vector);
+extern inline double bgc_fp64_vector3_get_squared_length(const BGC_FP64_Vector3* vector);
 
-extern inline float bgc_fp32_vector3_get_modulus(const BGC_FP32_Vector3* vector);
-extern inline double bgc_fp64_vector3_get_modulus(const BGC_FP64_Vector3* vector);
+extern inline float bgc_fp32_vector3_get_length(const BGC_FP32_Vector3* vector);
+extern inline double bgc_fp64_vector3_get_length(const BGC_FP64_Vector3* vector);
 
 extern inline int bgc_fp32_vector3_is_zero(const BGC_FP32_Vector3* vector);
 extern inline int bgc_fp64_vector3_is_zero(const BGC_FP64_Vector3* vector);
@@ -109,14 +109,14 @@ extern inline int bgc_fp64_vector3_get_attitude(const BGC_FP64_Vector3* vector1,
 
 float bgc_fp32_vector3_get_angle(const BGC_FP32_Vector3* vector1, const BGC_FP32_Vector3* vector2, const int angle_unit)
 {
-    const float square_modulus1 = bgc_fp32_vector3_get_square_modulus(vector1);
+    const float square_modulus1 = bgc_fp32_vector3_get_squared_length(vector1);
 
     // square_modulus1 != square_modulus1 is check for NaN value at square_modulus1
     if (square_modulus1 <= BGC_FP32_SQUARE_EPSILON || square_modulus1 != square_modulus1) {
         return 0.0f;
     }
 
-    const float square_modulus2 = bgc_fp32_vector3_get_square_modulus(vector2);
+    const float square_modulus2 = bgc_fp32_vector3_get_squared_length(vector2);
 
     // square_modulus2 != square_modulus2 is check for NaN value at square_modulus2
     if (square_modulus2 <= BGC_FP32_SQUARE_EPSILON || square_modulus2 != square_modulus2) {
@@ -129,21 +129,21 @@ float bgc_fp32_vector3_get_angle(const BGC_FP32_Vector3* vector1, const BGC_FP32
 
     const float scalar = bgc_fp32_vector3_get_dot_product(vector1, vector2);
 
-    const float cross = bgc_fp32_vector3_get_modulus(&cross_product);
+    const float cross = bgc_fp32_vector3_get_length(&cross_product);
 
     return bgc_fp32_radians_to_units(atan2f(cross, scalar), angle_unit);
 }
 
 double bgc_fp64_vector3_get_angle(const BGC_FP64_Vector3* vector1, const BGC_FP64_Vector3* vector2, const int angle_unit)
 {
-    const double square_modulus1 = bgc_fp64_vector3_get_square_modulus(vector1);
+    const double square_modulus1 = bgc_fp64_vector3_get_squared_length(vector1);
 
     // square_modulus1 != square_modulus1 is check for NaN value at square_modulus1
     if (square_modulus1 <= BGC_FP64_SQUARE_EPSILON || square_modulus1 != square_modulus1) {
         return 0.0;
     }
 
-    const double square_modulus2 = bgc_fp64_vector3_get_square_modulus(vector2);
+    const double square_modulus2 = bgc_fp64_vector3_get_squared_length(vector2);
 
     // square_modulus2 != square_modulus2 is check for NaN value at square_modulus2
     if (square_modulus2 <= BGC_FP64_SQUARE_EPSILON || square_modulus2 != square_modulus2) {
@@ -156,7 +156,7 @@ double bgc_fp64_vector3_get_angle(const BGC_FP64_Vector3* vector1, const BGC_FP6
 
     const double scalar = bgc_fp64_vector3_get_dot_product(vector1, vector2);
 
-    const double cross = bgc_fp64_vector3_get_modulus(&cross_product);
+    const double cross = bgc_fp64_vector3_get_length(&cross_product);
 
     return bgc_fp64_radians_to_units(atan2(cross, scalar), angle_unit);
 }
diff --git a/basic-geometry/vector3.h b/basic-geometry/vector3.h
index 9c8d8a9..8980730 100644
--- a/basic-geometry/vector3.h
+++ b/basic-geometry/vector3.h
@@ -41,46 +41,46 @@ inline void bgc_fp64_vector3_make(BGC_FP64_Vector3* destination, const double x1
 
 // ================== Modulus =================== //
 
-inline float bgc_fp32_vector3_get_square_modulus(const BGC_FP32_Vector3* vector)
+inline float bgc_fp32_vector3_get_squared_length(const BGC_FP32_Vector3* vector)
 {
     return vector->x1 * vector->x1 + vector->x2 * vector->x2 + vector->x3 * vector->x3;
 }
 
-inline double bgc_fp64_vector3_get_square_modulus(const BGC_FP64_Vector3* vector)
+inline double bgc_fp64_vector3_get_squared_length(const BGC_FP64_Vector3* vector)
 {
     return vector->x1 * vector->x1 + vector->x2 * vector->x2 + vector->x3 * vector->x3;
 }
 
-inline float bgc_fp32_vector3_get_modulus(const BGC_FP32_Vector3* vector)
+inline float bgc_fp32_vector3_get_length(const BGC_FP32_Vector3* vector)
 {
-    return sqrtf(bgc_fp32_vector3_get_square_modulus(vector));
+    return sqrtf(bgc_fp32_vector3_get_squared_length(vector));
 }
 
-inline double bgc_fp64_vector3_get_modulus(const BGC_FP64_Vector3* vector)
+inline double bgc_fp64_vector3_get_length(const BGC_FP64_Vector3* vector)
 {
-    return sqrt(bgc_fp64_vector3_get_square_modulus(vector));
+    return sqrt(bgc_fp64_vector3_get_squared_length(vector));
 }
 
 // ================= Comparison ================= //
 
 inline int bgc_fp32_vector3_is_zero(const BGC_FP32_Vector3* vector)
 {
-    return bgc_fp32_vector3_get_square_modulus(vector) <= BGC_FP32_SQUARE_EPSILON;
+    return bgc_fp32_vector3_get_squared_length(vector) <= BGC_FP32_SQUARE_EPSILON;
 }
 
 inline int bgc_fp64_vector3_is_zero(const BGC_FP64_Vector3* vector)
 {
-    return bgc_fp64_vector3_get_square_modulus(vector) <= BGC_FP64_SQUARE_EPSILON;
+    return bgc_fp64_vector3_get_squared_length(vector) <= BGC_FP64_SQUARE_EPSILON;
 }
 
 inline int bgc_fp32_vector3_is_unit(const BGC_FP32_Vector3* vector)
 {
-    return bgc_fp32_is_square_unit(bgc_fp32_vector3_get_square_modulus(vector));
+    return bgc_fp32_is_square_unit(bgc_fp32_vector3_get_squared_length(vector));
 }
 
 inline int bgc_fp64_vector3_is_unit(const BGC_FP64_Vector3* vector)
 {
-    return bgc_fp64_is_square_unit(bgc_fp64_vector3_get_square_modulus(vector));
+    return bgc_fp64_is_square_unit(bgc_fp64_vector3_get_squared_length(vector));
 }
 
 // ==================== Copy ==================== //
@@ -375,7 +375,7 @@ inline void bgc_fp64_vector3_get_reverse(BGC_FP64_Vector3* reverse, const BGC_FP
 
 inline int bgc_fp32_vector3_normalize(BGC_FP32_Vector3* vector)
 {
-    const float square_modulus = bgc_fp32_vector3_get_square_modulus(vector);
+    const float square_modulus = bgc_fp32_vector3_get_squared_length(vector);
 
     if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -396,7 +396,7 @@ inline int bgc_fp32_vector3_normalize(BGC_FP32_Vector3* vector)
 
 inline int bgc_fp64_vector3_normalize(BGC_FP64_Vector3* vector)
 {
-    const double square_modulus = bgc_fp64_vector3_get_square_modulus(vector);
+    const double square_modulus = bgc_fp64_vector3_get_squared_length(vector);
 
     if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         return BGC_FAILURE;
@@ -417,7 +417,7 @@ inline int bgc_fp64_vector3_normalize(BGC_FP64_Vector3* vector)
 
 inline int bgc_fp32_vector3_get_normalized(BGC_FP32_Vector3* normalized, const BGC_FP32_Vector3* vector)
 {
-    const float square_modulus = bgc_fp32_vector3_get_square_modulus(vector);
+    const float square_modulus = bgc_fp32_vector3_get_squared_length(vector);
 
     if (square_modulus <= BGC_FP32_SQUARE_EPSILON || isnan(square_modulus)) {
         bgc_fp32_vector3_reset(normalized);
@@ -435,7 +435,7 @@ inline int bgc_fp32_vector3_get_normalized(BGC_FP32_Vector3* normalized, const B
 
 inline int bgc_fp64_vector3_get_normalized(BGC_FP64_Vector3* normalized, const BGC_FP64_Vector3* vector)
 {
-    const double square_modulus = bgc_fp64_vector3_get_square_modulus(vector);
+    const double square_modulus = bgc_fp64_vector3_get_squared_length(vector);
 
     if (square_modulus <= BGC_FP64_SQUARE_EPSILON || isnan(square_modulus)) {
         bgc_fp64_vector3_reset(normalized);
@@ -579,8 +579,8 @@ inline int bgc_fp64_vector3_are_close_enough(const BGC_FP64_Vector3* vector1, co
 
 inline int bgc_fp32_vector3_are_close(const BGC_FP32_Vector3* vector1, const BGC_FP32_Vector3* vector2)
 {
-    const float square_modulus1 = bgc_fp32_vector3_get_square_modulus(vector1);
-    const float square_modulus2 = bgc_fp32_vector3_get_square_modulus(vector2);
+    const float square_modulus1 = bgc_fp32_vector3_get_squared_length(vector1);
+    const float square_modulus2 = bgc_fp32_vector3_get_squared_length(vector2);
     const float square_distance = bgc_fp32_vector3_get_square_distance(vector1, vector2);
 
     if (square_modulus1 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP32_EPSILON_EFFECTIVENESS_LIMIT) {
@@ -592,8 +592,8 @@ inline int bgc_fp32_vector3_are_close(const BGC_FP32_Vector3* vector1, const BGC
 
 inline int bgc_fp64_vector3_are_close(const BGC_FP64_Vector3* vector1, const BGC_FP64_Vector3* vector2)
 {
-    const double square_modulus1 = bgc_fp64_vector3_get_square_modulus(vector1);
-    const double square_modulus2 = bgc_fp64_vector3_get_square_modulus(vector2);
+    const double square_modulus1 = bgc_fp64_vector3_get_squared_length(vector1);
+    const double square_modulus2 = bgc_fp64_vector3_get_squared_length(vector2);
     const double square_distance = bgc_fp64_vector3_get_square_distance(vector1, vector2);
 
     if (square_modulus1 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT || square_modulus2 <= BGC_FP64_EPSILON_EFFECTIVENESS_LIMIT) {
@@ -607,8 +607,8 @@ inline int bgc_fp64_vector3_are_close(const BGC_FP64_Vector3* vector1, const BGC
 
 inline int bgc_fp32_vector3_are_parallel(const BGC_FP32_Vector3* vector1, const BGC_FP32_Vector3* vector2)
 {
-    const float square_modulus1 = bgc_fp32_vector3_get_square_modulus(vector1);
-    const float square_modulus2 = bgc_fp32_vector3_get_square_modulus(vector2);
+    const float square_modulus1 = bgc_fp32_vector3_get_squared_length(vector1);
+    const float square_modulus2 = bgc_fp32_vector3_get_squared_length(vector2);
 
     if (square_modulus1 <= BGC_FP32_SQUARE_EPSILON || square_modulus2 <= BGC_FP32_SQUARE_EPSILON) {
         return 1;
@@ -618,13 +618,13 @@ inline int bgc_fp32_vector3_are_parallel(const BGC_FP32_Vector3* vector1, const
 
     bgc_fp32_vector3_get_cross_product(&product, vector1, vector2);
 
-    return bgc_fp32_vector3_get_square_modulus(&product) <= BGC_FP32_SQUARE_EPSILON * square_modulus1 * square_modulus2;
+    return bgc_fp32_vector3_get_squared_length(&product) <= BGC_FP32_SQUARE_EPSILON * square_modulus1 * square_modulus2;
 }
 
 inline int bgc_fp64_vector3_are_parallel(const BGC_FP64_Vector3* vector1, const BGC_FP64_Vector3* vector2)
 {
-    const double square_modulus1 = bgc_fp64_vector3_get_square_modulus(vector1);
-    const double square_modulus2 = bgc_fp64_vector3_get_square_modulus(vector2);
+    const double square_modulus1 = bgc_fp64_vector3_get_squared_length(vector1);
+    const double square_modulus2 = bgc_fp64_vector3_get_squared_length(vector2);
 
     if (square_modulus1 <= BGC_FP64_SQUARE_EPSILON || square_modulus2 <= BGC_FP64_SQUARE_EPSILON) {
         return 1;
@@ -634,15 +634,15 @@ inline int bgc_fp64_vector3_are_parallel(const BGC_FP64_Vector3* vector1, const
 
     bgc_fp64_vector3_get_cross_product(&product, vector1, vector2);
 
-    return bgc_fp64_vector3_get_square_modulus(&product) <= BGC_FP64_SQUARE_EPSILON * square_modulus1 * square_modulus2;
+    return bgc_fp64_vector3_get_squared_length(&product) <= BGC_FP64_SQUARE_EPSILON * square_modulus1 * square_modulus2;
 }
 
 // ================= Orthogonal ================= //
 
 inline int bgc_fp32_vector3_are_orthogonal(const BGC_FP32_Vector3* vector1, const BGC_FP32_Vector3* vector2)
 {
-    const float square_modulus1 = bgc_fp32_vector3_get_square_modulus(vector1);
-    const float square_modulus2 = bgc_fp32_vector3_get_square_modulus(vector2);
+    const float square_modulus1 = bgc_fp32_vector3_get_squared_length(vector1);
+    const float square_modulus2 = bgc_fp32_vector3_get_squared_length(vector2);
 
     if (square_modulus1 <= BGC_FP32_SQUARE_EPSILON || square_modulus2 <= BGC_FP32_SQUARE_EPSILON) {
         return 1;
@@ -655,8 +655,8 @@ inline int bgc_fp32_vector3_are_orthogonal(const BGC_FP32_Vector3* vector1, cons
 
 inline int bgc_fp64_vector3_are_orthogonal(const BGC_FP64_Vector3* vector1, const BGC_FP64_Vector3* vector2)
 {
-    const double square_modulus1 = bgc_fp64_vector3_get_square_modulus(vector1);
-    const double square_modulus2 = bgc_fp64_vector3_get_square_modulus(vector2);
+    const double square_modulus1 = bgc_fp64_vector3_get_squared_length(vector1);
+    const double square_modulus2 = bgc_fp64_vector3_get_squared_length(vector2);
 
     if (square_modulus1 <= BGC_FP64_SQUARE_EPSILON || square_modulus2 <= BGC_FP64_SQUARE_EPSILON) {
         return 1;
@@ -671,8 +671,8 @@ inline int bgc_fp64_vector3_are_orthogonal(const BGC_FP64_Vector3* vector1, cons
 
 inline int bgc_fp32_vector3_get_attitude(const BGC_FP32_Vector3* vector1, const BGC_FP32_Vector3* vector2)
 {
-    const float square_modulus1 = bgc_fp32_vector3_get_square_modulus(vector1);
-    const float square_modulus2 = bgc_fp32_vector3_get_square_modulus(vector2);
+    const float square_modulus1 = bgc_fp32_vector3_get_squared_length(vector1);
+    const float square_modulus2 = bgc_fp32_vector3_get_squared_length(vector2);
 
     if (square_modulus1 <= BGC_FP32_SQUARE_EPSILON || square_modulus2 <= BGC_FP32_SQUARE_EPSILON) {
         return BGC_ATTITUDE_ZERO;
@@ -690,7 +690,7 @@ inline int bgc_fp32_vector3_get_attitude(const BGC_FP32_Vector3* vector1, const
 
     bgc_fp32_vector3_get_cross_product(&product, vector1, vector2);
 
-    if (bgc_fp32_vector3_get_square_modulus(&product) > square_limit) {
+    if (bgc_fp32_vector3_get_squared_length(&product) > square_limit) {
         return BGC_ATTITUDE_ANY;
     }
 
@@ -699,8 +699,8 @@ inline int bgc_fp32_vector3_get_attitude(const BGC_FP32_Vector3* vector1, const
 
 inline int bgc_fp64_vector3_get_attitude(const BGC_FP64_Vector3* vector1, const BGC_FP64_Vector3* vector2)
 {
-    const double square_modulus1 = bgc_fp64_vector3_get_square_modulus(vector1);
-    const double square_modulus2 = bgc_fp64_vector3_get_square_modulus(vector2);
+    const double square_modulus1 = bgc_fp64_vector3_get_squared_length(vector1);
+    const double square_modulus2 = bgc_fp64_vector3_get_squared_length(vector2);
 
     if (square_modulus1 <= BGC_FP64_SQUARE_EPSILON || square_modulus2 <= BGC_FP64_SQUARE_EPSILON) {
         return BGC_ATTITUDE_ZERO;
@@ -718,7 +718,7 @@ inline int bgc_fp64_vector3_get_attitude(const BGC_FP64_Vector3* vector1, const
 
     bgc_fp64_vector3_get_cross_product(&product, vector1, vector2);
 
-    if (bgc_fp64_vector3_get_square_modulus(&product) > square_limit) {
+    if (bgc_fp64_vector3_get_squared_length(&product) > square_limit) {
         return BGC_ATTITUDE_ANY;
     }