def test_rectangle(self):
self.assertCountEqual(indices.rectangle(L=[4, 4], n=2),
[mi for mi in cartesian_product([range(4)] * 2)])
self.assertCountEqual(indices.rectangle(L=2, n=2), [
MultiIndex(),
MultiIndex((1, 0)),
MultiIndex((0, 1)),
MultiIndex((1, 1))
])
def get_samples(self,mi_acc=None):
if mi_acc is not None and not isinstance(mi_acc,MultiIndex):
mi_acc = MultiIndex(mi_acc)
if mi_acc not in self.spas:
raise ValueError('Only have samples with accuracy parameters {}'.format(list(self.spas.keys())))
if mi_acc is None:
if self.n_acc>0:
return {mi_acc:(spa.X,spa.Y) for spa in self.spas}
else:
return self.spas[MultiIndex()].X,self.spas[MultiIndex()].Y
def test_sparse_index_dict(self):
B = MultiIndexDict()
B[MultiIndex((1, 2))] = 1
B[MultiIndex((1, 2))] += 3
B[MultiIndex((2, 3))] = 5
self.assertEqual(B[MultiIndex((1, 2))], 4)
self.assertEqual([B[i] for i in B], [4, 5])
with self.assertRaises(KeyError):
B[MultiIndex((4, 120))]
self.assertEqual([a.full_tuple() for a in B], [(1, 2), (2, 3)])
def structure(mi):
mim = mi.mod(lambda n: n < Delta.n_acc)
if mim == MultiIndex():
return []
else:
ret = [
mi.restrict(lambda n: n < Delta.n_acc) +
mi2.shifted(Delta.n_acc) for mi2 in [
MultiIndex(perm)
for perm in multiset_permutations(
mi.mod(lambda n: n < Delta.n_acc).
full_tuple())
]
]
return ret
def plot_samples(self,mi_acc=None,ax=None,kwargs=None):
if mi_acc is None and self.n_acc>0:
raise ValueError('Must specify which delta to plot')
if not isinstance(mi_acc,MultiIndex):
mi_acc = MultiIndex(mi_acc)
if mi_acc not in self.spas:
raise ValueError('Only have samples with accuracy parameters {}'.format(list(self.spas.keys())))
return self.spas[mi_acc].plot_samples(ax=ax,kwargs=kwargs)
def test1(self):
f = lambda mi: 3 + 2.**(-mi[0]) * 2.**(-mi[1])
md = MixedDifferences(f)
s = 0
for j in range(4):
for i in range(4):
s += md(MultiIndex((i, j)))
self.assertAlmostEqual(s, 3, places=1)
decomp = Decomposition(func=md, n=3, is_md=True)
SA = SparseApproximation(decomp)
SA.expand_adaptive(N=100)
self.assertAlmostEqual(SA.get_approximation(), 3, places=2)
def __init__(self, decomposition):
self.WORK_EXPONENT_MAX = 10
self.WORK_EXPONENT_MIN = 0
self.CONTRIBUTION_EXPONENT_MAX = 0
self.CONTRIBUTION_EXPONENT_MIN = -10
self.decomposition = decomposition
# If decomposition is bundled, runtime_estimator only makes sense if runtime_function has all bundled dimensions. runtime_function may or not be bundled; if it is not it will be called for each index in bundled and the observed runtime will then be divided by the sum
# work_model function does not have to be bundled if decomposition is. if it is bundled, it does have to include bundled dims in its dims
# contribution function cannot be bundled
self.runtime_estimator = _Estimator(
self.decomposition.work_function.dims,
exponent_max=self.WORK_EXPONENT_MAX,
exponent_min=self.WORK_EXPONENT_MIN,
name='runtime')
self.runtimes = MultiIndexDict(
lambda dim: self.decomposition.bundled and self.decomposition.
bundled_dims(dim))
self.contribution_estimator = _Estimator(
self.decomposition.contribution_function.dims,
exponent_max=self.CONTRIBUTION_EXPONENT_MAX,
exponent_min=self.CONTRIBUTION_EXPONENT_MIN,
init_exponents=self.decomposition.kronecker_exponents,
name='contribution')
if self.decomposition.returns_work:
self.work_model_estimator = _Estimator(
self.decomposition.work_function.dims,
exponent_max=self.WORK_EXPONENT_MAX,
exponent_min=self.WORK_EXPONENT_MIN,
name='work_model')
self.work_models = MultiIndexDict(decomposition.bundled_dims)
self.mis = MISet(dims=decomposition.init_dims)
self.mis.structure_constraints = set([MultiIndex()])
self.mis.structure_constraints |= set(
MultiIndex(((i, 1), ), sparse=True)
for i in self.decomposition.init_dims)
self.object_slices = MultiIndexDict(decomposition.bundled_dims)
self.contributions = dict()
def get_approximation(self,mi_acc=None):
'''
Returns polynomial approximation
:return: Polynomial approximation of :math:`f\colon [a,b]^d\to\mathbb{R}`
:rtype: Function
'''
if mi_acc is not None:
if not isinstance(mi_acc,MultiIndex):
mi_acc = MultiIndex(mi_acc)
if mi_acc not in self.spas:
raise ValueError('Only have approximation of Deltas with accuracy parameters {}'.format(list(self.spas.keys())))
return self.spas[mi_acc].get_approximation()
else:
return sum([self.spas[mi_acc].get_approximation() for mi_acc in self.spas])
def __call__(self, mi):
mi = mi.mod(self.dims_ignore)
if mi in self.quantities:
return self.quantities[mi]
else:
if mi.is_kronecker():
dim = mi.active_dims()[0]
return self.quantities[MultiIndex()] * np.exp(
self.exponents[dim])
else:
estimate = 0
for dim, sign in itertools.product(self.active_dims, (-1, 1)):
neighbor = mi + sign * kronecker(dim)
if neighbor in self.quantities:
estimate = max(estimate, self.quantities[neighbor])
return estimate
def test_dimensionadaptivity(self):
ndim = 5
def func(i):
ii = [v for __, v in i.sparse_tuple()]
value = np.exp(-sum(ii))
return value + snooze(2**sum(ii))
decomp = Decomposition(func=func,
n=inf,
next_dims=lambda dim: [dim + 1]
if dim < ndim - 1 else [])
SA = SparseApproximation(decomp)
print_runtime(SA.expand_adaptive)(N=30)
#print(SA.get_indices())
self.assertGreaterEqual(
max(
max(mi.active_dims()) if mi != MultiIndex() else 0
for mi in SA.get_indices()), 1)
self.assertAlmostEqual(SA._get_contribution_exponent(0), 1, delta=0.1)
def _pols_from_mi(self, mi):
'''
Convert multi-index to corresponding polynomials
:param mi: Multi-index
:return: List of polynomials corresponding to mi
'''
if self.reparametrization is True:
if mi == MultiIndex():
return [mi]
else:
univariate_entries = []
for dimension in mi.active_dims():
init_range = 2 ** (mi[dimension])-1
end_range = 2 ** (mi[dimension]+1)-1
univariate_entries.append(range(init_range, end_range))
return cartesian_product(univariate_entries, mi.active_dims())
elif self.reparametrization is False:
return [mi]
else:
return self.reparametrization(mi)
def test_rectangles(self):
d = 5
L = 5
sparseindices = cartesian_product([range(L)] * d)
CR = combination_rule(sparseindices)
self.assertEqual([mi for mi in CR], [MultiIndex((L - 1, ) * d)])
def test_simplex(self):
self.assertCountEqual(
indices.simplex(L=1, n=2),
[MultiIndex(),
MultiIndex(
(1, 0)), MultiIndex((0, 1))])
def test_retract(self):
AA = MultiIndex([0, 0, 1, 0])
AAA = AA.retract(lambda dim: dim * 2)
self.assertEqual(AAA.full_tuple(), (0, 1))
def test1(self):
A = MultiIndex([1, 0, 0, 1, 2])
self.assertEqual(A[0], 1)
A[0] = 0
self.assertEqual(A[2], 0)
self.assertEqual(A[0], 0)
self.assertEqual(A[4], 2)
A[4] = 3
A[5] = 4
A[5] = 0
self.assertEqual(A.full_tuple(), (0, 0, 0, 1, 3))
A[4] = 2
B = MultiIndex([0, 0, 0, 1, 4])
self.assertFalse(A == B)
self.assertTrue(A.equal_mod(B, lambda dim: dim == 4))
self.assertTrue(A != B)
T = MultiIndex((0, 5, 0))
self.assertTrue(T == MultiIndex((0, 5, 0)))
self.assertFalse(T != MultiIndex((0, 5, 0)))
C = B - A
self.assertEqual(C.full_tuple(), (0, 0, 0, 0, 2))
D = MultiIndex(zip([0, 2, 3], [4, 2.4, 4]), sparse=True)
self.assertEqual(D.sparse_tuple(), ((0, 4), (2, 2.4), (3, 4)))
self.assertEqual(D.full_tuple(5), (4, 0, 2.4, 4, 0))
def test1(self):
A = DCSet()
A.add(MultiIndex([0]))
