From faabe210b0a11636f10bf910bb8e6555300d1e91 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Andr=C3=A9=20Wobst?= Date: Thu, 5 Aug 2004 15:41:55 +0000 Subject: [PATCH] transformations added vector*matrix disallowed tests completed -> overall it now looks kind of complete to me (usability and integration in PyX needs to be discussed, but this is not a short time issue; I might come back later to that later on, but for now I'll try to focus myself on the 0.7 release) git-svn-id: https://pyx.svn.sourceforge.net/svnroot/pyx/trunk/pyx@1814 069f4177-920e-0410-937b-c2a4a81bcd90 --- test/experimental/solve.py | 163 +++++++++++++++------- test/experimental/test_solve.py | 298 +++++++++++++++++++++++++++++++++------- 2 files changed, 368 insertions(+), 93 deletions(-) diff --git a/test/experimental/solve.py b/test/experimental/solve.py index f319f7ec..03d9e59b 100644 --- a/test/experimental/solve.py +++ b/test/experimental/solve.py @@ -163,7 +163,7 @@ class addend: if len(setscalars): return float(addend(setscalars)) else: - return 1.0 + return 1 def variable(self): assert self.is_linear() @@ -232,12 +232,12 @@ class polynom: class vector: - # represents a vector, i.e. a list of terms + # represents a vector, i.e. a list of scalars (or polynoms) def __init__(self, dimension_or_values, name="unnamed_vector"): try: name + "" - except TypeError: + except: raise RuntimeError("a vectors name should be a string (you probably wanted to write vector([x, y]) instead of vector(x, y))") try: for value in dimension_or_values: @@ -298,26 +298,21 @@ class vector: def __mul__(self, other): try: - other = scalar(other) - except: - pass - try: other = other.vector() except (TypeError, AttributeError): - try: - other = other.polynom() - except (TypeError, AttributeError): - # inverse matrix multiplication ? - return other.__rmul__(self) - else: - return vector([item*other for item in self._items]) + return vector([item*other for item in self._items]) else: # scalar product if len(self) != len(other): raise RuntimeError("vector length mismatch in scalar product") return sum([selfitem*otheritem for selfitem, otheritem in zip(self._items, other._items)]) - __rmul__ = __mul__ + def __rmul__(self, other): + return vector([other*item for item in self._items]) + # We do not allow for vector * here (i.e. a + # simulating the behaviour of a dual vector). In principle we could do + # that, but for transformations it would lead to (a*X)*c != a*(X*c). + # Hence we disallow vector*X for X being something else that a scalar. def __div__(self, other): return vector([item/other for item in self._items]) @@ -330,13 +325,19 @@ class vector: solver.addequation(item) +class zerovector(vector): + + def __init__(self, dimension, name="0"): + vector.__init__(self, [0 for i in range(dimension)], name) + + class matrix: - # represents a matrix, i.e. a 2d list of terms + # represents a matrix, i.e. a 2d list of scalars (or polynoms) def __init__(self, dimensions_or_values, name="unnamed_matrix"): try: name + "" - except TypeError: + except: raise RuntimeError("a matrix name should be a string (you probably wanted to write matrix([x, y]) instead of matrix(x, y))") try: for row in dimensions_or_values: @@ -371,6 +372,13 @@ class matrix: raise RuntimeError("empty matrix not allowed") self.name = name + # instead of __len__ two methods to fetch the matrix dimensions + def getnumberofrows(self): + return self._numberofrows + + def getnumberofcols(self): + return self._numberofcols + def __getitem__(self, (row, col)): return self._rows[row][col] @@ -442,6 +450,97 @@ class matrix: solver.addequation(col) +class identitymatrix(matrix): + + def __init__(self, dimension, name="I"): + def eq(row, col): + if row == col: + return 1 + else: + return 0 + matrix.__init__(self, [[eq(row, col) for col in range(dimension)] for row in range(dimension)], name) + + +class trafo: + # represents a transformation, i.e. matrix and a constant vector + + def __init__(self, dimensions_or_values, name="unnamed_trafo"): + try: + name + "" + except: + raise RuntimeError("a trafo name should be a string (you probably wanted to write trafo([x, y]) instead of trafo(x, y))") + if len(dimensions_or_values) != 2: + raise RuntimeError("first parameter of a trafo must contain two elements: either two dimensions or a matrix and a vector") + try: + numberofrows, numberofcols = [int(x) for x in dimensions_or_values] + except: + self._matrix = dimensions_or_values[0].matrix() + self._vector = dimensions_or_values[1].vector() + if self._matrix.getnumberofrows() != len(self._vector): + raise RuntimeError("size mismatch between matrix and vector") + else: + self._matrix = matrix((numberofrows, numberofcols), name=name + "_matrix") + self._vector = vector(numberofrows, name=name + "_vector") + self.name = name + + def trafo(self): + return self + + def getmatrix(self): + return self._matrix + + def getvector(self): + return self._vector + + def __neg__(self): + return trafo((-self._matrix, -self._vector)) + + def __add__(self, other): + other = other.trafo() + return trafo((self._matrix + other._matrix, self._vector + other._vector)) + + __radd__ = __add__ + + def __sub__(self, other): + return -other + self + + def __rsub__(self, other): + return -self + other + + def __mul__(self, other): + try: + other = other.trafo() + except (TypeError, AttributeError): + try: + other = other.vector() + except (TypeError, AttributeError): + return trafo((self._matrix * other, self._vector * other)) + else: + return self._matrix * other + self._vector + else: + return trafo((self._matrix * other._matrix, self._vector + self._matrix * other._vector)) + + def __rmul__(self, other): + return trafo((other * self._matrix, other * self._vector)) + + def __div__(self, other): + return trafo((self._matrix/other, self._vector/other)) + + def __str__(self): + return "%s{=(matrix: %s, vector: %s)}" % (self.name, self._matrix, self._vector) + + def solve(self, solver): + self._matrix.solve(solver) + self._vector.solve(solver) + + +class identitytrafo(trafo): + + def __init__(self, dimension, name="I"): + trafo.__init__(self, (identitymatrix(dimension, name=name), + zerovector(dimension, name=name)), name) + + class Solver: # linear equation solver @@ -511,33 +610,3 @@ class Solver: solver = Solver() -if __name__ == "__main__": - - # x = vector(2, "x") - # y = vector(2, "y") - # z = vector(2, "z") - - # solver.eq(4*x + y, 2*x - y + vector([4, 0])) # => x + y = (2, 0) - # solver.eq(x[0] - y[0], z[1]) - # solver.eq(x[1] - y[1], z[0]) - # solver.eq(vector([5, 0]), z) - - # print x - # print y - # print z - - A = matrix([2, 2]) - solver.eq(vector([1, 1]), A * vector([0, 1])) - solver.eq(vector([0, 2]), A * vector([1, 0])) - - I = matrix([2, 2]) - solver.eq(vector([0, 1]), I * vector([0, 1])) - solver.eq(vector([1, 0]), I * vector([1, 0])) - - B = matrix([2, 2]) - solver.eq(I, A*B) - - print A - print B - - diff --git a/test/experimental/test_solve.py b/test/experimental/test_solve.py index 33f33be5..47b47885 100644 --- a/test/experimental/test_solve.py +++ b/test/experimental/test_solve.py @@ -1,12 +1,12 @@ import unittest, operator -from solve import scalar, vector, matrix, solver +from solve import scalar, vector, matrix, identitymatrix, trafo, identitytrafo, Solver class ScalarTestCase(unittest.TestCase): def testInit(self): - self.failUnlessRaises(RuntimeError, scalar, "") - self.failUnlessRaises(RuntimeError, scalar, 1j) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), scalar, "") + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), scalar, 1j) self.failUnlessEqual(str(scalar()), "unnamed_scalar") self.failUnlessEqual(str(scalar(name="s")), "s") self.failUnlessEqual(str(scalar(1)), "unnamed_scalar{=1.0}") @@ -26,22 +26,22 @@ class ScalarTestCase(unittest.TestCase): self.failUnlessEqual(str(scalar(name="s") / 2.0), "unnamed_scalar{=0.5} * s") self.failUnlessEqual(str(scalar(name="s") / 2), "unnamed_scalar{=0.0} * s") # integer logic! self.failUnlessEqual(str((scalar(name="s") + scalar(name="t")) / 2.0), "unnamed_scalar{=0.5} * s + unnamed_scalar{=0.5} * t") - self.failUnlessRaises(TypeError, lambda: 2 / scalar()) - self.failUnlessRaises(TypeError, lambda: scalar() / scalar()) - self.failUnlessRaises(TypeError, lambda: vector(1) / scalar()) - self.failUnlessRaises(TypeError, lambda: ((scalar() + scalar()) / scalar())) - self.failUnlessRaises(TypeError, lambda: (vector(1) + vector(1)) / scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, 2, scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, scalar(), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, vector(1), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, scalar() + scalar(), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, vector(1) + vector(1), scalar()) def testAccess(self): s = scalar() self.failUnlessEqual(s.is_set(), 0) - self.failUnlessRaises(RuntimeError, s.get) - self.failUnlessRaises(RuntimeError, float, s) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), s.get) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), float, s) s.set(2) self.failUnlessEqual(s.is_set(), 1) self.failUnlessAlmostEqual(s.get(), 2.0) self.failUnlessAlmostEqual(float(s), 2.0) - self.failUnlessRaises(RuntimeError, s.set, 3) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), s.set, 3) self.failUnlessEqual(s.is_set(), 1) self.failUnlessAlmostEqual(s.get(), 2.0) self.failUnlessAlmostEqual(float(s), 2.0) @@ -50,7 +50,7 @@ class ScalarTestCase(unittest.TestCase): self.failUnlessEqual(scalar(2).is_set(), 1) self.failUnlessAlmostEqual(s.get(), 2.0) self.failUnlessAlmostEqual(float(s), 2.0) - self.failUnlessRaises(RuntimeError, s.set, 3) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), s.set, 3) self.failUnlessEqual(s.is_set(), 1) self.failUnlessAlmostEqual(s.get(), 2.0) self.failUnlessAlmostEqual(float(s), 2.0) @@ -59,7 +59,7 @@ class ScalarTestCase(unittest.TestCase): class VectorTestCase(unittest.TestCase): def testInit(self): - self.failUnlessRaises(RuntimeError, vector, 0, 0) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), vector, 0, 0) self.failUnlessEqual(str(vector(2)), "unnamed_vector{=(unnamed_vector[0], unnamed_vector[1])}") self.failUnlessEqual(str(vector([1, 2])), "unnamed_vector{=(unnamed_vector[0]{=1.0}, unnamed_vector[1]{=2.0})}") self.failUnlessEqual(str(vector(3, "a")), "a{=(a[0], a[1], a[2])}") @@ -81,23 +81,23 @@ class VectorTestCase(unittest.TestCase): self.failUnlessAlmostEqual(float(a[0]), 2.0) self.failUnlessAlmostEqual(a.x.get(), 2.0) self.failUnlessAlmostEqual(float(a.x), 2.0) - self.failUnlessRaises(RuntimeError, a[1].get) - self.failUnlessRaises(RuntimeError, float, a[1]) - self.failUnlessRaises(RuntimeError, a.y.get) - self.failUnlessRaises(RuntimeError, float, a.y) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), a[1].get) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), float, a[1]) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), a.y.get) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), float, a.y) self.failUnlessEqual(a[0].is_set(), 1) self.failUnlessEqual(a.x.is_set(), 1) self.failUnlessEqual(a[1].is_set(), 0) self.failUnlessEqual(a.y.is_set(), 0) - self.failUnlessRaises(RuntimeError, a[0].set, 3) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), a[0].set, 3) self.failUnlessAlmostEqual(a[0].get(), 2.0) self.failUnlessAlmostEqual(float(a[0]), 2.0) self.failUnlessAlmostEqual(a.x.get(), 2.0) self.failUnlessAlmostEqual(float(a.x), 2.0) - self.failUnlessRaises(RuntimeError, a[1].get) - self.failUnlessRaises(RuntimeError, float, a[1]) - self.failUnlessRaises(RuntimeError, a.y.get) - self.failUnlessRaises(RuntimeError, float, a.y) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), a[1].get) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), float, a[1]) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), a.y.get) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), float, a.y) self.failUnlessEqual(a[0].is_set(), 1) self.failUnlessEqual(a.x.is_set(), 1) self.failUnlessEqual(a[1].is_set(), 0) @@ -117,7 +117,7 @@ class VectorTestCase(unittest.TestCase): self.failUnlessEqual(a.x.is_set(), 1) self.failUnlessEqual(a[1].is_set(), 1) self.failUnlessEqual(a.y.is_set(), 1) - self.failUnlessRaises(RuntimeError, a[0].set, 4) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), a[0].set, 4) self.failUnlessAlmostEqual(a[0].get(), 2.0) self.failUnlessAlmostEqual(float(a[0]), 2.0) self.failUnlessAlmostEqual(a.x.get(), 2.0) @@ -137,53 +137,259 @@ class VectorTestCase(unittest.TestCase): self.failUnlessEqual(str(a.z), "unnamed_vector[2]{=3.0}") def testLen(self): - for i in range(1, 10): + for i in range(1, 5): a = vector(i) self.failUnlessEqual(len(a), i) self.failUnlessEqual(str(a), "unnamed_vector{=(" + ", ".join(["unnamed_vector[%i]" % j for j in range(i)]) + ")}") - for i in range(1, 10): - a = -vector(i) - self.failUnlessEqual(len(a), i) - self.failUnlessEqual(str(a), "unnamed_vector{=(" + ", ".join(["unnamed_scalar{=-1.0} * unnamed_vector[%i]" % j for j in range(i)]) + ")}") def testMath(self): self.failUnlessEqual(str(-vector(2, "a")), "unnamed_vector{=(unnamed_scalar{=-1.0} * a[0], unnamed_scalar{=-1.0} * a[1])}") self.failUnlessEqual(str(vector(2, "a") + vector(2, "b")), "unnamed_vector{=(a[0] + b[0], a[1] + b[1])}") - self.failUnlessRaises(AttributeError, operator.__add__, vector(2), scalar()) - self.failUnlessRaises(RuntimeError, operator.__add__, vector(2), vector(3)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, 1, vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, vector(2), 1) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, scalar(), vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, vector(2), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, scalar() + scalar(), vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, vector(2), scalar() + scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, vector(2), vector(3)) self.failUnlessEqual(str(vector(2, "a") - vector(2, "b")), "unnamed_vector{=(unnamed_scalar{=-1.0} * b[0] + a[0], unnamed_scalar{=-1.0} * b[1] + a[1])}") - self.failUnlessRaises(RuntimeError, operator.__sub__, vector(2), scalar()) - self.failUnlessRaises(RuntimeError, operator.__sub__, vector(2), vector(3)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, 1, vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, vector(2), 1) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, scalar(), vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, vector(2), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, scalar() + scalar(), vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, vector(2), scalar() + scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, vector(2), vector(3)) self.failUnlessEqual(str(2 * vector(2, "a")), "unnamed_vector{=(a[0] * unnamed_scalar{=2.0}, a[1] * unnamed_scalar{=2.0})}") self.failUnlessEqual(str(vector(2, "a") * 2), "unnamed_vector{=(a[0] * unnamed_scalar{=2.0}, a[1] * unnamed_scalar{=2.0})}") - self.failUnlessEqual(str(scalar(name="s") * vector(2, "a")), "unnamed_vector{=(s * a[0], s * a[1])}") - self.failUnlessEqual(str(scalar(name="s") * (vector(2, "a") + vector(2, "b"))), "unnamed_vector{=(s * a[0] + s * b[0], s * a[1] + s * b[1])}") - self.failUnlessEqual(str((scalar(name="s") + scalar(name="t")) * vector(2, "a")), "unnamed_vector{=(s * a[0] + t * a[0], s * a[1] + t * a[1])}") - self.failUnlessEqual(str((scalar(name="s") + scalar(name="t")) * (vector(2, "a") + vector(2, "b"))), "unnamed_vector{=(s * a[0] + s * b[0] + t * a[0] + t * b[0], s * a[1] + s * b[1] + t * a[1] + t * b[1])}") - self.failUnlessEqual(str(vector(2, "a") * scalar(name="s")), "unnamed_vector{=(s * a[0], s * a[1])}") + self.failUnlessEqual(str(scalar(name="s") * vector(2, "a")), "unnamed_vector{=(a[0] * s, a[1] * s)}") + self.failUnlessEqual(str(scalar(name="s") * (vector(2, "a") + vector(2, "b"))), "unnamed_vector{=(a[0] * s + b[0] * s, a[1] * s + b[1] * s)}") + self.failUnlessEqual(str((scalar(name="s") + scalar(name="t")) * vector(2, "a")), "unnamed_vector{=(a[0] * s + a[0] * t, a[1] * s + a[1] * t)}") + self.failUnlessEqual(str((scalar(name="s") + scalar(name="t")) * (vector(2, "a") + vector(2, "b"))), "unnamed_vector{=(a[0] * s + b[0] * s + a[0] * t + b[0] * t, a[1] * s + b[1] * s + a[1] * t + b[1] * t)}") + self.failUnlessEqual(str(vector(2, "a") * scalar(name="s")), "unnamed_vector{=(a[0] * s, a[1] * s)}") self.failUnlessEqual(str(vector(2, "a") * vector(2, "b")), "a[0] * b[0] + a[1] * b[1]") - self.failUnlessRaises(RuntimeError, operator.__mul__, vector(2, "a"), vector(3)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__mul__, vector(2, "a"), vector(3)) self.failUnlessEqual(str(vector(2, "a") / 2.0), "unnamed_vector{=(unnamed_scalar{=0.5} * a[0], unnamed_scalar{=0.5} * a[1])}") self.failUnlessEqual(str(vector(2, "a") / 2), "unnamed_vector{=(unnamed_scalar{=0.0} * a[0], unnamed_scalar{=0.0} * a[1])}") # integer logic! - self.failUnlessRaises(TypeError, lambda: scalar() / vector(1)) - self.failUnlessRaises(TypeError, lambda: vector(1) / vector(1)) - self.failUnlessRaises(TypeError, lambda: (scalar() + scalar()) / vector(1)) - self.failUnlessRaises(TypeError, lambda: (vector(1) + vector(1)) / vector(1)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, scalar(), vector(1)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, scalar() + scalar(), vector(1)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, vector(1), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, vector(1), scalar() + scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, vector(1), vector(1)) class MatrixTestCase(unittest.TestCase): def testInit(self): - self.failUnlessEqual(str(matrix([2, 3])), "unnamed_matrix{=((unnamed_matrix[0, 0], unnamed_matrix[0, 1], unnamed_matrix[0, 2]), (unnamed_matrix[1, 0], unnamed_matrix[1, 1], unnamed_matrix[1, 2]))}") + self.failUnlessEqual(str(matrix((2, 3))), "unnamed_matrix{=((unnamed_matrix[0, 0], unnamed_matrix[0, 1], unnamed_matrix[0, 2]), (unnamed_matrix[1, 0], unnamed_matrix[1, 1], unnamed_matrix[1, 2]))}") self.failUnlessEqual(str(matrix([[1, 2, 3], [4, 5, 6]])), "unnamed_matrix{=((unnamed_matrix[0, 0]{=1.0}, unnamed_matrix[0, 1]{=2.0}, unnamed_matrix[0, 2]{=3.0}), (unnamed_matrix[1, 0]{=4.0}, unnamed_matrix[1, 1]{=5.0}, unnamed_matrix[1, 2]{=6.0}))}") - self.failUnlessEqual(str(matrix([2, 3], "a")), "a{=((a[0, 0], a[0, 1], a[0, 2]), (a[1, 0], a[1, 1], a[1, 2]))}") + self.failUnlessEqual(str(matrix((2, 3), "a")), "a{=((a[0, 0], a[0, 1], a[0, 2]), (a[1, 0], a[1, 1], a[1, 2]))}") self.failUnlessEqual(str(matrix([[1, 2, 3], [4, 5, 6]], "a")), "a{=((a[0, 0]{=1.0}, a[0, 1]{=2.0}, a[0, 2]{=3.0}), (a[1, 0]{=4.0}, a[1, 1]{=5.0}, a[1, 2]{=6.0}))}") + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), matrix, [[1, 2, 3], [4, 5]]) + + def testLen(self): + for rows in range(1, 5): + for cols in range(1, 5): + A = matrix((rows, cols)) + self.failUnlessEqual(A.getnumberofrows(), rows) + self.failUnlessEqual(A.getnumberofcols(), cols) + self.failUnlessEqual(str(A), "unnamed_matrix{=(" + ", ".join(["(" + ", ".join(["unnamed_matrix[%i, %i]" % (i, j) for j in range(cols)]) + ")" for i in range(rows)]) + ")}") + + def testAccess(self): + A = matrix([2, 3]) + self.failUnlessEqual(str(A), "unnamed_matrix{=((unnamed_matrix[0, 0], unnamed_matrix[0, 1], unnamed_matrix[0, 2]), (unnamed_matrix[1, 0], unnamed_matrix[1, 1], unnamed_matrix[1, 2]))}") + self.failUnlessEqual(A[0, 0].is_set(), 0) + self.failUnlessEqual(A[1, 0].is_set(), 0) + self.failUnlessRaises(IndexError, operator.__getitem__, A, (2, 0)) + self.failUnlessEqual(A[0, 1].is_set(), 0) + self.failUnlessEqual(A[1, 1].is_set(), 0) + self.failUnlessEqual(A[0, 2].is_set(), 0) + self.failUnlessEqual(A[1, 2].is_set(), 0) + self.failUnlessRaises(IndexError, operator.__getitem__, A, (0, 3)) + A[0, 0].set(1) + self.failUnlessEqual(A[0, 0].is_set(), 1) + self.failUnlessEqual(A[0, 1].is_set(), 0) + self.failUnlessEqual(A[1, 0].is_set(), 0) + self.failUnlessAlmostEqual(A[0, 0].get(), 1.0) + self.failUnlessAlmostEqual(float(A[0, 0]), 1.0) def testMath(self): - self.failUnlessEqual(str(-matrix([2, 2], "A")), "unnamed_matrix{=((unnamed_scalar{=-1.0} * A[0, 0], unnamed_scalar{=-1.0} * A[0, 1]), (unnamed_scalar{=-1.0} * A[1, 0], unnamed_scalar{=-1.0} * A[1, 1]))}") + self.failUnlessEqual(str(-matrix([2, 3], "A")), "unnamed_matrix{=((unnamed_scalar{=-1.0} * A[0, 0], unnamed_scalar{=-1.0} * A[0, 1], unnamed_scalar{=-1.0} * A[0, 2]), (unnamed_scalar{=-1.0} * A[1, 0], unnamed_scalar{=-1.0} * A[1, 1], unnamed_scalar{=-1.0} * A[1, 2]))}") self.failUnlessEqual(str(matrix([2, 3], "A") + matrix([2, 3], "B")), "unnamed_matrix{=((A[0, 0] + B[0, 0], A[0, 1] + B[0, 1], A[0, 2] + B[0, 2]), (A[1, 0] + B[1, 0], A[1, 1] + B[1, 1], A[1, 2] + B[1, 2]))}") - self.failUnlessEqual(str(matrix([2, 3], "A") * matrix([3, 2], "B")), "unnamed_matrix{=((A[0, 0] * B[0, 0] + A[0, 1] * B[1, 0] + A[0, 2] * B[2, 0], A[0, 0] * B[0, 1] + A[0, 1] * B[1, 1] + A[0, 2] * B[2, 1]), (A[1, 0] * B[0, 0] + A[1, 1] * B[1, 0] + A[1, 2] * B[2, 0], A[1, 0] * B[0, 1] + A[1, 1] * B[1, 1] + A[1, 2] * B[2, 1]))}") + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, matrix([2, 3]), 1) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, matrix([2, 3]), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, matrix([2, 3]), scalar() + scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, matrix([2, 3]), vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, matrix([2, 3]), vector(3)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, matrix([2, 3]), matrix([2, 4])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, matrix([2, 3]), matrix([3, 3])) + self.failUnlessEqual(str(matrix([2, 3], "A") - matrix([2, 3], "B")), "unnamed_matrix{=((unnamed_scalar{=-1.0} * B[0, 0] + A[0, 0], unnamed_scalar{=-1.0} * B[0, 1] + A[0, 1], unnamed_scalar{=-1.0} * B[0, 2] + A[0, 2]), (unnamed_scalar{=-1.0} * B[1, 0] + A[1, 0], unnamed_scalar{=-1.0} * B[1, 1] + A[1, 1], unnamed_scalar{=-1.0} * B[1, 2] + A[1, 2]))}") + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, matrix([2, 3]), 1) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, matrix([2, 3]), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, matrix([2, 3]), scalar() + scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, matrix([2, 3]), vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, matrix([2, 3]), vector(3)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, matrix([2, 3]), matrix([2, 4])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, matrix([2, 3]), matrix([3, 3])) + self.failUnlessEqual(str(2 * matrix([2, 3], "A")), "unnamed_matrix{=((A[0, 0] * unnamed_scalar{=2.0}, A[0, 1] * unnamed_scalar{=2.0}, A[0, 2] * unnamed_scalar{=2.0}), (A[1, 0] * unnamed_scalar{=2.0}, A[1, 1] * unnamed_scalar{=2.0}, A[1, 2] * unnamed_scalar{=2.0}))}") + self.failUnlessEqual(str(matrix([2, 3], "A") * 2), "unnamed_matrix{=((A[0, 0] * unnamed_scalar{=2.0}, A[0, 1] * unnamed_scalar{=2.0}, A[0, 2] * unnamed_scalar{=2.0}), (A[1, 0] * unnamed_scalar{=2.0}, A[1, 1] * unnamed_scalar{=2.0}, A[1, 2] * unnamed_scalar{=2.0}))}") self.failUnlessEqual(str(matrix([2, 3], "A") * vector(3, "a")), "unnamed_vector{=(A[0, 0] * a[0] + A[0, 1] * a[1] + A[0, 2] * a[2], A[1, 0] * a[0] + A[1, 1] * a[1] + A[1, 2] * a[2])}") + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__mul__, vector(2, "a"), matrix([2, 3], "A")) + self.failUnlessEqual(str(matrix([2, 3], "A") * matrix([3, 2], "B")), "unnamed_matrix{=((A[0, 0] * B[0, 0] + A[0, 1] * B[1, 0] + A[0, 2] * B[2, 0], A[0, 0] * B[0, 1] + A[0, 1] * B[1, 1] + A[0, 2] * B[2, 1]), (A[1, 0] * B[0, 0] + A[1, 1] * B[1, 0] + A[1, 2] * B[2, 0], A[1, 0] * B[0, 1] + A[1, 1] * B[1, 1] + A[1, 2] * B[2, 1]))}") + self.failUnlessEqual(str(matrix([2, 3], "A") / 2.0), "unnamed_matrix{=((unnamed_scalar{=0.5} * A[0, 0], unnamed_scalar{=0.5} * A[0, 1], unnamed_scalar{=0.5} * A[0, 2]), (unnamed_scalar{=0.5} * A[1, 0], unnamed_scalar{=0.5} * A[1, 1], unnamed_scalar{=0.5} * A[1, 2]))}") + self.failUnlessEqual(str(matrix([2, 3], "A") / 2), "unnamed_matrix{=((unnamed_scalar{=0.0} * A[0, 0], unnamed_scalar{=0.0} * A[0, 1], unnamed_scalar{=0.0} * A[0, 2]), (unnamed_scalar{=0.0} * A[1, 0], unnamed_scalar{=0.0} * A[1, 1], unnamed_scalar{=0.0} * A[1, 2]))}") + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, scalar(), matrix([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, scalar() + scalar(), matrix([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, vector(1), matrix([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, matrix([2, 3]), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, matrix([2, 3]), scalar() + scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, matrix([2, 3]), vector(1)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, matrix([2, 3]), matrix([2, 3])) + + +class TrafoTestCase(unittest.TestCase): + + def testInit(self): + self.failUnlessEqual(str(trafo((2, 3))), "unnamed_trafo{=(matrix: unnamed_trafo_matrix{=((unnamed_trafo_matrix[0, 0], unnamed_trafo_matrix[0, 1], unnamed_trafo_matrix[0, 2]), (unnamed_trafo_matrix[1, 0], unnamed_trafo_matrix[1, 1], unnamed_trafo_matrix[1, 2]))}, vector: unnamed_trafo_vector{=(unnamed_trafo_vector[0], unnamed_trafo_vector[1])})}") + self.failUnlessEqual(str(trafo((2, 3), "A")), "A{=(matrix: A_matrix{=((A_matrix[0, 0], A_matrix[0, 1], A_matrix[0, 2]), (A_matrix[1, 0], A_matrix[1, 1], A_matrix[1, 2]))}, vector: A_vector{=(A_vector[0], A_vector[1])})}") + self.failUnlessEqual(str(trafo((matrix([2, 3], "B"), vector(2, "c")), "A")), "A{=(matrix: B{=((B[0, 0], B[0, 1], B[0, 2]), (B[1, 0], B[1, 1], B[1, 2]))}, vector: c{=(c[0], c[1])})}") + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), trafo, (matrix([2, 3]), vector(3))) + + def testAccess(self): + m = matrix([2, 3]) + v = vector(2) + t = trafo((m, v)) + self.failUnlessEqual(t.getmatrix(), m) + self.failUnlessEqual(t.getvector(), v) + + def testMath(self): + self.failUnlessEqual(str(-trafo([2, 3], "A")), str(trafo((-matrix([2, 3], "A_matrix"), -vector(2, "A_vector"))))) + self.failUnlessEqual(str(trafo([2, 3], "A") + trafo([2, 3], "B")), str(trafo((matrix([2, 3], "A_matrix") + matrix([2, 3], "B_matrix"), vector(2, "A_vector") + vector(2, "B_vector"))))) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, 1, trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, trafo([2, 3]), 1) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, scalar(), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, trafo([2, 3]), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, scalar() + scalar(), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, trafo([2, 3]), scalar() + scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, vector(2), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, trafo([2, 3]), vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, vector(3), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, trafo([2, 3]), vector(3)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, matrix([2, 3]), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, trafo([2, 3]), matrix([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, trafo([2, 3]), trafo([2, 4])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__add__, trafo([2, 3]), trafo([3, 3])) + self.failUnlessEqual(str(trafo([2, 3], "A") - trafo([2, 3], "B")), str(trafo((matrix([2, 3], "A_matrix") - matrix([2, 3], "B_matrix"), vector(2, "A_vector") - vector(2, "B_vector"))))) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, 1, trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, trafo([2, 3]), 1) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, scalar(), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, trafo([2, 3]), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, scalar() + scalar(), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, trafo([2, 3]), scalar() + scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, vector(2), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, trafo([2, 3]), vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, vector(3), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, trafo([2, 3]), vector(3)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, matrix([2, 3]), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, trafo([2, 3]), matrix([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, trafo([2, 3]), trafo([2, 4])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__sub__, trafo([2, 3]), trafo([3, 3])) + self.failUnlessEqual(str(trafo([2, 3], "A") * trafo([3, 4], "B")), str(trafo((matrix([2, 3], "A_matrix") * matrix([3, 4], "B_matrix"), vector(2, "A_vector") + matrix([2, 3], "A_matrix") * vector(3, "B_vector"))))) + self.failUnlessEqual(str(2 * trafo([2, 3], "A")), str(trafo((2 * matrix([2, 3], "A_matrix"), 2 * vector(2, "A_vector"))))) + self.failUnlessEqual(str(trafo([2, 3], "A") * 2), str(trafo((matrix([2, 3], "A_matrix") * 2, vector(2, "A_vector") * 2)))) + self.failUnlessEqual(str(scalar() * trafo([2, 3], "A")), str(trafo((scalar() * matrix([2, 3], "A_matrix"), scalar() * vector(2, "A_vector"))))) + self.failUnlessEqual(str(trafo([2, 3], "A") * scalar()), str(trafo((matrix([2, 3], "A_matrix") * scalar(), vector(2, "A_vector") * scalar())))) + self.failUnlessEqual(str((scalar() + scalar()) * trafo([2, 3], "A")), str(trafo(((scalar() + scalar()) * matrix([2, 3], "A_matrix"), (scalar() + scalar()) * vector(2, "A_vector"))))) + self.failUnlessEqual(str(trafo([2, 3], "A") * (scalar() + scalar())), str(trafo((matrix([2, 3], "A_matrix") * (scalar() + scalar()), vector(2, "A_vector") * (scalar() + scalar()))))) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__mul__, vector(2), trafo([2, 3])) + self.failUnlessEqual(str(trafo([2, 3], "A") * vector(3, "a")), str(matrix([2, 3], "A_matrix") * vector(3, "a") + vector(2, "A_vector"))) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__mul__, trafo([2, 3]), vector(2)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__mul__, matrix([3, 2]), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__mul__, trafo([2, 3]), matrix([3, 2])) + self.failUnlessEqual(str(trafo([2, 3], "A") / 2.0), str(trafo((matrix([2, 3], "A_matrix") / 2.0, vector(2, "A_vector") / 2.0)))) + self.failUnlessEqual(str(trafo([2, 3], "A") / 2), str(trafo((matrix([2, 3], "A_matrix") / 2, vector(2, "A_vector") / 2)))) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, scalar(), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, scalar() + scalar(), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, vector(1), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, matrix([2, 3]), trafo([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, trafo([2, 3]), scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, trafo([2, 3]), scalar() + scalar()) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, trafo([2, 3]), vector(1)) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, trafo([2, 3]), matrix([2, 3])) + self.failUnlessRaises((RuntimeError, AttributeError, TypeError), operator.__div__, trafo([2, 3]), trafo([2, 3])) + +class SolverTestCase(unittest.TestCase): + + def testScalars(self): + solver = Solver() + a = scalar() + solver.eq(2 + a, 3) + self.failUnlessAlmostEqual(float(a), 1) + self.failUnlessRaises(RuntimeError, solver.eq, 2 + a, 3) # the solver is broken after that + solver = Solver() + a = scalar() + b = scalar() + solver.eq(2*a, b) + solver.eq(2 + a + b, 5) + self.failUnlessAlmostEqual(float(a), 1) + self.failUnlessAlmostEqual(float(b), 2) + a = scalar() + b = scalar() + solver.eq(a, b) + self.failUnlessRaises(Exception, solver.eq, a, b) + + def testVector(self): + solver = Solver() + a = vector(2) + solver.eq(vector([1, 2]) + a, vector([3, 3])) + self.failUnlessAlmostEqual(float(a.x), 2) + self.failUnlessAlmostEqual(float(a.y), 1) + b = vector(2) + solver.eq(a*b) # => solver.eq(a*b, 0) + solver.eq(b.y, 2) + self.failUnlessAlmostEqual(float(b.x), -1) + + def testMatrix(self): + solver = Solver() + A = matrix([2, 2]) + solver.eq(A*vector([1, -1]), vector([2, 0])) + solver.eq(A*vector([1, 1]), vector([0, 2])) + self.failUnlessAlmostEqual(float(A[0, 0]), 1) + self.failUnlessAlmostEqual(float(A[0, 1]), -1) + self.failUnlessAlmostEqual(float(A[1, 0]), 1) + self.failUnlessAlmostEqual(float(A[1, 1]), 1) + B = matrix([2, 2]) + solver.eq(A*B, identitymatrix(2)) + self.failUnlessAlmostEqual(float(B[0, 0]), 0.5) + self.failUnlessAlmostEqual(float(B[0, 1]), 0.5) + self.failUnlessAlmostEqual(float(B[1, 0]), -0.5) + self.failUnlessAlmostEqual(float(B[1, 1]), 0.5) + self.failUnlessAlmostEqual(float((B * vector([2, 0]))[0]), 1) + self.failUnlessAlmostEqual(float((B * vector([2, 0]))[1]), -1) + self.failUnlessAlmostEqual(float((B * vector([0, 2]))[0]), 1) + self.failUnlessAlmostEqual(float((B * vector([0, 2]))[1]), 1) + + def testTrafo(self): + solver = Solver() + A = trafo([2, 2]) + solver.eq(A.getmatrix()[0, 0], A.getmatrix()[1, 1]) # restrict to rotation + scaling + translation + solver.eq(A.getmatrix()[0, 1], -A.getmatrix()[1, 0]) + solver.eq(A*vector([0, 1]), vector([-1, 2])) + solver.eq(A*vector([1, 0]), vector([1, 4])) + self.failUnlessEqual(float((A * vector([0, 0]))[0]), 1) + self.failUnlessEqual(float((A * vector([0, 0]))[1]), 2) + self.failUnlessEqual(float(A.getmatrix()[0, 0]), 0) + self.failUnlessEqual(float(A.getmatrix()[0, 1]), -2) + self.failUnlessEqual(float(A.getmatrix()[1, 0]), 2) + self.failUnlessEqual(float(A.getmatrix()[1, 1]), 0) + B = trafo([2, 2]) + solver.eq(A*B, identitytrafo(2)) + self.failUnlessEqual(float((B * vector([0, 0]))[0]), -1) + self.failUnlessEqual(float((B * vector([0, 0]))[1]), 0.5) + self.failUnlessEqual(float(B.getmatrix()[0, 0]), 0) + self.failUnlessEqual(float(B.getmatrix()[0, 1]), 0.5) + self.failUnlessEqual(float(B.getmatrix()[1, 0]), -0.5) + self.failUnlessEqual(float(B.getmatrix()[1, 1]), 0) if __name__ == "__main__": -- 2.11.4.GIT