Отказ от терминов Versor и Cotes Number в пользу Turn3 и Turn2, использование кватернионов внутри Turn3

basic-geometry/position3.h

@@ -3,17 +3,17 @@
 
 #include "vector3.h"
 #include "affine3.h"
-#include "versor.h"
+#include "turn3.h"
 
 // ==================== Types ==================== //
 
 typedef struct {
-    BGC_FP32_Versor turn;
+    BGC_FP32_Turn3 turn;
     BGC_FP32_Vector3 shift;
 } BGC_FP32_Position3;
 
 typedef struct {
-    BGC_FP64_Versor turn;
+    BGC_FP64_Turn3 turn;
     BGC_FP64_Vector3 shift;
 } BGC_FP64_Position3;
 
@@ -21,27 +21,27 @@ typedef struct {
 
 inline void bgc_fp32_position3_reset(BGC_FP32_Position3 * position)
 {
-    bgc_fp32_versor_reset(&position->turn);
+    bgc_fp32_turn3_reset(&position->turn);
     bgc_fp32_vector3_reset(&position->shift);
 }
 
 inline void bgc_fp64_position3_reset(BGC_FP64_Position3 * position)
 {
-    bgc_fp64_versor_reset(&position->turn);
+    bgc_fp64_turn3_reset(&position->turn);
     bgc_fp64_vector3_reset(&position->shift);
 }
 
 // ==================== Make ===================== //
 
-inline void bgc_fp32_position3_make(BGC_FP32_Position3* position, const BGC_FP32_Versor * turn, const BGC_FP32_Vector3 * shift)
+inline void bgc_fp32_position3_make(BGC_FP32_Position3* position, const BGC_FP32_Turn3 * turn, const BGC_FP32_Vector3 * shift)
 {
-    bgc_fp32_versor_copy(&position->turn, turn);
+    bgc_fp32_turn3_copy(&position->turn, turn);
     bgc_fp32_vector3_copy(&position->shift, shift);
 }
 
-inline void bgc_fp64_position3_make(BGC_FP64_Position3* position, const BGC_FP64_Versor * turn, const BGC_FP64_Vector3 * shift)
+inline void bgc_fp64_position3_make(BGC_FP64_Position3* position, const BGC_FP64_Turn3 * turn, const BGC_FP64_Vector3 * shift)
 {
-    bgc_fp64_versor_copy(&position->turn, turn);
+    bgc_fp64_turn3_copy(&position->turn, turn);
     bgc_fp64_vector3_copy(&position->shift, shift);
 }
 
@@ -49,13 +49,13 @@ inline void bgc_fp64_position3_make(BGC_FP64_Position3* position, const BGC_FP64
 
 inline void bgc_fp32_position3_copy(BGC_FP32_Position3* destination, const BGC_FP32_Position3 * source)
 {
-    bgc_fp32_versor_copy(&destination->turn, &source->turn);
+    bgc_fp32_turn3_copy(&destination->turn, &source->turn);
     bgc_fp32_vector3_copy(&destination->shift, &source->shift);
 }
 
 inline void bgc_fp64_position3_copy(BGC_FP64_Position3* destination, const BGC_FP64_Position3 * source)
 {
-    bgc_fp64_versor_copy(&destination->turn, &source->turn);
+    bgc_fp64_turn3_copy(&destination->turn, &source->turn);
     bgc_fp64_vector3_copy(&destination->shift, &source->shift);
 }
 
@@ -63,13 +63,13 @@ inline void bgc_fp64_position3_copy(BGC_FP64_Position3* destination, const BGC_F
 
 inline void bgc_fp32_position3_swap(BGC_FP32_Position3 * first, BGC_FP32_Position3 * second)
 {
-    bgc_fp32_versor_swap(&first->turn, &second->turn);
+    bgc_fp32_turn3_swap(&first->turn, &second->turn);
     bgc_fp32_vector3_swap(&first->shift, &second->shift);
 }
 
 inline void bgc_fp64_position3_swap(BGC_FP64_Position3 * first, BGC_FP64_Position3 * second)
 {
-    bgc_fp64_versor_swap(&first->turn, &second->turn);
+    bgc_fp64_turn3_swap(&first->turn, &second->turn);
     bgc_fp64_vector3_swap(&first->shift, &second->shift);
 }
 
@@ -77,13 +77,13 @@ inline void bgc_fp64_position3_swap(BGC_FP64_Position3 * first, BGC_FP64_Positio
 
 inline void bgc_fp32_position3_convert_to_fp64(BGC_FP64_Position3* destination, const BGC_FP32_Position3 * source)
 {
-    bgc_fp32_versor_convert_to_fp64(&destination->turn, &source->turn);
+    bgc_fp32_turn3_convert_to_fp64(&destination->turn, &source->turn);
     bgc_fp32_vector3_convert_to_fp64(&destination->shift, &source->shift);
 }
 
 inline void bgc_fp64_position3_convert_to_fp32(BGC_FP32_Position3* destination, const BGC_FP64_Position3* source)
 {
-    bgc_fp64_versor_convert_to_fp32(&destination->turn, &source->turn);
+    bgc_fp64_turn3_convert_to_fp32(&destination->turn, &source->turn);
     bgc_fp64_vector3_convert_to_fp32(&destination->shift, &source->shift);
 }
 
@@ -91,27 +91,27 @@ inline void bgc_fp64_position3_convert_to_fp32(BGC_FP32_Position3* destination,
 
 inline int bgc_fp32_position3_is_idle(const BGC_FP32_Position3 * position)
 {
-    return bgc_fp32_vector3_is_zero(&position->shift) && bgc_fp32_versor_is_idle(&position->turn);
+    return bgc_fp32_vector3_is_zero(&position->shift) && bgc_fp32_turn3_is_idle(&position->turn);
 }
 
 inline int bgc_fp64_position3_is_idle(const BGC_FP64_Position3 * position)
 {
-    return bgc_fp64_vector3_is_zero(&position->shift) && bgc_fp64_versor_is_idle(&position->turn);
+    return bgc_fp64_vector3_is_zero(&position->shift) && bgc_fp64_turn3_is_idle(&position->turn);
 }
 
 // =================== Invert ==================== //
 
 inline void bgc_fp32_position3_invert(BGC_FP32_Position3 * position)
 {
-    bgc_fp32_versor_turn_vector_back(&position->shift, &position->turn, &position->shift);
-    bgc_fp32_versor_revert(&position->turn);
+    bgc_fp32_turn3_vector_back(&position->shift, &position->turn, &position->shift);
+    bgc_fp32_turn3_revert(&position->turn);
     bgc_fp32_vector3_revert(&position->shift);
 }
 
 inline void bgc_fp64_position3_invert(BGC_FP64_Position3 * position)
 {
-    bgc_fp64_versor_turn_vector_back(&position->shift, &position->turn, &position->shift);
-    bgc_fp64_versor_revert(&position->turn);
+    bgc_fp64_turn3_vector_back(&position->shift, &position->turn, &position->shift);
+    bgc_fp64_turn3_revert(&position->turn);
     bgc_fp64_vector3_revert(&position->shift);
 }
 
@@ -119,15 +119,15 @@ inline void bgc_fp64_position3_invert(BGC_FP64_Position3 * position)
 
 inline void bgc_fp32_position3_get_inverse(BGC_FP32_Position3* inverse, const BGC_FP32_Position3 * position)
 {
-    bgc_fp32_versor_turn_vector_back(&inverse->shift, &position->turn, &position->shift);
-    bgc_fp32_versor_get_reverse(&inverse->turn, &position->turn);
+    bgc_fp32_turn3_vector_back(&inverse->shift, &position->turn, &position->shift);
+    bgc_fp32_turn3_get_reverse(&inverse->turn, &position->turn);
     bgc_fp32_vector3_revert(&inverse->shift);
 }
 
 inline void bgc_fp64_position3_get_inverse(BGC_FP64_Position3* inverse, const BGC_FP64_Position3 * position)
 {
-    bgc_fp64_versor_turn_vector_back(&inverse->shift, &position->turn, &position->shift);