diff --git a/docs/quaternion-eng.md b/docs/quaternion-eng.md index 91084f8..89dde39 100644 --- a/docs/quaternion-eng.md +++ b/docs/quaternion-eng.md @@ -1,63 +1,44 @@ # Quaternions -Quaternions are hypercomplex numbers that extend the concept of complex numbers. They consist of one real component and three imaginary components: +[ / Russian version](quaternion-rus.md) -q = w + ix + jy + kz +Quaternions are hypercomplex numbers that extend the concept of complex numbers. +They consist of one real component and three imaginary components: + +q = s + ix + jy + kz where: -- w, x, y, z ∈ R are real numbers +- s, x, y, z ∈ R are real numbers - i, j, k are imaginary units that satisfy the following conditions: - i2 = j2 = k2 = ijk = -1 -Quaternions were discovered by mathematician William Hamilton and introduced to the public in 1843. They have found wide application in computer graphics, robotics, and physics to describe rotations in three-dimensional space. +Quaternions were discovered by mathematician William Hamilton and introduced +to the public in 1843. They have found wide application in computer graphics, +robotics, and physics to describe rotations in three-dimensional space. ## Quaternion implementation in the library -The library provides two implementations of quaternions: +There are two types of quaternions in the library: +- **BGC_FP32_Quaternion** - a quaternion using single-precision floating-point +numbers +- **BGC_FP64_Quaternion** - a quaternion using double-precision floating-point +numbers -1. **General-purpose quaternions** - - Support all basic operations (addition, subtraction, multiplication by a scalar, etc.). - -2. **Versors**: - - Specialized quaternions whose absolute value is always equal to one. - - Suitable for describing rotations in three-dimensional space. - - Do not support addition, subtraction, and multiplication by a scalar. - -General-purpose quaternions can also be used to represent rotations in three-dimensional space. But the developer using quaternions to describe rotations must ensure that the absolute values of the quaternions do not become less than the error value and do not take the NaN (not a number) value. - -### Quaternion structures - -#### General purpose quaternions +Structure definitions: ```c typedef struct { - float s0, x1, x2, x3; - } BgcQuaternionFP32; + float s, x, y, z; + } BGC_FP32_Quaternion; typedef struct { - double s0, x1, x2, x3; - } BgcQuaternionFP64; -``` - -#### Versors - -```c - typedef struct { - const float s0, x1, x2, x3; - } BgcVersorFP32; - - typedef struct { - const double s0, x1, x2, x3; - } BgcVersorFP64; + double s, x, y, z; + } BGC_FP64_Quaternion; ``` Fields: -- s0 is the real part of the quaternion. -- x1, x2, x3 - Imaginary components of the quaternion. - -The versor fields are declared as const so that the developer uses the library functions to work with versors, and does not change them directly. - -The quaternion fields are free to be changed by the developer using the library. +- **s** is the real part of the quaternion. It is named after the word Scalar. +- **x**, **y**, **z** - Imaginary components of the quaternion. [Documentation](intro-eng.md) diff --git a/docs/quaternion-rus.md b/docs/quaternion-rus.md index 5fcb201..c7b17e6 100644 --- a/docs/quaternion-rus.md +++ b/docs/quaternion-rus.md @@ -1,62 +1,45 @@ # Кватернионы -Кватернионы — это гиперкомплексные числа, которые расширяют понятие комплексных чисел. Они состоят из одной действительной компоненты и трёх мнимых компонент: +[English version / Английская версия](quaternion-eng.md) -q = w + ix + jy + kz +Кватернионы — это гиперкомплексные числа, которые расширяют понятие комплексных +чисел. Они состоят из одной действительной компоненты и трёх мнимых компонент: + +q = s + ix + jy + kz где: -- w, x, y, z ∈ R - действительные числа +- s, x, y, z ∈ R - действительные числа - i, j, k - мнимые единицы, удовлетворяющие следующим условиям: - i2 = j2 = k2 = ijk = -1 -Кватернионы были открыты математиком Уильямом Гамильтоном и представлены публике в 1843 году. Они нашли широкое применение в компьютерной графике, робототехнике и физике для описания поворотов в трёхмерном пространстве. +Кватернионы были открыты математиком Уильямом Гамильтоном и представлены публике +в 1843 году. Они нашли широкое применение в компьютерной графике, робототехнике +и физике для описания поворотов в трёхмерном пространстве. ## Реализация кватернионов в библиотеке -Библиотека предоставляет две реализации кватернионов: -1. **Кватернионы общего назначения** - - Поддерживают все основные операции (сложение, вычитание, умножение на скаляр и т.д.). +В библиотеке есть два типа трёхмерных векторов: +- **BGC_FP32_Quaternion** - кватернион на основе чисел с плавающей запятой +одинарной точности +- **BGC_FP64_Quaternion** - кватернион на основе чисел с плавающей запятой +двойной точности -2. **Версоры**: - - Специализированные кватернионы, модуль которых всегда равен единице. - - Подходят для описания поворотов в трёхмерном пространстве. - - Не поддерживают операции сложения, вычитания и умножения на скаляр. - -Кватернионы общего назначения также можно использовать для представления поворотов в трёхмерном пространстве. Но разработчик, использующий кватернионы для описания поворотов, сам должен следить за тем, чтобы модули кватернионов не становились меньше величины погрешности и не принимали значение NaN (не число). - -### Структуры для кватернионов - -#### Кватернионы общего назначения +Определения структур: ```c typedef struct { - float s0, x1, x2, x3; - } BgcQuaternionFP32; + float s, x, y, z; + } BGC_FP32_Quaternion; typedef struct { - double s0, x1, x2, x3; - } BgcQuaternionFP64; -``` - -#### Версоры - -```c - typedef struct { - const float s0, x1, x2, x3; - } BgcVersorFP32; - - typedef struct { - const double s0, x1, x2, x3; - } BgcVersorFP64; + double s, x, y, z; + } BGC_FP64_Quaternion; ``` Поля: -- s0 - это вещественная часть кватерниона. -- x1, x2, x3 - Мнимые компоненты кватерниона. - -Поля версоров объявлены как const, чтобы разработчик использовал функции библиотеки для работы с версорами, а не изменял их напрямую. - -Поля кватернионов разработчик, использующий библиотеку, может менять свободно. +- **s** - это вещественная часть кватерниона, буква выбрана от английского слова +scalar - скалярная величина. +- **x**, **y**, **z** - мнимые компоненты кватерниона. [Документация](intro-rus.md) diff --git a/docs/vector2-eng.md b/docs/vector2-eng.md index cd81a00..a7cc826 100644 --- a/docs/vector2-eng.md +++ b/docs/vector2-eng.md @@ -1,31 +1,33 @@ # Two-dimensional vectors +[ / Russian version](vector2-rus.md) + There are two types of 2D vectors in the library: -- **BgcVector2FP32** - vector using single-precision floating-point numbers -- **BgcVector2FP64** - vector using double-precision floating-point numbers +- **BGC_FP32_Vector2** - vector using single-precision floating-point numbers +- **BGC_FP64_Vector2** - vector using double-precision floating-point numbers Structure definitions: ```c typedef struct { - float x1, x2; - } BgcVector2FP32; + float x, y; + } BGC_FP32_Vector2; typedef struct { - double x1, x2; - } BgcVector2FP64; + double x, y; + } BGC_FP64_Vector2; ``` ## Functions -| Funtions for BgcVector2FP32 | Funtions for BgcVector2FP64 | +| Funtions for BGC_FP32_Vector2 | Funtions for BGC_FP64_Vector2 | |:-------------------------------------------------------------:|:-------------------------------------------------------------:| -| [bgc_vector2_reset_fp32](vector2/reset-eng.md) | [bgc_vector2_reset_fp64](vector2/reset-eng.md) | -| [bgc_vector2_set_values_fp32](vector2/set-values-eng.md) | [bgc_vector2_set_values_fp64](vector2/set-values-eng.md) | -| [bgc_vector2_copy_fp32](vector2/copy-eng.md) | [bgc_vector2_copy_fp64](vector2/copy-eng.md) | -| [bgc_vector2_swap_fp32](vector2/swap-eng.md) | [bgc_vector2_swap_fp64](vector2/swap-eng.md) | +| [bgc_fp32_vector2_reset](vector2/reset-eng.md) | [bgc_fp64_vector2_reset](vector2/reset-eng.md) | +| [bgc_fp32_vector2_set_values](vector2/set-values-eng.md) | [bgc_fp64_vector2_set_values](vector2/set-values-eng.md) | +| [bgc_fp32_vector2_copy](vector2/copy-eng.md) | [bgc_fp64_vector2_copy](vector2/copy-eng.md) | +| [bgc_fp32_vector2_swap](vector2/swap-eng.md) | [bgc_fp64_vector2_swap](vector2/swap-eng.md) | [Documentation](intro-eng.md) diff --git a/docs/vector2-rus.md b/docs/vector2-rus.md index 1b61b3c..7f6236c 100644 --- a/docs/vector2-rus.md +++ b/docs/vector2-rus.md @@ -1,45 +1,34 @@ # Двумерные векторы векторы +[English version / Английская версия](vector2-eng.md) + В библиотеке есть два типа двумерных векторов: -- **BgcVector2FP32** - вектор с использованием чисел с плавающей запятой одинарной точности -- **BgcVector2FP64** - вектор с использованием чисел с плавающей запятой двойной точности +- **BGC_FP32_Vector3** - вектор с использованием чисел с плавающей запятой +одинарной точности +- **BGC_FP64_Vector3** - вектор с использованием чисел с плавающей запятой +двойной точности Определения структур: ```c typedef struct { - float x1, x2; - } BgcVector2FP32; + float x, y; + } BGC_FP32_Vector2; typedef struct { - double x1, x2; - } BgcVector2FP64; + double x, y; + } BGC_FP64_Vector2; ``` ## Функции -| Функции для BgcVector2FP32 | Функции для BgcVector2FP64 | +| Функции для BGC_FP32_Vector2 | Функции для BGC_FP64_Vector2 | |:-------------------------------------------------------------:|:-------------------------------------------------------------:| -| [bgc_vector2_reset_fp32](vector2/reset-rus.md) | [bgc_vector2_reset_fp64](vector2/reset-rus.md) | -| [bgc_vector2_set_values_fp32](vector2/set-values-rus.md) | [bgc_vector2_set_values_fp64](vector2/set-values-rus.md) | -| [bgc_vector2_copy_fp32](vector2/copy-rus.md) | [bgc_vector2_copy_fp64](vector2/copy-rus.md) | -| [bgc_vector2_swap_fp32](vector2/swap-rus.md) | [bgc_vector2_swap_fp64](vector2/swap-rus.md) | - -### Функции кнвертации типа - -Функции конвертации типа позволяют преобразовать - - inline void bgc_vector2_convert_fp64_to_fp32(const BgcVector2FP64* from, BgcVector2FP32* to); - inline void bgc_vector2_convert_fp32_to_fp64(const BgcVector2FP32* from, BgcVector2FP64* to); - -Функции библиотеки проектировались из предпосылки, что разработчик, использующий -данную библиотеку, выберет один из двух типов чисел с плавающей запятой -(**float** или **double**) и будет работать с геометрическими структурами и -функциями выбранного типа. - -Тем не менее, в библиотеке есть функции, которые позволяют преобразовать данные -одного типа в данные другого типа. +| [bgc_fp32_vector2_reset](vector2/reset-rus.md) | [bgc_fp64_vector2_reset](vector2/reset-rus.md) | +| [bgc_fp32_vector2_set_values](vector2/set-values-rus.md) | [bgc_fp64_vector2_set_values](vector2/set-values-rus.md) | +| [bgc_fp32_vector2_copy](vector2/copy-rus.md) | [bgc_fp64_vector2_copy](vector2/copy-rus.md) | +| [bgc_fp32_vector2_swap](vector2/swap-rus.md) | [bgc_fp64_vector2_swap](vector2/swap-rus.md) | [Документация](intro-rus.md) diff --git a/docs/vector3-eng.md b/docs/vector3-eng.md index 8474a4f..217ddb0 100644 --- a/docs/vector3-eng.md +++ b/docs/vector3-eng.md @@ -1,5 +1,7 @@ # Three-dimensional vectors +[ / Russian version](vector3-rus.md) + There are two types of 3D vectors in the library: - **BGC_FP32_Vector3** - vector using single-precision floating-point numbers - **BGC_FP64_Vector3** - vector using double-precision floating-point numbers @@ -20,12 +22,12 @@ Structure definitions: ## Functions -| Funtions for BgcVector3FP32 | Funtions for BgcVector3FP64 | +| Funtions for BGC_FP32_Vector3 | Funtions for BGC_FP64_Vector3 | |:-------------------------------------------------------------:|:-------------------------------------------------------------:| -| [bgc_vector3_reset_fp32](vector3/reset-eng.md) | [bgc_vector3_reset_fp64](vector3/reset-eng.md) | -| [bgc_vector3_set_values_fp32](vector3/set-values-eng.md) | [bgc_vector3_set_values_fp64](vector3/set-values-eng.md) | -| [bgc_vector3_copy_fp32](vector3/copy-eng.md) | [bgc_vector3_copy_fp64](vector3/copy-eng.md) | -| [bgc_vector3_swap_fp32](vector3/swap-eng.md) | [bgc_vector3_swap_fp64](vector3/swap-eng.md) | +| [bgc_fp32_vector3_reset](vector3/reset-eng.md) | [bgc_fp64_vector3_reset](vector3/reset-eng.md) | +| [bgc_fp32_vector3_set_values](vector3/set-values-eng.md) | [bgc_fp64_vector3_set_values](vector3/set-values-eng.md) | +| [bgc_fp32_vector3_copy](vector3/copy-eng.md) | [bgc_fp64_vector3_copy](vector3/copy-eng.md) | +| [bgc_fp32_vector3_swap](vector3/swap-eng.md) | [bgc_fp64_vector3_swap](vector3/swap-eng.md) | [Documentation](intro-eng.md) diff --git a/docs/vector3-rus.md b/docs/vector3-rus.md index a51409e..9be7c1b 100644 --- a/docs/vector3-rus.md +++ b/docs/vector3-rus.md @@ -1,5 +1,7 @@ # Трёхмерные векторы векторы +[English version / Английская версия](vector3-eng.md) + В библиотеке есть два типа трёхмерных векторов: - **BGC_FP32_Vector3** - вектор с использованием чисел с плавающей запятой одинарной точности @@ -22,7 +24,7 @@ ## Функции -| Функции для BgcVector3FP32 | Функции для BgcVector3FP64 | +| Функции для BGC_FP32_Vector3 | Функции для BGC_FP64_Vector3 | |:-------------------------------------------------------------:|:-------------------------------------------------------------:| | [bgc_fp32_vector3_reset](vector3/reset-rus.md) | [bgc_fp64_vector3_reset](vector3/reset-rus.md) | | [bgc_fp32_vector3_set_values](vector3/set-values-rus.md) | [bgc_fp64_vector3_set_values](vector3/set-values-rus.md) | diff --git a/docs/vector3/copy-eng.md b/docs/vector3/copy-eng.md index 74d5e69..54de959 100644 --- a/docs/vector3/copy-eng.md +++ b/docs/vector3/copy-eng.md @@ -1,5 +1,7 @@ # Copying +[ / Russian version](copy-rus.md) + The copy functions allow you to copy the coordinate values of one vector to another vector. diff --git a/docs/vector3/copy-rus.md b/docs/vector3/copy-rus.md index 8598eb2..56c5a7a 100644 --- a/docs/vector3/copy-rus.md +++ b/docs/vector3/copy-rus.md @@ -1,5 +1,7 @@ # +[English version / ](copy-eng.md) + . diff --git a/docs/vector3/reset-eng.md b/docs/vector3/reset-eng.md index 9d0d7f9..bafb272 100644 --- a/docs/vector3/reset-eng.md +++ b/docs/vector3/reset-eng.md @@ -1,5 +1,7 @@ # Resetting the state of a 3D vector +[ / Russian version](reset-rus.md) + These functions set all coordinates of 3D vectors to 0. Function for **BGC_FP32_Vector3**: diff --git a/docs/vector3/reset-rus.md b/docs/vector3/reset-rus.md index 59a2634..75ebad4 100644 --- a/docs/vector3/reset-rus.md +++ b/docs/vector3/reset-rus.md @@ -1,17 +1,19 @@ # +[English version / ](reset-eng.md) + 0 . **BGC_FP32_Vector3**: ```c -inline void bgc_fp32_vector3_reset(BGC_FP32_Vector3* vector); +inline void bgc_fp32_vector3_reset(BGC_FP32_Vector3* const vector); ``` **BGC_FP64_Vector3**: ```c -inline void bgc_fp64_vector3_reset(BGC_FP64_Vector3* vector); +inline void bgc_fp64_vector3_reset(BGC_FP64_Vector3* const vector); ``` : diff --git a/docs/vector3/set-values-eng.md b/docs/vector3/set-values-eng.md index dd07e0b..01dcb27 100644 --- a/docs/vector3/set-values-eng.md +++ b/docs/vector3/set-values-eng.md @@ -1,5 +1,7 @@ # Setting the coordinates of a three-dimensional vector +[ / Russian version](set-values-rus.md) + You can set the coordinates of vectors either directly or using functions. The functions for setting coordinate values allow you to do this in one line. diff --git a/docs/vector3/set-values-rus.md b/docs/vector3/set-values-rus.md index 17b3338..4b5a559 100644 --- a/docs/vector3/set-values-rus.md +++ b/docs/vector3/set-values-rus.md @@ -1,5 +1,7 @@ # +[English version / ](set-values-eng.md) + , . , . diff --git a/docs/vector3/swap-eng.md b/docs/vector3/swap-eng.md index d47b928..f812727 100644 --- a/docs/vector3/swap-eng.md +++ b/docs/vector3/swap-eng.md @@ -1,5 +1,7 @@ # Swapping +[ / Russian version](swap-rus.md) + The exchange functions allow two vectors of the same type to exchange coordinate values. diff --git a/docs/vector3/swap-rus.md b/docs/vector3/swap-rus.md index 347be86..61c701f 100644 --- a/docs/vector3/swap-rus.md +++ b/docs/vector3/swap-rus.md @@ -1,18 +1,20 @@ # Обмен значениями +[English version / Английская версия](swap-eng.md) + Функции обмена позволяют двум векторам одного типа обменяться значениями координат. Функция для **BgcVector3FP32**: ```c -inline void bgc_vector3_swap_fp32(BgcVector3FP32* vector1, BgcVector3FP32* vector2); +inline void bgc_fp32_vector3_swap(BGC_FP32_Vector3* const vector1, BGC_FP32_Vector3* const vector2); ``` Функция для **BgcVector3FP32**: ```c -inline void bgc_vector3_swap_fp64(BgcVector3FP64* vector1, BgcVector3FP64* vector2); +inline void bgc_fp64_vector3_swap(BGC_FP64_Vector3* const vector1, BGC_FP64_Vector3* const vector2); ``` Параметры **vector1** и **vector2** не должны быть некорректными указателями. diff --git a/docs/versor-eng.md b/docs/versor-eng.md deleted file mode 100644 index 8d3bde5..0000000 --- a/docs/versor-eng.md +++ /dev/null @@ -1,71 +0,0 @@ -# Versors - -[Quaternions](quaternion-eng.md) are hypercomplex numbers that have one real component and three imaginary components: - -q = w + ix + jy + kz - -where: - -- w, x, y, z ∈ R are real numbers -- i, j, k are imaginary units that satisfy the following conditions: - - i2 = j2 = k2 = ijk = -1 - -Quaternions were discovered by mathematician William Hamilton and introduced to the public in 1843. Hamilton later proposed a special class of quaternions, which he called versors. - -## What is a versor? - -A versor is a quaternion whose modulus is equal to one. That is, the formulas defining quaternions must be supplemented with the condition that the modulus of a quaternion is equal to one. - -It is sufficient to add the equation of the modulus being equal to one to the formulas defining a quaternion: - -q = w + ix + jy + kz - -- w, x, y, z ∈ R are real numbers -- i, j, k are imaginary units that satisfy the following conditions: - - i2 = j2 = k2 = ijk = -1 -- w2 + x2 + y2 + z2 = 1 - -The name comes from the Latin verb "versare", meaning "to turn", "to rotate", to which the Latin ending -or is added, denoting the subject performing the action. Literally, the Latin word "versor" can be translated as "rotator" or "turner". - -## Using Versors - -Versors have proven to be an excellent tool for describing rotations in three-dimensional space. The quaternion multiplication operation has proven useful for combining two consecutive rotations, and the conjugate quaternion operation has proven useful for obtaining the inverse rotation. - -When multiplying two versors (quaternions of unit length) and taking the conjugate versor, the result will also be a versor, that is, a quaternion of unit length. - -Addition and subtraction of two quaternions, as well as multiplication and division of a quaternion by a number, turned out to be unnecessary for describing rotations in three-dimensional space. - -## Advantages of versors - -1. **Preservation of modulus**: Versors preserve modulus equal to one, which prevents them from degenerating. -2. **Efficiency**: The BGC library automatically normalizes versors only when necessary, which avoids unnecessary computations. - -## Implementation in the BGC library - -The BGC library provides a separate implementation for versors in the form of structures and functions that keep the versor modulus close to one. - -### Structures - -```c - typedef struct { - const float s0, x1, x2, x3; - } BgcVersorFP32; - - typedef struct { - const double s0, x1, x2, x3; - } BgcVersorFP64; -``` - -Fields: -- s0 is the real part of the versor. -- x1, x2, x3 are the imaginary components of the versor. - -## Functions - -| Funtions for BgcVersorFP32 | Funtions for BgcVersorFP64 | -|:-------------------------------------------------------------:|:-------------------------------------------------------------:| -| [bgc_versor_reset_fp32](versor/reset-eng.md) | [bgc_versor_reset_fp64](versor/reset-eng.md) | -| [bgc_versor_set_values_fp32](versor/set-values-eng.md) | [bgc_versor_set_values_fp64](versor/set-values-eng.md) | - - -[Documentation](intro-eng.md) diff --git a/docs/versor-rus.md b/docs/versor-rus.md deleted file mode 100644 index 8b41d8f..0000000 --- a/docs/versor-rus.md +++ /dev/null @@ -1,73 +0,0 @@ -# Версоры - -[Кватернионы](quaternion-rus.md) - это гиперкомплексные числа, у которых имеется одна действительная компонента и три мнимых компоненты: - -q = w + ix + jy + kz, где w - действительная компонена, x, y, z - мнимые компоненты, а i, j, k - мнимые единицы - -где -- w, x, y, z ∈ R - действительные числа -- i, j, k - мнимые единицы, удовлетворяющие следующим условиям: - - i2 = j2 = k2 = ijk = -1 - -Кватернионы были открыты математиком Уильямом Гамильтоном и представлены публике в 1843 году. Позже Гамильтон предложил особый класс кватернионов, которые назвал версорами. - -## Что такое версор? - -Версор - это кватернион, модуль которого равен единице. То есть, к формулам, определяющим кватернионы, необходимо добавить условие, что модуль кватерниона равен единице. - -К формулам, определяющим кватернион достаточно добавить уравнение равенства модуля единице: - -q = w + ix + jy + kz - -где -- w, x, y, z ∈ R - действительные числа -- i, j, k - мнимые единицы, удовлетворяющие следующим условиям: - - i2 = j2 = k2 = ijk = -1 -- w2 + x2 + y2 + z2 = 1 - -Название происходит от латинского глагола "versare", означающего "поворачивать", "вращать", к которому добавлено латинское окончание -or, обозначающее субъект, выполняющий действие. Дословно латинское слово "versor" можно перевести как "вращатель" или "поворачиватель". - -## Применение версоров - -Версоры оказались отличным инструментом для описания поворотов в трёхмерном пространстве. Для комбинации двух последовательных поворотов полезной оказалась операция умножения кватернионов, а для получения обратного поворота - операция взятия сопряжённого кватерниона. - -При умножении двух версоров (кватернионов единичной длины) и при взятии сопряжённого версора результат также будет версором, то есть кватернионом единичной длины. - -Сложение и вычитание двух кватернионов, а также умножение и деление кватерниона на число оказались не нужны для описания поворотов в трёхмерном пространстве. - -Несмотря на то, что версоры как класс кватернионов были предложены ещё Уильямом Гамильтоном для описаний поворотов ещё в середине 19 века, в русскоязычной литературе термин "версор" встречается настолько редко, что можно сказать, что не употребляется. - -## Преимущества версоров - -1. **Сохранение модуля**: Версоры сохраняют модуль, равный единице, что предотвращает их вырождение. -2. **Эффективность**: Библиотека BGC автоматически нормализует версоры только при необходимости, что позволяет избежать лишних вычислений. - -## Реализация в библиотеке BGC - -Библиотека BGC предоставляет отдельную реализацию для версоров в виде структур и функций, которые поддерживают модуль версоров близким к единице. - -### Структуры - -```c - typedef struct { - const float s0, x1, x2, x3; - } BgcVersorFP32; - - typedef struct { - const double s0, x1, x2, x3; - } BgcVersorFP64; -``` - -Поля: -- s0 - это вещественная часть версора. -- x1, x2, x3 - Мнимые компоненты версора. - -## Функции - -| Функции для BgcVersorFP32 | Функции для BgcVersorFP64 | -|:-------------------------------------------------------------:|:-------------------------------------------------------------:| -| [bgc_versor_reset_fp32](versor/reset-rus.md) | [bgc_versor_reset_fp64](versor/reset-rus.md) | -| [bgc_versor_set_values_fp32](versor/set-values-rus.md) | [bgc_versor_set_values_fp64](versor/set-values-rus.md) | - - -[Документация](intro-rus.md) diff --git a/docs/versor/reset-eng.md b/docs/versor/reset-eng.md deleted file mode 100644 index 7713ab3..0000000 --- a/docs/versor/reset-eng.md +++ /dev/null @@ -1,53 +0,0 @@ -# State reset functions for versors - -[A versor](../versor-eng.md) that corresponds to no rotation has the following component values: - -``` - s0 = 1; - x1 = 0; - x2 = 0; - x3 = 0; -``` - -To set such a state for the versor components, the library has the corresponding functions. - -For the **BgFP32Versor** type, the function is: - -```c - inline void bgc_versor_reset_fp32(BgFP32Versor* versor); -``` - -For the **BgFP64Versor** type, the function is: - -```c - inline void bgc_versor_reset_fp64(BgFP64Versor* versor); -``` - -The **versor** parameter must be a valid pointer and must not be NULL. - -These functions are well suited for initializing the state of variables of the **BgFP32Versor** and **BgFP64Versor** types. - -Usage example: - -```c - #include - #include - - int main() { - BgFP32Versor versor; - - bgc_versor_reset_fp32(&versor); - - printf("Versor: (%f, %f, %f, %f)\n", versor.s0, versor.x1, versor.x2, versor.x3); - - return 0; - } -``` - -Result: - -``` - Versor: (1.000000, 0.000000, 0.000000, 0.000000) -``` - -[Documentation](../intro-eng.md) / [Versors](../versor-eng.md) diff --git a/docs/versor/reset-rus.md b/docs/versor/reset-rus.md deleted file mode 100644 index 179d759..0000000 --- a/docs/versor/reset-rus.md +++ /dev/null @@ -1,53 +0,0 @@ -# Функции сброса состояния для версоров - -[Версор](../versor-rus.md), который соответствует отсутствию поворота, имеет следующие значеия компонент: - -``` - s0 = 1; - x1 = 0; - x2 = 0; - x3 = 0; -``` - -Чтобы установить данное состояние для компонент версора, в библиотеке есть соответствующие функции. - -Для типа **BgFP32Versor** функция имеет вид: - -```c - inline void bgc_versor_reset_fp32(BgFP32Versor* versor); -``` - -Для типа **BgFP64Versor** функция имеет вид: - -```c - inline void bgc_versor_reset_fp64(BgFP64Versor* versor); -``` - -Параметр **versor** должен быть корректным указателем, а также не должен быть равен NULL. - -Эти функции хорошо подходят для инициализации состояния переменных типов **BgFP32Versor** и **BgFP64Versor**. - -Пример использования: - -```c - #include - #include - - int main() { - BgFP32Versor versor; - - bgc_versor_reset_fp32(&versor); - - printf("Versor: (%f, %f, %f, %f)\n", versor.s0, versor.x1, versor.x2, versor.x3); - - return 0; - } -``` - -Результат: - -``` - Versor: (1.000000, 0.000000, 0.000000, 0.000000) -``` - -[Документация](../intro-rus.md) / [Версоры](../versor-rus.md) diff --git a/docs/versor/set-values-eng.md b/docs/versor/set-values-eng.md deleted file mode 100644 index d41b8c8..0000000 --- a/docs/versor/set-values-eng.md +++ /dev/null @@ -1,56 +0,0 @@ -# Versor component assignment functions - -Special functions are provided to specify specific values ??for the versor components. - -For the **BgFP32Versor** type, the function has the form: - -```c - inline void bgc_versor_set_values_fp32(const float s0, const float x1, const float x2, const float x3, BgcVersorFP32* versor); -``` - -For the **BgFP64Versor** type, the function has the form: - -```c - inline void bgc_versor_set_values_fp64(const double s0, const double x1, const double x2, const double x3, BgcVersorFP64* versor); -``` - -These functions set the values ??passed in the **s0**, **x1**, **x2**, and **x3** parameters to the corresponding components of the versor passed by pointer in the **versor** parameter. But if the resulting state is not a normalized quaternion, then the functions normalize the versor. - -The **versor** parameter must be a valid pointer and must not be NULL. - -These functions are also well suited for initializing the state of variables of types **BgFP32Versor** and **BgFP64Versor**, as are the functions [bgc_versor_reset_fp32 and bgc_versor_reset_fp64](./versor-reset-eng.md). - -```c - #include - #include - - int main() { - BgcVersorFP64 versor; - - bgc_versor_set_values_fp64(1, 2, 3, 4, &versor); - - printf("Versor: (%lf, %lf, %lf, %lf)\n", versor.s0, versor.x1, versor.x2, versor.x3); - - return 0; - } -``` - -Result: - -``` - Versor: (0.182574, 0.365148, 0.547723, 0.730297) -``` - -If zeros are passed to the function as component values, then the versor, the pointer to which is passed in the **versor** parameter, will be set to the state corresponding to the absence of rotation: - -```c - bgc_versor_set_values_fp64(0, 0, 0, 0, &versor); -``` - -Result: - -``` - Versor: (1.000000, 0.000000, 0.000000, 0.000000) -``` - -[Documentation](../intro-eng.md) / [Versors](../versor-eng.md) diff --git a/docs/versor/set-values-rus.md b/docs/versor/set-values-rus.md deleted file mode 100644 index 45148d2..0000000 --- a/docs/versor/set-values-rus.md +++ /dev/null @@ -1,58 +0,0 @@ -# Функции задания компонент версора - -Чтобы указать конкретные значения для компонент версора предусмотрены специальные функции. - -Для типа **BgFP32Versor** функция имеет вид: - -```c - inline void bgc_versor_set_values_fp32(const float s0, const float x1, const float x2, const float x3, BgcVersorFP32* versor); -``` - -Для типа **BgFP64Versor** функция имеет вид: - -```c - inline void bgc_versor_set_values_fp64(const double s0, const double x1, const double x2, const double x3, BgcVersorFP64* versor); -``` - -Данные функции устанавливают значения, переданные в параметрах **s0**, **x1**, **x2** и **x3**, в соответствующе компоненты версора, переданного по указателю в параметре **versor**. Но если получившееся состояние не является нормализованным кватернионом, то функции нормализуют версор. - -Параметр **versor** должен быть корректным указателем, а также не должен быть равен NULL. - -Данные функции также хорошо подходят для инициализации состояния переменных типов **BgFP32Versor** и **BgFP64Versor** как и функции [bgc_versor_reset_fp32 и bgc_versor_reset_fp64](./versor-reset-eng.md). - -Пример использования: - -```c - #include - #include - - int main() { - BgcVersorFP64 versor; - - bgc_versor_set_values_fp64(1, 2, 3, 4, &versor); - - printf("Versor: (%lf, %lf, %lf, %lf)\n", versor.s0, versor.x1, versor.x2, versor.x3); - - return 0; - } -``` - -Результат: - -``` - Versor: (0.182574, 0.365148, 0.547723, 0.730297) -``` - -Если в качестве значений компонент в функцию передать нули, то версор, указатель на который передан в параметре **versor**, будет установлен в состояние, соответствующее отсутствию поворота: - -```c - bgc_versor_set_values_fp64(0, 0, 0, 0, &versor); -``` - -Результат: - -``` - Versor: (1.000000, 0.000000, 0.000000, 0.000000) -``` - -[Документация](../intro-rus.md) / [Версоры](../versor-rus.md)