def test_automatic_promotions(): class A: pass class B(A): pass a, b = A(), B() assert_allsame(promote(a, b), (a, b)) assert_allsame(promote(a, a), (a, a)) assert promote_type(A, B) is A assert promote_type(B, A) is A
def __mul_matrix(self, other): outtype = promote_type(type(self), type(other)) a, b, c, d, e, f, g, h, i = self.flat j, k, l, m, n, o, p, q, r = other.flat data = [ a * j + b * m + c * p, a * k + b * n + c * q, a * l + b * o + c * r, d * j + e * m + f * p, d * k + e * n + f * q, d * l + e * o + f * r, g * j + h * m + i * p, g * k + h * n + i * q, g * l + h * o + i * r, ] return outtype.from_flat(data, copy=False)
def sub_elementwise_factory(argtypes, restype): T, S = argtypes if issubclass(T, S): return S.__subsame__ if issubclass(S, T): return T.__subsame__ if T.__origin__ is not S.__origin__: return NotImplemented elif T.shape != S.shape: return NotImplemented def func(u, v): return u.convert(dtype) - v.convert(dtype) dtype = promote_type(T.dtype, S.dtype) return func
def add_elementwise_factory(argtypes, restype): T, S = argtypes if issubclass(T, S): return S.__addsame__ if issubclass(S, T): return T.__addsame__ if T.__origin__ is not S.__origin__: return NotImplemented if T.shape != S.shape: return NotImplemented def func(u, v): return u.convert(dtype) + v.convert(dtype) dtype = promote_type(T.dtype, S.dtype) return func
def __finalizetype__(cls): """ Assure that the resulting type has the correct shape, size, dim, dtype """ # Shape parameters if cls.__parameters__ is None or cls.shape is None: default_ns = default_smallvectors_type_ns(cls.__parameters__) for k, v in default_ns.items(): if getattr(cls, k, None) is None: setattr(cls, k, v) # Pick up flat object flat = mFlat if issubclass(cls, _Mutable) else Flat cls.__flat__ = flat # Floating parameter if cls.dtype is not None: cls._floating = promote_type(cls._float, cls.dtype) assert cls.dtype is not Any, cls
def inv(self): """ Return the inverse matrix. """ # Simple and naive matrix inversion using Gaussian elimination # Creates extended matrix N = self.nrows dtype = promote_type(float, self.dtype) matrix = self._mmat[N, N, dtype].from_flat(self.flat) matrix = matrix.append_col(self._identity(N)) # Make left hand side upper triangular for i in range(0, N): # Search for maximum value in the truncated column and put it # in pivoting position trunc_col = list(matrix.col(i))[i:] _, idx = max([(abs(c), i) for (i, c) in enumerate(trunc_col)]) matrix.iswap_rows(i, idx + i) # Find linear combinations that make all rows below the current one # become equal to zero in the current column Z = matrix[i, i] for k in range(i + 1, N): matrix.isum_row(k, matrix[i] * (-matrix[k, i] / Z)) # Make the left hand side diagonal Z = matrix[i, i] for k in range(0, i): matrix.isum_row(k, matrix[i] * (-matrix[k, i] / Z)) # Normalize by the diagonal for i in range(N): matrix.imul_row(i, 1 / matrix[i, i]) out = matrix.select_cols(range(N, 2 * N)) return self._mat[N, N, dtype].from_flat(out.flat)
def test_successfull_type_promotions_of_base_types(): assert promote_type(int, float) is float assert promote_type(bool, complex) is complex