def test_matmul(self) -> None:
self.assertEqual(rows((range(3), range(3, 6))) @ rows((range(6, 9), range(9, 12))), 145)
self.assertEqual(row(range(5, -1, -1)) @ row(range(6)), 20)
self.assertEqual(column(range(5, -1, -1)) @ column(range(6)), 20)
self.assertEqual(vector(range(5, -1, -1)) @ vector(range(6)), 20)
self.assertRaises(DimensionError, matmul, row(range(5)), column(range(5)))
self.assertRaises(DimensionError, matmul, row(range(5)), row(range(6)))
def test_1(self) -> None:
field = ElectrostaticField()
field.charges = [DiscreteCharge(vector((0, 0)), 1)]
a = abs(field.force(DiscreteCharge(vector((1, 0)), 1)))
field.charges = [DiscreteCharge(vector((0, 0)), 2)]
b = abs(field.force(DiscreteCharge(vector((1, -1)), -2)))
self.assertLess(a, b)
def test_double_integrate(self) -> None:
self.assertAlmostEqual(
double_integrate(lambda x, y: x * y**2,
0,
1,
lambda x: 0,
pos,
steps=100,
integrator=MidpointIntegrator()), 1 / 15, 3)
self.assertAlmostEqual(
double_integrate(lambda x, y: x * y**2,
0,
1,
lambda x: 0,
pos,
steps=100,
integrator=TrapezoidIntegrator()), 1 / 15, 3)
self.assertAlmostEqual(
double_integrate(lambda x, y: x * y**2,
0,
1,
lambda x: 0,
pos,
steps=100,
integrator=SimpsonIntegrator()), 1 / 15)
self.assertAlmostEqual(
double_integrate(lambda x, y: x**2 * y,
0,
1,
lambda x: 0,
pos,
steps=100,
integrator=MidpointIntegrator()), 0.1, 4)
self.assertAlmostEqual(
double_integrate(lambda x, y: x**2 * y,
0,
1,
lambda x: 0,
pos,
steps=100,
integrator=TrapezoidIntegrator()), 0.1, 4)
self.assertAlmostEqual(
double_integrate(lambda x, y: x**2 * y,
0,
1,
lambda x: 0,
pos,
steps=100,
integrator=SimpsonIntegrator()), 0.1)
self.assertIterableAlmostEqual(
double_integrate(
lambda x, y: vector((2 * y, 2 * x + y**2, 3 * x * y)),
-10,
1,
lambda x: -2 * x,
lambda x: x,
steps=100,
), vector((-1001, -5497.25, 11248.875)))
def test_add(self) -> None:
self.assertEqual(
rows((range(3), range(3, 6))) + rows((range(6, 9), range(9, 12))), rows(((6, 8, 10), (12, 14, 16))))
self.assertEqual(row(range(5, -1, -1)) + row(range(6)), row((5,) * 6))
self.assertEqual(column(range(5, -1, -1)) + column(range(6)), column((5,) * 6))
self.assertEqual(vector(range(5, -1, -1)) + vector(range(6)), vector((5,) * 6))
self.assertRaises(TypeError, add, row(range(5)), 5)
self.assertRaises(DimensionError, add, row(range(5)), column(range(5)))
self.assertRaises(DimensionError, add, row(range(5)), row(range(6)))
self.assertRaises(DimensionError, add, row(range(5)), vector(range(5)))
def test_getitem(self) -> None:
self.assertEqual(rows((range(3), range(3, 6)))[4], 4)
self.assertEqual(row(range(6))[4], 4)
self.assertEqual(column(range(6))[4], 4)
self.assertEqual(vector(range(6))[4], 4)
self.assertIterableEqual(rows((range(3), range(3, 6)))[2:5], range(2, 5))
self.assertIterableEqual(row(range(6))[2:5], range(2, 5))
self.assertIterableEqual(column(range(6))[2:5], range(2, 5))
self.assertIterableEqual(vector(range(6))[2:5], range(2, 5))
def test_2(self) -> None:
field = ElectrostaticField()
field.charges = [
DiscreteCharge(vector((0, 0)), 2),
DiscreteCharge(vector((0.5, sqrt(1 - 0.5**2))), -1)
]
e = field.intensity(vector((1, 0)))
self.assertGreater(e[0], 0)
self.assertGreater(e[1], 0)
self.assertLess(e[1], e[0])
def test_3(self) -> None:
q, a = -1e-9, 1
field = ElectrostaticField()
field.charges = [
DiscreteCharge(vector((a, 0, 0)), q),
DiscreteCharge(vector((0, a, 0)), q),
DiscreteCharge(vector((0, 0, a)), q),
]
self.assertIterableAlmostEqual(field.intensity(zero_vector(3)),
repeat(8.987551792261172, 3))
self.assertIterableAlmostEqual(field.intensity(vector((0, 0, 100))),
(0, 0, -0.0027142443154663546), 4)
def test_triple_integrate(self) -> None:
self.assertAlmostEqual(
triple_integrate(
lambda x, y, z: sin(x) * cos(y) * z,
-5,
1,
lambda x: -10,
pos,
lambda x, y: -x * y * 2,
mul,
steps=50,
integrator=MidpointIntegrator(),
), 1289.4240604730014, -1)
self.assertAlmostEqual(
triple_integrate(
lambda x, y, z: sin(x) * cos(y) * z,
-5,
1,
lambda x: -10,
pos,
lambda x, y: -x * y * 2,
mul,
steps=50,
integrator=TrapezoidIntegrator(),
), 1289.4240604730014, -1)
self.assertAlmostEqual(
triple_integrate(
lambda x, y, z: sin(x) * cos(y) * z,
-5,
1,
lambda x: -10,
pos,
lambda x, y: -x * y * 2,
mul,
steps=50,
integrator=SimpsonIntegrator(),
), 1289.4240604730014, 3)
self.assertIterableAlmostEqual(
triple_integrate(
lambda x, y, z: vector((1**(x * y * z), x + y + z, x * y * z)),
-1,
2,
lambda x: -x,
lambda x: 2 * x,
lambda x, y: -x * y,
lambda x, y: 2 * x * y,
steps=10,
), vector((16.875, 136.35, 179.296875)), 0)
def test_mul(self) -> None:
self.assertEqual(
rows((range(3), range(3, 6))) * rows((range(2), range(2, 4), range(4, 6))), rows(((10, 13), (28, 40))))
self.assertEqual(row(range(5, -1, -1)) * column(range(6)), singleton_matrix(20))
self.assertEqual(column(range(6)) * row(range(6)), rows((
(0,) * 6, range(6), range(0, 12, 2), range(0, 18, 3), range(0, 24, 4), range(0, 30, 5),
)))
self.assertEqual(row(range(5, -1, -1)) * vector(range(6)), singleton_vector(20))
self.assertRaises(DimensionError, mul, row(range(5)), row(range(5)))
self.assertRaises(DimensionError, mul, row(range(5)), column(range(6)))
def test_integrate(self) -> None:
self.assertAlmostEqual(
integrate(lambda x: x**2,
-1,
1,
steps=100,
integrator=MidpointIntegrator()), 2 / 3, 3)
self.assertAlmostEqual(
integrate(lambda x: x**2,
-1,
1,
steps=100,
integrator=TrapezoidIntegrator()), 2 / 3, 3)
self.assertAlmostEqual(
integrate(lambda x: x**2,
-1,
1,
steps=100,
integrator=SimpsonIntegrator()), 2 / 3)
self.assertAlmostEqual(
integrate(sin,
0,
2 * pi,
steps=100,
integrator=MidpointIntegrator()), 0)
self.assertAlmostEqual(
integrate(sin,
0,
2 * pi,
steps=100,
integrator=TrapezoidIntegrator()), 0)
self.assertAlmostEqual(
integrate(sin,
0,
2 * pi,
steps=100,
integrator=SimpsonIntegrator()), 0)
self.assertIterableAlmostEqual(
integrate(lambda x: vector((0, 2 * x, 3 * x**2)), -1, 1,
steps=100), vector((0, 0, 2)))
def test_w(self) -> None:
self.assertEqual(vector(range(1, 1)).w, 0)
self.assertEqual(vector(range(1, 2)).w, 0)
self.assertEqual(vector(range(1, 3)).w, 0)
self.assertEqual(vector(range(1, 4)).w, 0)
self.assertEqual(vector(range(1, 5)).w, 4)
self.assertEqual(vector(range(1, 6)).w, 4)
def test_parallel_to(self) -> None:
self.assertTrue(vector((1, 0, 0)).parallel_to(vector((100, 0, 0))))
self.assertTrue(vector((1, 0, 0)).parallel_to(vector((-100, 0, 0))))
self.assertFalse(vector((1, 0, 0)).parallel_to(vector((-100, 1, 0))))
self.assertTrue(i.parallel_to(i))
self.assertFalse(i.parallel_to(j))
self.assertFalse(i.parallel_to(k))
self.assertFalse(j.parallel_to(i))
self.assertTrue(j.parallel_to(j))
self.assertFalse(j.parallel_to(k))
self.assertFalse(k.parallel_to(i))
self.assertFalse(k.parallel_to(j))
self.assertTrue(k.parallel_to(k))
def test_pos(self) -> None:
self.assertEqual(+rows((range(3), range(3, 6))), rows((range(3), range(3, 6))))
self.assertEqual(+row(range(6)), row(range(6)))
self.assertEqual(+column(range(6)), column(range(6)))
self.assertEqual(+vector(range(6)), vector(range(6)))
def test_div(self) -> None:
self.assertEqual(rows((range(0, 15, 5), range(15, 30, 5))) / 5, rows((range(3), range(3, 6))))
self.assertEqual(row(range(25, -1, -5)) / 5, row(range(5, -1, -1)))
self.assertEqual(column(range(25, -1, -5)) / 5, column(range(5, -1, -1)))
self.assertEqual(vector(range(25, -1, -5)) / 5, vector(range(5, -1, -1)))
def test_rmul(self) -> None:
self.assertEqual(5 * rows((range(3), range(3, 6))), rows((range(0, 15, 5), range(15, 30, 5))))
self.assertEqual(5 * row(range(5, -1, -1)), row(range(25, -1, -5)))
self.assertEqual(5 * column(range(5, -1, -1)), column(range(25, -1, -5)))
self.assertEqual(5 * vector(range(5, -1, -1)), vector(range(25, -1, -5)))
def test_sub(self) -> None:
self.assertEqual(
rows((range(3), range(3, 6))) - rows((range(6, 9), range(9, 12))), rows(((-6, -6, -6), (-6, -6, -6))))
self.assertEqual(row(range(5, -1, -1)) - row(range(6)), row(range(5, -6, -2)))
self.assertEqual(column(range(5, -1, -1)) - column(range(6)), column(range(5, -6, -2)))
self.assertEqual(vector(range(5, -1, -1)) - vector(range(6)), vector(range(5, -6, -2)))
def test_norm(self) -> None:
self.assertAlmostEqual(norm(row((1 / sqrt(2), 1 / sqrt(2)))), 1)
self.assertAlmostEqual(norm(column((1, 0, 0))), 1)
self.assertAlmostEqual(norm(vector(range(5))), abs(vector(range(5))))
self.assertAlmostEqual(norm(identity_matrix(2)), sqrt(2))
def test_one_vector(self) -> None:
self.assertEqual(one_vector(0), empty_vector())
self.assertEqual(one_vector(5), vector((1,) * 5))
def test_zero_vector(self) -> None:
self.assertEqual(zero_vector(0), empty_vector())
self.assertEqual(zero_vector(5), vector((0,) * 5))
def test_unit(self) -> None:
self.assertIterableAlmostEqual(vector((1, 1)).unit, vector((1 / sqrt(2), 1 / sqrt(2))))
self.assertIterableAlmostEqual(vector((100, 0)).unit, vector((1, 0)))
self.assertIterableAlmostEqual(vector((0, 100, 0)).unit, j)
def test_vector(self) -> None:
self.assertEqual(vector(range(5)).dimensions, (5,))
def test_projection_on(self) -> None:
self.assertIterableAlmostEqual(vector((1, 1, 1)).projection_on(i), vector((1, 0, 0)))
self.assertIterableAlmostEqual(vector((100, 100, 100)).projection_on(i), vector((100, 0, 0)))
self.assertIterableAlmostEqual(vector((100, 100, 100)).projection_on(j), vector((0, 100, 0)))
self.assertIterableAlmostEqual(vector((100, 100, 100)).projection_on(k), vector((0, 0, 100)))
def test_angle_between(self) -> None:
self.assertAlmostEqual(vector((1, 0)).angle_between(vector((0, 10))), pi / 2)
self.assertAlmostEqual(vector((1, 0)).angle_between(vector((1000, 0))), 0)
self.assertAlmostEqual(vector((1, 0)).angle_between(vector((-1000, 0))), pi)
def test_neg(self) -> None:
self.assertEqual(-rows((range(3), range(3, 6))), rows((range(0, -3, -1), range(-3, -6, -1))))
self.assertEqual(-row(range(6)), rows((range(0, -6, -1),)))
self.assertEqual(-column(range(6)), rows(tuple((-x,) for x in range(6))))
self.assertEqual(-vector(range(6)), vector(range(0, -6, -1)))
def test_singleton_vector(self) -> None:
self.assertEqual(singleton_vector(5), vector((5,)))
self.assertEqual(singleton_vector(0), vector((0,)))
self.assertEqual(singleton_vector(10), vector((10,)))
def test_full_vector(self) -> None:
self.assertEqual(full_vector(int, 5), vector(range(5)))
