6549750104

Committed 17 Oct 2023 03:56PM UTC coverage: 50.111% (-0.3%) from 50.364%

Build # 6549750104

Build Type

push

github

Committed by

web-flow

Commit Message

Deploy testing (#114)

* split up workflows to make checks easier

* bump verson for testing

* building workflow dependencies

* homogenizing some of the workflows

* bump version number, add missing doi

* another doi

* update cif to match zenodo.  typo in affiliations

* some mistakes in workflows

* working out inheritance

* try without forwarding

* trying to include token

* old api for tesst pypi

* typo

* disable other tests for now

* trying to get the right files

* try to find the artefact

* bumping version

* moveing dir

* some cleanup. separating and Upgrading test.pypi

* bump versions

* actions finally working, cleaning up, bump version

* bumping version for release

* update cif file

* bump version for pypi

* another version bump

Run Details

1583 of 3159 relevant lines covered (50.11%)

4.46 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

68.42

/UncertainSCI/transformations.py

import numpy as np
from scipy import sparse as sprs


class AffineTransform:
    def __init__(self, domain=None, image=None, A=None, b=None):
        """
        Initializes a general affine map of the form

          x ---> x*A.T + b,

        where x is a (row) vector, A is an invertible matrix, and b is a
        vector.

        If domain and image are specified, they are each 2 x d matrices
        specifying box constraints on a d-dimensional hypercube.
        """

        if domain is not None:
            if image is None:
                raise ValueError('If domain is specified, '
                                 'image must also be specified.')
            else:
                assert domain.shape == image.shape, \
                       "Domain, image matrices must be of same shape"

            self.diagonal = True
            d = domain.shape[1]
            self.A = sprs.eye(d)

            a = np.zeros(d)
            b = np.zeros(d)
            for q in range(d):
                a[q] = (image[1, q] - image[0, q]) / \
                       (domain[1, q] - domain[0, q])
                b[q] = image[0, q] - domain[0, q]*a[q]

            self.A = sprs.diags(a, 0)
            self.b = b

            self.Ainv = sprs.diags(1/a, 0)
            self.binv = self.Ainv.dot(-self.b)

        elif (A is not None) and (b is not None):
            # Assume A is a numpy array
            assert (A.ndim == 1) or (A.shape[0] == A.shape[1]), \
                   ValueError("Input matrix A must be square")
            assert b.ndim == 1, ValueError("Input b must be a vector")
            assert b.size == A.shape[0], \
                   ValueError("Input vector b must have same dimension as A")

            if A.ndim == 1:
                A = np.reshape(A, [1,1])

            self.A, self.b = A, b
            self.Ainv = np.linalg.inv(A)
            self.binv = self.Ainv.dot(-self.b)
        else:
            raise ValueError('Domain/image or A/b must be specified')

    def map(self, x):
        if len(x.shape) < 2:
            # either len(x) == dim or dim == 1
            if len(x) == self.b.size:
                return self.A.dot(x) + self.b
            elif self.b.size == 1:
                if isinstance(self.A, sprs.spmatrix):
                    return self.A.todense()[0, 0]*x + self.b
                else:
                    return self.A[0, 0]*x + self.b

        else:
            return self.A.dot(x.T).T + self.b

    def mapinv(self, x):
        if len(x.shape) < 2:
            # either len(x) == dim or dim == 1
            if len(x) == self.binv.size:
                return self.Ainv.dot(x) + self.binv
            elif self.b.size == 1:
                if isinstance(self.A, sprs.spmatrix):
                    return self.Ainv.todense()[0, 0]*x + self.binv
                else:
                    return self.Ainv[0, 0]*x + self.binv

        else:
            return self.Ainv.dot(x.T).T + self.binv

    def jacobian_determinant(self):
        """ Returns the Jacobian determinant of the map.

        Args:
            None
        Returns:
            jacdet: positive float, the absolute value of the map determinant
        """

        if isinstance(self.A, sprs.spmatrix):
            return np.abs(np.linalg.det(self.A.todense()))
        else:
            return np.abs(np.linalg.det(self.A))

    def compose(self, other):
        """ Returns composition of two AffineTransform's

        Args:
            other: An AffineTransform instance where the domain and range are
              the same dimension as for self.
       Returns:
            composition: AffineTransform instance, corresponding to the map
              self :math:`\\circ` other
        """

        A1 = np.asarray(self.A.todense())
        A2 = np.asarray(other.A.todense())

        assert A1.shape[0] == A2.shape[0]

        return AffineTransform(A=(A1 @ A2), b=(A1 @ other.b + self.b))

1	import numpy as np	9✔
2	from scipy import sparse as sprs	9✔
3
4
5	class AffineTransform:	9✔
6	def __init__(self, domain=None, image=None, A=None, b=None):	9✔
7	"""
8	Initializes a general affine map of the form
9
10	x ---> x*A.T + b,
11
12	where x is a (row) vector, A is an invertible matrix, and b is a
13	vector.
14
15	If domain and image are specified, they are each 2 x d matrices
16	specifying box constraints on a d-dimensional hypercube.
17	"""
18
19	if domain is not None:	9✔
20	if image is None:	9✔
21	raise ValueError('If domain is specified, '	×
22	'image must also be specified.')
23	else:
24	assert domain.shape == image.shape, \	9✔
25	"Domain, image matrices must be of same shape"
26
27	self.diagonal = True	9✔
28	d = domain.shape[1]	9✔
29	self.A = sprs.eye(d)	9✔
30
31	a = np.zeros(d)	9✔
32	b = np.zeros(d)	9✔
33	for q in range(d):	9✔
34	a[q] = (image[1, q] - image[0, q]) / \	9✔
35	(domain[1, q] - domain[0, q])
36	b[q] = image[0, q] - domain[0, q]*a[q]	9✔
37
38	self.A = sprs.diags(a, 0)	9✔
39	self.b = b	9✔
40
41	self.Ainv = sprs.diags(1/a, 0)	9✔
42	self.binv = self.Ainv.dot(-self.b)	9✔
43
44	elif (A is not None) and (b is not None):	9✔
45	# Assume A is a numpy array
46	assert (A.ndim == 1) or (A.shape[0] == A.shape[1]), \	9✔
47	ValueError("Input matrix A must be square")
48	assert b.ndim == 1, ValueError("Input b must be a vector")	9✔
49	assert b.size == A.shape[0], \	9✔
50	ValueError("Input vector b must have same dimension as A")
51
52	if A.ndim == 1:	9✔
53	A = np.reshape(A, [1,1])	×
54
55	self.A, self.b = A, b	9✔
56	self.Ainv = np.linalg.inv(A)	9✔
57	self.binv = self.Ainv.dot(-self.b)	9✔
58	else:
59	raise ValueError('Domain/image or A/b must be specified')	×
60
61	def map(self, x):	9✔
62	if len(x.shape) < 2:	9✔
63	# either len(x) == dim or dim == 1
64	if len(x) == self.b.size:	×
65	return self.A.dot(x) + self.b	×
66	elif self.b.size == 1:	×
67	if isinstance(self.A, sprs.spmatrix):	×
68	return self.A.todense()[0, 0]*x + self.b	×
69	else:
70	return self.A[0, 0]*x + self.b	×
71
72	else:
73	return self.A.dot(x.T).T + self.b	9✔
74
75	def mapinv(self, x):	9✔
76	if len(x.shape) < 2:	9✔
77	# either len(x) == dim or dim == 1
78	if len(x) == self.binv.size:	×
79	return self.Ainv.dot(x) + self.binv	×
80	elif self.b.size == 1:	×
81	if isinstance(self.A, sprs.spmatrix):	×
82	return self.Ainv.todense()[0, 0]*x + self.binv	×
83	else:
84	return self.Ainv[0, 0]*x + self.binv	×
85
86	else:
87	return self.Ainv.dot(x.T).T + self.binv	9✔
88
89	def jacobian_determinant(self):	9✔
90	""" Returns the Jacobian determinant of the map.
91
92	Args:
93	None
94	Returns:
95	jacdet: positive float, the absolute value of the map determinant
96	"""
97
98	if isinstance(self.A, sprs.spmatrix):	×
99	return np.abs(np.linalg.det(self.A.todense()))	×
100	else:
101	return np.abs(np.linalg.det(self.A))	×
102
103	def compose(self, other):	9✔
104	""" Returns composition of two AffineTransform's
105
106	Args:
107	other: An AffineTransform instance where the domain and range are
108	the same dimension as for self.
109	Returns:
110	composition: AffineTransform instance, corresponding to the map
111	self :math:`\\circ` other
112	"""
113
114	A1 = np.asarray(self.A.todense())	9✔
115	A2 = np.asarray(other.A.todense())	9✔
116
117	assert A1.shape[0] == A2.shape[0]	9✔
118
119	return AffineTransform(A=(A1 @ A2), b=(A1 @ other.b + self.b))	9✔

SCIInstitute / UncertainSCI / 6549750104

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous