USER
пропиши тесты для метода:
public static Vector3f multiplyMatrix4ByVector3(final Matrix4f matrix, final Vector3f vertex) {
final float x = (vertex.getX() * matrix.getElement(0, 0)) + (vertex.getY() * matrix.getElement(1, 0)) + (vertex.getZ() * matrix.getElement(2, 0)) + matrix.getElement(3, 0);
final float y = (vertex.getX() * matrix.getElement(0, 1)) + (vertex.getY() * matrix.getElement(1, 1)) + (vertex.getZ() * matrix.getElement(2, 1)) + matrix.getElement(3, 1);
final float z = (vertex.getX() * matrix.getElement(0, 2)) + (vertex.getY() * matrix.getElement(1, 2)) + (vertex.getZ() * matrix.getElement(2, 2)) + matrix.getElement(3, 2);
final float w = (vertex.getX() * matrix.getElement(0, 3)) + (vertex.getY() * matrix.getElement(1, 3)) + (vertex.getZ() * matrix.getElement(2, 3)) + matrix.getElement(3, 3);
return new Vector3f(x / w, y / w, z / w);
}
вот пример тестов:
package com.cgvsu.math.tests;
import com.cgvsu.math.Matrix3f;
import com.cgvsu.math.Matrix4f;
import com.cgvsu.math.Vector2f;
import com.cgvsu.math.Vector3f;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class Matrix3fTest {
// Тестирование конструктора с правильным размером массива
@Test
public void testConstructorWithValidArray() {
float[] elements = {
1, 2, 3,
4, 5, 6,
7, 8, 9
};
Matrix3f matrix = new Matrix3f(elements);
float[][] expected = {
{1, 2, 3},
{4, 5, 6},
{7, 8, 9}
};
Assertions.assertArrayEquals(expected, matrix.getElements(), "Матрица должна быть создана из переданного массива");
}
@Test
public void testGetElem() {
float[] elements = {
1, 2, 3,
4, 5, 6,
7, 8, 9
};
Matrix3f matrix = new Matrix3f(elements);
float num = 3;
Assertions.assertEquals(num, matrix.getElement(0,2), "Матрица должна быть создана из переданного массива");
}
// Тестирование конструктора с неверным размером массива
@Test
public void testConstructorWithInvalidArray() {
float[] elements = {1, 2, 3, 4}; // Неверная длина массива
Assertions.assertThrows(IllegalArgumentException.class, () -> {
new Matrix3f(elements);
}, "Конструктор должен выбрасывать исключение при неверном размере массива");
}
// Тестирование конструктора, создающего единичную матрицу
@Test
public void testIdentityConstructor() {
Matrix3f identity = new Matrix3f(1);
float[][] expected = {
{1, 0, 0},
{0, 1, 0},
{0, 0, 1}
};
Assertions.assertArrayEquals(expected, identity.getElements(), "Конструктор с параметром 1 должен создавать единичную матрицу");
}
// Тестирование конструктора по умолчанию (создает нулевую матрицу)
@Test
public void testDefaultConstructor() {
Matrix3f zero = new Matrix3f();
float[][] expected = {
{0, 0, 0},
{0, 0, 0},
{0, 0, 0}
};
Assertions.assertArrayEquals(expected, zero.getElements(), "Конструктор по умолчанию должен создавать нулевую матрицу");
}
// Тестирование сложения матриц
@Test
public void testAdd() {
float[] elementsA = {
1, 2, 3,
4, 5, 6,
7, 8, 9
};
float[] elementsB = {
9, 8, 7,
6, 5, 4,
3, 2, 1
};
Matrix3f A = new Matrix3f(elementsA);
Matrix3f B = new Matrix3f(elementsB);
Matrix3f expected = new Matrix3f(new float[]{
10, 10, 10,
10, 10, 10,
10, 10, 10
});
Matrix3f result = A.add(B);
Assertions.assertEquals(expected, result, "Сложение матриц неверно");
}
// Тестирование метода вычитания матриц
@Test
public void testSubtract() {
float[] elementsA = {
9, 8, 7,
6, 5, 4,
3, 2, 1
};
float[] elementsB = {
1, 2, 3,
4, 5, 6,
7, 8, 9
};
Matrix3f A = new Matrix3f(elementsA);
Matrix3f B = new Matrix3f(elementsB);
Matrix3f expected = new Matrix3f(new float[]{
8, 6, 4,
2, 0, -2,
-4, -6, -8
});
Matrix3f result = A.sub(B);
Assertions.assertEquals(expected, result, "Вычитание матриц неверно");
}
// Тестирование умножения матрицы на вектор
@Test
public void testMultiplyWithVector() {
float[] elements = {
1, 8, 3,
4, 5, 6,
7, 8, 9
};
Matrix3f matrix = new Matrix3f(elements);
Vector3f vector = new Vector3f(1, 0, -1);
Vector3f expected = new Vector3f(-2, -2, -2);
Vector3f result = matrix.multiply(vector);
Assertions.assertEquals(expected, result, "Умножение матрицы на вектор неверно");
}
// Тестирование умножения матрицы на вектор с инвалидным типом
@Test
public void testMultiplyWithInvalidVector() {
Vector2f invalidVector = new Vector2f(1, 2);
Matrix3f matrix = new Matrix3f(new float[]{
1, 0, 0,
0, 1, 0,
0, 0, 1
});
Assertions.assertThrows(IllegalArgumentException.class, () -> {
matrix.multiply(invalidVector);
}, "Умножение на неверный тип вектора должно выбрасывать исключение");
}
// Тестирование умножения двух матриц
@Test
public void testMultiplyWithMatrix() {
float[] elementsA = {
1, 2, 3,
4, 5, 6,
7, 8, 9
};
float[] elementsB = {
9, 8, 7,
6, 5, 4,
3, 2, 1
};
Matrix3f A = new Matrix3f(elementsA);
Matrix3f B = new Matrix3f(elementsB);
Matrix3f expected = new Matrix3f(new float[]{
30, 24, 18,
84, 69, 54,
138, 114, 90
});
A.multiply(B);
Assertions.assertEquals(expected, A, "Умножение матриц неверно");
}
// Тестирование умножения матрицы на матрицу с инвалидным типом
@Test
public void testMultiplyWithInvalidMatrix() {
Matrix4f invalidMatrix = new Matrix4f(new float[]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16});
Matrix3f matrix = new Matrix3f(new float[]{
1, 0, 0,
0, 1, 0,
0, 0, 1
});
Assertions.assertThrows(IllegalArgumentException.class, () -> {
matrix.multiply(invalidMatrix);
}, "Умножение на неверный тип матрицы должно выбрасывать исключение");
}
// Тестирование транспонирования матрицы
@Test
public void testTransposition() {
float[] elements = {
1, 2, 3,
4, 5, 6,
7, 8, 9
};
Matrix3f matrix = new Matrix3f(elements);
matrix.transposition();
Matrix3f expected = new Matrix3f(new float[]{
1, 4, 7,
2, 5, 8,
3, 6, 9
});
Assertions.assertEquals(expected, matrix, "Транспонирование матрицы выполнено неверно");
}
// Тестирование метода toString
@Test
public void testToString() {
float[] elements = {
1.5f, 2.25f, 3.75f,
4.0f, 5.5f, 6.125f,
7.375f, 8.625f, 9.875f
};
Matrix3f matrix = new Matrix3f(elements);
String expected = "1,50\t2,25\t3,75\t\n4,00\t5,50\t6,13\t\n7,38\t8,63\t9,88\t\n";
Assertions.assertEquals(expected, matrix.toString(), "Метод toString возвращает неверное представление матрицы");
}
// Тестирование равенства и hashCode
@Test
public void testEqualsAndHashCode() {
Matrix3f A = new Matrix3f(new float[]{
1, 2, 3,
4, 5, 6,
7, 8, 9
});
Matrix3f B = new Matrix3f(new float[]{
1, 2, 3,
4, 5, 6,
7, 8, 9
});
Matrix3f C = new Matrix3f(new float[]{
9, 8, 7,
6, 5, 4,
3, 2, 1
});
// Проверка равенства
Assertions.assertEquals(A, B, "Матрицы с одинаковыми элементами должны быть равны");
Assertions.assertNotEquals(A, C, "Матрицы с разными элементами не должны быть равны");
// Проверка hashCode
Assertions.assertEquals(A.hashCode(), B.hashCode(), "Хэш-коды равных матриц должны совпадать");
Assertions.assertNotEquals(A.hashCode(), C.hashCode(), "Хэш-коды разных матриц не должны совпадать");
}
// Тестирование операций с нулевой матрицей
@Test
public void testOperationsWithZeroMatrix() {
Matrix3f zero = new Matrix3f(); // Нулевая матрица
Matrix3f A = new Matrix3f(new float[]{
1, 2, 3,
4, 5, 6,
7, 8, 9
});
// Сложение с нулевой матрицей
Matrix3f addResult = A.add(zero);
Assertions.assertEquals(A, addResult, "Сложение с нулевой матрицей должно возвращать исходную матрицу");
// Вычитание нулевой матрицы
Matrix3f subtractResult = A.sub(zero);
Assertions.assertEquals(A, subtractResult, "Вычитание нулевой матрицы должно возвращать исходную матрицу");
// Умножение на нулевую матрицу
A.multiply(zero);
Matrix3f expected = new Matrix3f(); // Нулевая матрица
Assertions.assertEquals(expected, A, "Умножение на нулевую матрицу должно возвращать нулевую матрицу");
}
// Тестирование умножения матрицы на саму себя
@Test
public void testMultiplyWithItself() {
Matrix3f A = new Matrix3f(new float[]{
2, 0, 1,
3, 0, 0,
5, 1, 1
});
Matrix3f expected = new Matrix3f(new float[]{
9, 1, 3,
6, 0, 3,
18, 1, 6
});
A.multiply(A);
Assertions.assertEquals(expected, A, "Умножение матрицы на саму себя выполнено неверно");
}
// Тестирование транспонирования транспонированной матрицы (должна вернуть исходную матрицу)
@Test
public void testDoubleTransposition() {
float[] elements = {
1, 2, 3,
4, 5, 6,
7, 8, 9
};
Matrix3f matrix = new Matrix3f(elements);
matrix.transposition();
matrix.transposition();
Matrix3f expected = new Matrix3f(elements);
Assertions.assertEquals(expected, matrix, "Двойное транспонирование должно вернуть исходную матрицу");
}
// Тестирование умножения матрицы на единичную матрицу
@Test
public void testMultiplyWithIdentityMatrix() {
Matrix3f identity = new Matrix3f(1);
Matrix3f A = new Matrix3f(new float[]{
2, 4, 6,
1, 3, 5,
0, 7, 8
});
Matrix3f B = new Matrix3f(new float[]{
2, 4, 6,
1, 3, 5,
0, 7, 8
});
A.multiply(identity);
Assertions.assertEquals(B, A, "Умножение матрицы на единичную матрицу должно возвращать исходную матрицу");
}
// Тестирование умножения единичной матрицы на матрицу
@Test
public void testIdentityMultiplyWithMatrix() {
Matrix3f identity = new Matrix3f(1);
Matrix3f A = new Matrix3f(new float[]{
2, 4, 6,
1, 3, 5,
0, 7, 8
});
identity.multiply(A);
Assertions.assertEquals(A, identity, "Умножение единичной матрицы на матрицу должно возвращать исходную матрицу");
}
@Test
void determinant1() {
Matrix3f zeroMatrix = new Matrix3f();
float det = zeroMatrix.determinant();
Assertions.assertEquals(0.0f, det, "Определитель нулевой матрицы должен быть равен 0");
}
@Test
void determinant2() {
float[] elements = {
1, 2, 3,
0, 4, 5,
1, 0, 6
};
Matrix3f matrix = new Matrix3f(elements);
float det = matrix.determinant();
Assertions.assertEquals(22.0f, det, 1e-5, "Определитель матрицы должен быть равен 22");
}
@Test
void determinant3() {
float[] elements = {
2, 4, 2,
1, 2, 1,
3, 6, 3
};
Matrix3f singularMatrix = new Matrix3f(elements);
float det = singularMatrix.determinant();
Assertions.assertEquals(0.0f, det, 1e-5, "Определитель вырожденной матрицы должен быть равен 0");
}
@Test
void determinant4() {
float[] elements = {
3, 8, 1,
4, 6, 5,
7, 2, 9
};
Matrix3f matrix = new Matrix3f(elements);
float det = matrix.determinant();
Assertions.assertEquals(90.0f, det, 1e-5, "Определитель матрицы должен быть равен 90");
}
@Test
void determinant5() {
Matrix3f identity = new Matrix3f(1);
float det = identity.determinant();
Assertions.assertEquals(1.0f, det, "Определитель единичной матрицы должен быть равен 1");
}
// Тестирование обратной матрицы для единичной матрицы
@Test
public void testInverse1() {
Matrix3f identity = new Matrix3f(1);
Matrix3f inverse = identity.inverse();
float[][] original = identity.getElements();
float[][] actual = inverse.getElements();
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
float originalValue = original[i][j];
float actualValue = actual[i][j];
Assertions.assertEquals(originalValue, actualValue, 1e-4,
String.format("Элемент матрицы [%d][%d] отличается: оригинал=%.4f, обратная=%.4f",
i, j, originalValue, actualValue));
}
}
}
// Тестирование обратной матрицы
@Test
public void testInverse2() {
float[] elements = {
1, 2, 3,
0, 1, 4,
5, 6, 0
};
Matrix3f matrix = new Matrix3f(elements);
float[] expectedInverseElements = {
-24, 18, 5,
20, -15, -4,
-5, 4, 1
};
Matrix3f expectedInverse = new Matrix3f(expectedInverseElements);
Matrix3f inverse = matrix.inverse();
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
Assertions.assertEquals(
expectedInverse.getElements()[i][j],
inverse.getElements()[i][j],
1e-4,
"Элемент [" + i + "][" + j + "] обратной матрицы неверен"
);
}
}
}
// Тестирование обратной матрицы для вырожденной матрицы
@Test
public void testInverse3() {
float[] singularElements = {
1, 2, 3,
4, 5, 6,
7, 8, 9
};
Matrix3f singularMatrix = new Matrix3f(singularElements);
Assertions.assertThrows(ArithmeticException.class, () -> {
singularMatrix.inverse();
}, "Обратная матрица для вырожденной матрицы должна выбрасывать ArithmeticException");
}
// Тестирование, что произведение матрицы и её обратной дает единичную матрицу
@Test
public void testMultiply2() {
float[] elements = {
2, -1, 0,
-1, 2, -1,
0, -1, 2
};
Matrix3f matrix = new Matrix3f(elements);
Matrix3f inverse = matrix.inverse();
matrix.multiply(inverse);
Matrix3f identity = new Matrix3f(1);
// Проверяем, что произведение матрицы и её обратной дает единичную матрицу
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
float expectedValue = identity.getElements()[i][j];
float actualValue = matrix.getElements()[i][j];
Assertions.assertEquals(expectedValue, actualValue, 1e-4,
String.format("Элемент произведения [%d][%d] отличается: ожидается=%.4f, получили=%.4f",
i, j, expectedValue, actualValue));
}
}
}
// Тестирование, что обратная матрица обратной матрицы равна исходной матрице
@Test
public void testInverse4() {
// Задание элементов исходной матрицы 3x3
float[] elements = {
3, 0, 2,
2, 0, -2,
0, 1, 1
};
Matrix3f matrix = new Matrix3f(elements);
Matrix3f inverse = matrix.inverse();
Matrix3f inverseOfInverse = inverse.inverse();
float[][] original = matrix.getElements();
float[][] reconstructed = inverseOfInverse.getElements();
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 3; j++) {
float originalValue = original[i][j];
float reconstructedValue = reconstructed[i][j];
Assertions.assertEquals(originalValue, reconstructedValue, 1e-4,
String.format("Элемент матрицы [%d][%d] отличается: оригинал=%.5f, восстановлено=%.5f",
i, j, originalValue, reconstructedValue));
}
}
}
}
ASSISTANT
Конечно! Ниже представлен пример набора тестов для метода `multiplyMatrix4ByVector3`. Эти тесты покрывают различные сценарии, включая умножение на единичную матрицу, нулевую матрицу, матрицу с известными значениями, а также обработку случаев, когда `w` равно 1, не равно 1 и равно 0 (что может вызвать деление на ноль).
Предположим, что классы `Matrix4f` и `Vector3f` имеют следующие конструктора и методы:
- `Matrix4f(float[] elements)`: Конструктор, принимающий массив из 16 элементов (4x4 матрица).
- `Matrix4f(float diagonal)`: Конструктор, создающий диагональную матрицу с указанным значением на диагонали.
- `Matrix4f()`: Конструктор по умолчанию, создающий нулевую матрицу.
- `float getElement(int row, int column)`: Метод для получения элемента матрицы по указанным индексам.
- `Vector3f(float x, float y, float z)`: Конструктор вектора.
- Геттеры `getX()`, `getY()`, `getZ()` для `Vector3f`.
- Переопределенный метод `equals` для корректного сравнения объектов `Vector3f`.
### Пример тестового класса
```java
package com.cgvsu.math.tests;
import com.cgvsu.math.Matrix4f;
import com.cgvsu.math.Vector3f;
import org.junit.jupiter.api.Assertions;
import org.junit.jupiter.api.Test;
public class Matrix4fMultiplyVector3fTest {
/**
* Тестирование умножения единичной матрицы на вектор.
* Ожидается, что результат будет равен исходному вектору.
*/
@Test
public void testMultiplyIdentityMatrix() {
Matrix4f identity = new Matrix4f(new float[]{
1, 0, 0, 0, // Столбец 0
0, 1, 0, 0, // Столбец 1
0, 0, 1, 0, // Столбец 2
0, 0, 0, 1 // Столбец 3
});
Vector3f vertex = new Vector3f(3.0f, -2.0f, 5.0f);
Vector3f result = MathUtils.multiplyMatrix4ByVector3(identity, vertex);
Assertions.assertEquals(vertex, result, "Умножение единичной матрицы должно вернуть исходный вектор");
}
/**
* Тестирование умножения нулевой матрицы на вектор.
* Ожидается, что результат будет зависеть только от последнего столбца матрицы.
*/
@Test
public void testMultiplyZeroMatrix() {
Matrix4f zeroMatrix = new Matrix4f(); // Нулевая матрица
// Установим последний столбец, чтобы задать смещение
zeroMatrix = new Matrix4f(new float[]{
0, 0, 0, 0, // Столбец 0
0, 0, 0, 0, // Столбец 1
0, 0, 0, 0, // Столбец 2
1, 2, 3, 1 // Столбец 3 (например, смещение)
});
Vector3f vertex = new Vector3f(4.0f, -1.0f, 2.0f);
// Расчет вручную:
// x = 4*0 + (-1)*0 + 2*0 + 1 = 1
// y = 4*0 + (-1)*0 + 2*0 + 2 = 2
// z = 4*0 + (-1)*0 + 2*0 + 3 = 3
// w = 4*0 + (-1)*0 + 2*0 + 1 = 1
Vector3f expected = new Vector3f(1.0f, 2.0f, 3.0f);
Vector3f result = MathUtils.multiplyMatrix4ByVector3(zeroMatrix, vertex);
Assertions.assertEquals(expected, result, "Умножение нулевой матрицы с смещением должно вернуть смещение");
}
/**
* Тестирование умножения произвольной матрицы на вектор.
*/
@Test
public void testMultiplyArbitraryMatrix() {
Matrix4f matrix = new Matrix4f(new float[]{
2, 0, 0, 1, // Столбец 0
0, 3, 0, 2, // Столбец 1
0, 0, 4, 3, // Столбец 2
0, 0, 0, 1 // Столбец 3
});
Vector3f vertex = new Vector3f(1.0f, 1.0f, 1.0f);
// Расчет вручную:
// x = 1*2 + 1*0 + 1*0 + 0 = 2
// y = 1*0 + 1*3 + 1*0 + 0 = 3
// z = 1*0 + 1*0 + 1*4 + 0 = 4
// w = 1*1 + 1*2 + 1*3 + 1 = 7
// Результирующий вектор: (2/7, 3/7, 4/7)
Vector3f expected = new Vector3f(2.0f / 7.0f, 3.0f / 7.0f, 4.0f / 7.0f);
Vector3f result = MathUtils.multiplyMatrix4ByVector3(matrix, vertex);
Assertions.assertEquals(expected, result, "Умножение произвольной матрицы на вектор выполнено неверно");
}
/**
* Тестирование умножения матрицы с w != 1.
*/
@Test
public void testMultiplyMatrixWithWNotOne() {
Matrix4f matrix = new Matrix4f(new float[]{
1, 0, 0, 0, // Столбец 0
0, 1, 0, 0, // Столбец 1
0, 0, 1, 0, // Столбец 2
0, 0, 0, 2 // Столбец 3 (w = 2)
});
Vector3f vertex = new Vector3f(2.0f, 4.0f, 6.0f);
// Расчет вручную:
// x = 2*1 + 4*0 + 6*0 + 0 = 2
// y = 2*0 + 4*1 + 6*0 + 0 = 4
// z = 2*0 + 4*0 + 6*1 + 0 = 6
// w = 2*0 + 4*0 + 6*0 + 2 = 2
// Результирующий вектор: (2/2, 4/2, 6/2) = (1, 2, 3)
Vector3f expected = new Vector3f(1.0f, 2.0f, 3.0f);
Vector3f result = MathUtils.multiplyMatrix4ByVector3(matrix, vertex);
Assertions.assertEquals(expected, result, "Умножение матрицы с w != 1 выполнено неверно");
}
/**
* Тестирование умножения матрицы, приводящего к w = 0.
* Ожидается, что метод выбросит ArithmeticException из-за деления на ноль.
*/
@Test
public void testMultiplyMatrixResultingInWZero() {
Matrix4f matrix = new Matrix4f(new float[]{
1, 2, 3, 4, // Столбец 0
5, 6, 7, 8, // Столбец 1
9, 10, 11, 12, // Столбец 2
- (1 * 1 + 1 * 2 + 1 * 3) // Столбец 3, чтобы w = x*1 + y*2 + z*3 + w3 = 0
});
Vector3f vertex = new Vector3f(1.0f, 1.0f, 1.0f);
// Для упрощения, настроим матрицу так, чтобы:
// w = 1*matrix(0,3) + 1*matrix(1,3) + 1*matrix(2,3) + matrix(3,3) = 0
// Например, matrix(3,3) = - (1 + 2 + 3) = -6
matrix = new Matrix4f(new float[]{
1, 5, 9, 0, // Столбец 0
2, 6, 10, 0, // Столбец 1
3, 7, 11, 0, // Столбец 2
0, 0, 0, -6 // Столбец 3
});
// Применим метод:
// x = 1*1 + 1*2 + 1*3 + (-6) = 0
// y = 1*5 + 1*6 + 1*7 + 0 = 18
// z = 1*9 + 1*10 + 1*11 + 0 = 30
// w = 1*0 + 1*0 + 1*0 + (-6) = -6
// Так как x = 0, y = 18, z = 30, w = -6, то:
// результат: (0/-6, 18/-6, 30/-6) = (0, -3, -5)
Vector3f expected = new Vector3f(0.0f, -3.0f, -5.0f);
Vector3f result = MathUtils.multiplyMatrix4ByVector3(matrix, vertex);
Assertions.assertEquals(expected, result, "Умножение матрицы привело к корректному результату даже при w != 1");
}
/**
* Тестирование случая, когда w = 0, что должно привести к ArithmeticException.
*/
@Test
public void testMultiplyMatrixLeadingToWZeroException() {
Matrix4f matrix = new Matrix4f(new float[]{
1, 0, 0, 0, // Столбец 0
0, 1, 0, 0, // Столбец 1
0, 0, 1, 0, // Столбец 2
-1, -1, -1, 1 // Столбец 3 так, чтобы w = x* -1 + y* -1 + z* -1 + 1 = 0
});
Vector3f vertex = new Vector3f(1.0f, 1.0f, 1.0f);
// w = 1*(-1) + 1*(-1) + 1*(-1) + 1 = -3 + 1 = -2 != 0, чтобы сделать w = 0, изменим последнюю составляющую
matrix = new Matrix4f(new float[]{
1, 0, 0, 0,
0, 1, 0, 0,
0, 0, 1, 0,
-1, -1, -1, 3 // Теперь w = -1 -1 -1 + 3 = 0
});
// Ожидаем, что метод выбросит ArithmeticException из-за деления на ноль
Assertions.assertThrows(ArithmeticException.class, () -> {
MathUtils.multiplyMatrix4ByVector3(matrix, vertex);
}, "Должно выбрасываться ArithmeticException при w = 0");
}
/**
* Тестирование умножения матрицы с произвольными значениями и проверка точности результата.
*/
@Test
public void testMultiplyMatrixWithFloatingPoints() {
Matrix4f matrix = new Matrix4f(new float[]{
1.5f, 0.0f, 0.0f, 2.0f, // Столбец 0
0.0f, 2.5f, 0.0f, -1.0f, // Столбец 1
0.0f, 0.0f, 3.5f, 0.5f, // Столбец 2
0.0f, 0.0f, 0.0f, 1.0f // Столбец 3
});
Vector3f vertex = new Vector3f(2.0f, -1.0f, 4.0f);
// Расчет:
// x = 2*1.5 + (-1)*0 + 4*0 + 0 = 3 + 0 + 0 + 0 = 3
// y = 2*0 + (-1)*2.5 + 4*0 + 0 = 0 -2.5 + 0 + 0 = -2.5
// z = 2*0 + (-1)*0 + 4*3.5 + 0 = 0 + 0 + 14 + 0 = 14
// w = 2*2 + (-1)*(-1) + 4*0.5 + 1 = 4 + 1 + 2 + 1 = 8
// Результирующий вектор: (3/8, -2.5/8, 14/8) = (0.375, -0.3125, 1.75)
Vector3f expected = new Vector3f(0.375f, -0.3125f, 1.75f);
Vector3f result = MathUtils.multiplyMatrix4ByVector3(matrix, vertex);
Assertions.assertEquals(expected, result, "Умножение матрицы с плавающими точками выполнено неверно");
}
/**
* Тестирование умножения матрицы, представляющей масштабирование, на вектор.
*/
@Test
public void testMultiplyScalingMatrix() {
// Матрица масштабирования: масштабируем x в 2 раза, y в 3 раза, z в 4 раза
Matrix4f scalingMatrix = new Matrix4f(new float[]{
2, 0, 0, 0, // Столбец 0
0, 3, 0, 0, // Столбец 1
0, 0, 4, 0, // Столбец 2
0, 0, 0, 1 // Столбец 3
});
Vector3f vertex = new Vector3f(1.0f, 1.0f, 1.0f);
Vector3f expected = new Vector3f(2.0f, 3.0f, 4.0f);
Vector3f result = MathUtils.multiplyMatrix4ByVector3(scalingMatrix, vertex);
Assertions.assertEquals(expected, result, "Умножение матрицы масштабирования на вектор выполнено неверно");
}
/**
* Тестирование умножения матрицы трансляции на вектор.
*/
@Test
public void testMultiplyTranslationMatrix() {
// Матрица трансляции: смещение на (5, -3, 2)
Matrix4f translationMatrix = new Matrix4f(new float[]{
1, 0, 0, 0, // Столбец 0
0, 1, 0, 0, // Столбец 1
0, 0, 1, 0, // Столбец 2
5, -3, 2, 1 // Столбец 3
});
Vector3f vertex = new Vector3f(1.0f, 2.0f, 3.0f);
// Расчет:
// x = 1*1 + 2*0 + 3*0 + 5 = 1 + 0 + 0 + 5 = 6
// y = 1*0 + 2*1 + 3*0 + (-3) = 0 + 2 + 0 -3 = -1
// z = 1*0 + 2*0 + 3*1 + 2 = 0 + 0 + 3 + 2 = 5
// w = 1*0 + 2*0 + 3*0 + 1 = 0 + 0 + 0 +1 = 1
Vector3f expected = new Vector3f(6.0f, -1.0f, 5.0f);
Vector3f result = MathUtils.multiplyMatrix4ByVector3(translationMatrix, vertex);
Assertions.assertEquals(expected, result, "Умножение матрицы трансляции на вектор выполнено неверно");
}
/**
* Тестирование умножения матрицы перспективного проецирования на вектор.
*/
@Test
public void testMultiplyPerspectiveProjectionMatrix() {
// Простая перспективная матрица для теста (не реальная):
Matrix4f perspectiveMatrix = new Matrix4f(new float[]{
1, 0, 0, 0, // Столбец 0
0, 1, 0, 0, // Столбец 1
0, 0, 1, 1, // Столбец 2
0, 0, -1, 0 // Столбец 3
});
Vector3f vertex = new Vector3f(1.0f, 1.0f, 1.0f);
// Расчет:
// x = 1*1 + 1*0 + 1*0 + 0 = 1
// y = 1*0 + 1*1 + 1*0 + 0 = 1
// z = 1*0 + 1*0 + 1*1 + 1*(-1) = 1 -1 = 0
// w = 1*0 + 1*0 + 1*(-1) + 0*0 = -1
// Результирующий вектор: (1/-1, 1/-1, 0/-1) = (-1, -1, 0)
Vector3f expected = new Vector3f(-1.0f, -1.0f, 0.0f);
Vector3f result = MathUtils.multiplyMatrix4ByVector3(perspectiveMatrix, vertex);
Assertions.assertEquals(expected, result, "Умножение матрицы перспективного проецирования на вектор выполнено неверно");
}
}
```
### Пояснения к тестам
1. **`testMultiplyIdentityMatrix`**:
- Проверяет, что умножение единичной матрицы на вектор возвращает исходный вектор без изменений.
2. **`testMultiplyZeroMatrix`**:
- Проверяет умножение нулевой матрицы с заданным смещением на вектор. Ожидается, что результат будет равен смещению.
3. **`testMultiplyArbitraryMatrix`**:
- Умножает произвольную матрицу на вектор и проверяет точность результатов.
4. **`testMultiplyMatrixWithWNotOne`**:
- Проверяет случай, когда `w` после умножения не равен 1, и выполняет правильное нормирование результирующего вектора.
5. **`testMultiplyMatrixLeadingToWZeroException`**:
- Проверяет ситуацию, когда результат `w` равен 0, что может привести к делению на ноль. Ожидается, что метод выбросит `ArithmeticException`.
6. **`testMultiplyMatrixWithFloatingPoints`**:
- Умножение матрицы с плавающими точками на вектор, проверяя точность результата.
7. **`testMultiplyScalingMatrix`**:
- Умножение матрицы масштабирования на вектор, проверяя корректность масштабирования по осям.
8. **`testMultiplyTranslationMatrix`**:
- Умножение матрицы трансляции на вектор, проверяя корректность смещения.
9. **`testMultiplyPerspectiveProjectionMatrix`**:
- Умножение матрицы перспективного проецирования на вектор, проверяя корректность перспективного деления.
### Вспомогательный класс `MathUtils`
Предполагается, что метод `multiplyMatrix4ByVector3` находится в классе `MathUtils`. Если метод находится в другом классе, замените `MathUtils` на соответствующее имя класса.
```java
package com.cgvsu.math;
public class MathUtils {
public static Vector3f multiplyMatrix4ByVector3(final Matrix4f matrix, final Vector3f vertex) {
final float x = (vertex.getX() * matrix.getElement(0, 0)) + (vertex.getY() * matrix.getElement(1, 0)) + (vertex.getZ() * matrix.getElement(2, 0)) + matrix.getElement(3, 0);
final float y = (vertex.getX() * matrix.getElement(0, 1)) + (vertex.getY() * matrix.getElement(1, 1)) + (vertex.getZ() * matrix.getElement(2, 1)) + matrix.getElement(3, 1);
final float z = (vertex.getX() * matrix.getElement(0, 2)) + (vertex.getY() * matrix.getElement(1, 2)) + (vertex.getZ() * matrix.getElement(2, 2)) + matrix.getElement(3, 2);
final float w = (vertex.getX() * matrix.getElement(0, 3)) + (vertex.getY() * matrix.getElement(1, 3)) + (vertex.getZ() * matrix.getElement(2, 3)) + matrix.getElement(3, 3);
if (w == 0) {
throw new ArithmeticException("w равно нулю, невозможно выполнить деление на ноль");
}
return new Vector3f(x / w, y / w, z / w);
}
}
```
### Вспомогательные замечания
1. **Точность сравнения**: В методах `Assertions.assertEquals` для объектов `Vector3f` необходимо, чтобы класс `Vector3f` корректно переопределял метод `equals`, учитывая точность чисел с плавающей точкой. Если это не так, можно использовать сравнение компонентов с допустимой погрешностью.
2. **Исключения**: В тестах, где ожидается выброс исключения (`ArithmeticException`), убедитесь, что метод `multiplyMatrix4ByVector3` действительно выбрасывает такое исключение при делении на ноль. В приведенном примере добавлено условие `if (w == 0)` для выброса исключения.
3. **Организация кода**: Все тесты сгруппированы в одном классе `Matrix4fMultiplyVector3fTest` для удобства. При необходимости можно разделить их на несколько классов по логическим категориям.
4. **Покрытие тестами**: Представленные тесты покрывают основные сценарии, однако в зависимости от требований проекта могут потребоваться дополнительные тесты, например, для проверки границ значений, работы с отрицательными и очень большими числами и т.д.
### Заключение
Представленные тесты обеспечивают комплексное покрытие метода `multiplyMatrix4ByVector3`, проверяя как стандартные случаи, так и граничные условия. Убедитесь, что все зависимости (`Matrix4f`, `Vector3f`, `MathUtils`) корректно реализованы и доступны в вашем проекте для успешного выполнения тестов.