test_field.py 11.3 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
Theo Steininger's avatar
Theo Steininger committed
13
#
14
# Copyright(C) 2013-2019 Max-Planck-Society
Theo Steininger's avatar
Theo Steininger committed
15
#
16
# NIFTy is being developed at the Max-Planck-Institut fuer Astrophysik.
17
18

import unittest
19
from itertools import product
Jait Dixit's avatar
Jait Dixit committed
20
from test.common import expand
21

22
23
24
import nifty5 as ift
import numpy as np
from numpy.testing import assert_allclose, assert_equal, assert_raises
25

Martin Reinecke's avatar
Martin Reinecke committed
26
SPACES = [ift.RGSpace((4,)), ift.RGSpace((5))]
Theo Steininger's avatar
Theo Steininger committed
27
SPACE_COMBINATIONS = [(), SPACES[0], SPACES[1], SPACES]
28
29
30


class Test_Interface(unittest.TestCase):
31
    @expand(product(SPACE_COMBINATIONS,
Martin Reinecke's avatar
Martin Reinecke committed
32
33
                    [['domain', ift.DomainTuple],
                     ['val', ift.dobj.data_object],
34
                     ['shape', tuple],
Martin Reinecke's avatar
Martin Reinecke committed
35
                     ['size', (np.int, np.int64)]]))
36
37
38
    def test_return_types(self, domain, attribute_desired_type):
        attribute = attribute_desired_type[0]
        desired_type = attribute_desired_type[1]
Martin Reinecke's avatar
Martin Reinecke committed
39
        f = ift.Field.full(domain, 1.)
Martin Reinecke's avatar
Martin Reinecke committed
40
        assert_equal(isinstance(getattr(f, attribute), desired_type), True)
41

Martin Reinecke's avatar
Martin Reinecke committed
42

Martin Reinecke's avatar
Martin Reinecke committed
43
44
45
46
47
48
49
50
def _spec1(k):
    return 42/(1.+k)**2


def _spec2(k):
    return 42/(1.+k)**3


51
class Test_Functionality(unittest.TestCase):
Martin Reinecke's avatar
Martin Reinecke committed
52
53
54
55
    @expand(product([ift.RGSpace((8,), harmonic=True),
                     ift.RGSpace((8, 8), harmonic=True, distances=0.123)],
                    [ift.RGSpace((8,), harmonic=True),
                     ift.LMSpace(12)]))
Martin Reinecke's avatar
more    
Martin Reinecke committed
56
    def test_power_synthesize_analyze(self, space1, space2):
Martin Reinecke's avatar
stage1    
Martin Reinecke committed
57
        np.random.seed(11)
58

Martin Reinecke's avatar
Martin Reinecke committed
59
        p1 = ift.PowerSpace(space1)
60
        fp1 = ift.PS_field(p1, _spec1)
Martin Reinecke's avatar
Martin Reinecke committed
61
        p2 = ift.PowerSpace(space2)
62
63
        fp2 = ift.PS_field(p2, _spec2)
        outer = np.outer(fp1.to_global_data(), fp2.to_global_data())
64
        fp = ift.Field.from_global_data((p1, p2), outer)
65

66
67
        op1 = ift.create_power_operator((space1, space2), _spec1, 0)
        op2 = ift.create_power_operator((space1, space2), _spec2, 1)
Martin Reinecke's avatar
Martin Reinecke committed
68
        opfull = op2(op1)
69

Martin Reinecke's avatar
Martin Reinecke committed
70
        samples = 500
71
72
        sc1 = ift.StatCalculator()
        sc2 = ift.StatCalculator()
Martin Reinecke's avatar
Martin Reinecke committed
73
        for ii in range(samples):
74
            sk = opfull.draw_sample()
75

Martin Reinecke's avatar
Martin Reinecke committed
76
77
            sp = ift.power_analyze(sk, spaces=(0, 1),
                                   keep_phase_information=False)
78
79
            sc1.add(sp.sum(spaces=1)/fp2.sum())
            sc2.add(sp.sum(spaces=0)/fp1.sum())
80

81
82
        assert_allclose(sc1.mean.local_data, fp1.local_data, rtol=0.2)
        assert_allclose(sc2.mean.local_data, fp2.local_data, rtol=0.2)
Martin Reinecke's avatar
Martin Reinecke committed
83

Martin Reinecke's avatar
Martin Reinecke committed
84
85
86
87
    @expand(product([ift.RGSpace((8,), harmonic=True),
                     ift.RGSpace((8, 8), harmonic=True, distances=0.123)],
                    [ift.RGSpace((8,), harmonic=True),
                     ift.LMSpace(12)]))
88
    def test_DiagonalOperator_power_analyze2(self, space1, space2):
Martin Reinecke's avatar
Martin Reinecke committed
89
90
        np.random.seed(11)

91
92
        fp1 = ift.PS_field(ift.PowerSpace(space1), _spec1)
        fp2 = ift.PS_field(ift.PowerSpace(space2), _spec2)
Martin Reinecke's avatar
Martin Reinecke committed
93

94
95
        S_1 = ift.create_power_operator((space1, space2), _spec1, 0)
        S_2 = ift.create_power_operator((space1, space2), _spec2, 1)
Martin Reinecke's avatar
Martin Reinecke committed
96
        S_full = S_2(S_1)
Martin Reinecke's avatar
Martin Reinecke committed
97
98

        samples = 500
99
100
        sc1 = ift.StatCalculator()
        sc2 = ift.StatCalculator()
Martin Reinecke's avatar
Martin Reinecke committed
101
102

        for ii in range(samples):
103
            sk = S_full.draw_sample()
Martin Reinecke's avatar
Martin Reinecke committed
104
105
            sp = ift.power_analyze(sk, spaces=(0, 1),
                                   keep_phase_information=False)
106
107
            sc1.add(sp.sum(spaces=1)/fp2.sum())
            sc2.add(sp.sum(spaces=0)/fp1.sum())
Martin Reinecke's avatar
Martin Reinecke committed
108

109
110
        assert_allclose(sc1.mean.local_data, fp1.local_data, rtol=0.2)
        assert_allclose(sc2.mean.local_data, fp2.local_data, rtol=0.2)
Martin Reinecke's avatar
Martin Reinecke committed
111

112
113
114
115
116
117
    @expand(product([ift.RGSpace((8,), harmonic=True), (),
                     ift.RGSpace((8, 8), harmonic=True, distances=0.123),
                     ift.RGSpace((2, 3, 7))]))
    def test_norm(self, space):
        f = ift.Field.from_random("normal", domain=space, dtype=np.complex128)
        gd = f.to_global_data().reshape(-1)
Martin Reinecke's avatar
Martin Reinecke committed
118
119
120
121
122
123
        assert_allclose(f.norm(), np.linalg.norm(gd))
        assert_allclose(f.norm(1), np.linalg.norm(gd, ord=1))
        assert_allclose(f.norm(2), np.linalg.norm(gd, ord=2))
        assert_allclose(f.norm(3), np.linalg.norm(gd, ord=3))
        assert_allclose(f.norm(np.inf), np.linalg.norm(gd, ord=np.inf))

Martin Reinecke's avatar
Martin Reinecke committed
124
    def test_vdot(self):
Martin Reinecke's avatar
Martin Reinecke committed
125
126
127
        s = ift.RGSpace((10,))
        f1 = ift.Field.from_random("normal", domain=s, dtype=np.complex128)
        f2 = ift.Field.from_random("normal", domain=s, dtype=np.complex128)
Martin Reinecke's avatar
Martin Reinecke committed
128
        assert_allclose(f1.vdot(f2), f1.vdot(f2, spaces=0))
129
        assert_allclose(f1.vdot(f2), np.conj(f2.vdot(f1)))
130
131
132
133

    def test_vdot2(self):
        x1 = ift.RGSpace((200,))
        x2 = ift.RGSpace((150,))
Martin Reinecke's avatar
Martin Reinecke committed
134
        m = ift.Field.full((x1, x2), .5)
135
        res = m.vdot(m, spaces=1)
Martin Reinecke's avatar
Martin Reinecke committed
136
        assert_allclose(res.local_data, 37.5)
Martin Reinecke's avatar
Martin Reinecke committed
137

138
139
140
141
142
143
    def test_outer(self):
        x1 = ift.RGSpace((9,))
        x2 = ift.RGSpace((3,))
        m1 = ift.Field.full(x1, .5)
        m2 = ift.Field.full(x2, 3.)
        res = m1.outer(m2)
Martin Reinecke's avatar
fixes    
Martin Reinecke committed
144
        assert_allclose(res.to_global_data(), np.full((9, 3,), 1.5))
145

Sebastian Hutschenreuter's avatar
Sebastian Hutschenreuter committed
146
147
148
    def test_sum(self):
        x1 = ift.RGSpace((9,), distances=2.)
        x2 = ift.RGSpace((2, 12,), distances=(0.3,))
Martin Reinecke's avatar
MPI fix    
Martin Reinecke committed
149
        m1 = ift.Field.from_global_data(ift.makeDomain(x1), np.arange(9))
Sebastian Hutschenreuter's avatar
Sebastian Hutschenreuter committed
150
151
152
153
154
155
156
157
158
        m2 = ift.Field.full(ift.makeDomain((x1, x2)), 0.45)
        res1 = m1.sum()
        res2 = m2.sum(spaces=1)
        assert_allclose(res1, 36)
        assert_allclose(res2.to_global_data(), np.full(9, 2*12*0.45))

    def test_integrate(self):
        x1 = ift.RGSpace((9,), distances=2.)
        x2 = ift.RGSpace((2, 12,), distances=(0.3,))
Martin Reinecke's avatar
MPI fix    
Martin Reinecke committed
159
        m1 = ift.Field.from_global_data(ift.makeDomain(x1), np.arange(9))
Sebastian Hutschenreuter's avatar
Sebastian Hutschenreuter committed
160
161
162
163
164
165
        m2 = ift.Field.full(ift.makeDomain((x1, x2)), 0.45)
        res1 = m1.integrate()
        res2 = m2.integrate(spaces=1)
        assert_allclose(res1, 36*2)
        assert_allclose(res2.to_global_data(), np.full(9, 2*12*0.45*0.3**2))

166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
    def test_dataconv(self):
        s1 = ift.RGSpace((10,))
        ld = np.arange(ift.dobj.local_shape(s1.shape)[0])
        gd = np.arange(s1.shape[0])
        assert_equal(ld, ift.from_local_data(s1, ld).local_data)
        assert_equal(gd, ift.from_global_data(s1, gd).to_global_data())

    def test_cast_domain(self):
        s1 = ift.RGSpace((10,))
        s2 = ift.RGSpace((10,), distances=20.)
        d = np.arange(s1.shape[0])
        d2 = ift.from_global_data(s1, d).cast_domain(s2).to_global_data()
        assert_equal(d, d2)

    def test_empty_domain(self):
181
        f = ift.Field.full((), 5)
182
        assert_equal(f.local_data, 5)
183
        f = ift.Field.full(None, 5)
184
        assert_equal(f.local_data, 5)
185
186
187

    def test_trivialities(self):
        s1 = ift.RGSpace((10,))
188
        f1 = ift.Field.full(s1, 27)
189
        assert_equal(f1.local_data, f1.real.local_data)
190
        f1 = ift.Field.full(s1, 27.+3j)
191
192
193
194
195
        assert_equal(f1.real.local_data, 27.)
        assert_equal(f1.imag.local_data, 3.)
        assert_equal(f1.local_data, +f1.local_data)
        assert_equal(f1.sum(), f1.sum(0))
        f1 = ift.from_global_data(s1, np.arange(10))
196
197
#        assert_equal(f1.min(), 0)
#        assert_equal(f1.max(), 9)
198
199
200
201
        assert_equal(f1.prod(), 0)

    def test_weight(self):
        s1 = ift.RGSpace((10,))
202
        f = ift.Field.full(s1, 10.)
203
        f2 = f.weight(1)
204
205
206
207
208
209
210
211
        assert_equal(f.weight(1).local_data, f2.local_data)
        assert_equal(f.total_volume(), 1)
        assert_equal(f.total_volume(0), 1)
        assert_equal(f.total_volume((0,)), 1)
        assert_equal(f.scalar_weight(), 0.1)
        assert_equal(f.scalar_weight(0), 0.1)
        assert_equal(f.scalar_weight((0,)), 0.1)
        s1 = ift.GLSpace(10)
212
        f = ift.Field.full(s1, 10.)
213
214
215
216
217
218
219
        assert_equal(f.scalar_weight(), None)
        assert_equal(f.scalar_weight(0), None)
        assert_equal(f.scalar_weight((0,)), None)

    @expand(product([ift.RGSpace(10), ift.GLSpace(10)],
                    [np.float64, np.complex128]))
    def test_reduction(self, dom, dt):
220
        s1 = ift.Field.full(dom, dt(1.))
221
222
223
224
225
226
227
228
229
230
        assert_allclose(s1.mean(), 1.)
        assert_allclose(s1.mean(0), 1.)
        assert_allclose(s1.var(), 0., atol=1e-14)
        assert_allclose(s1.var(0), 0., atol=1e-14)
        assert_allclose(s1.std(), 0., atol=1e-14)
        assert_allclose(s1.std(0), 0., atol=1e-14)

    def test_err(self):
        s1 = ift.RGSpace((10,))
        s2 = ift.RGSpace((11,))
231
        f1 = ift.Field.full(s1, 27)
232
        with assert_raises(ValueError):
233
            f2 = ift.Field(ift.DomainTuple.make(s2), f1.val)
234
        with assert_raises(TypeError):
235
            f2 = ift.Field.full(s2, "xyz")
236
237
238
239
240
241
242
        with assert_raises(TypeError):
            if f1:
                pass
        with assert_raises(TypeError):
            f1.full((2, 4, 6))
        with assert_raises(TypeError):
            f2 = ift.Field(None, None)
243
        with assert_raises(TypeError):
244
245
246
247
248
249
            f2 = ift.Field(s1, None)
        with assert_raises(ValueError):
            f1.imag
        with assert_raises(TypeError):
            f1.vdot(42)
        with assert_raises(ValueError):
250
            f1.vdot(ift.Field.full(s2, 1.))
251
252
253
        with assert_raises(TypeError):
            ift.full(s1, [2, 3])

Martin Reinecke's avatar
Martin Reinecke committed
254
255
    def test_stdfunc(self):
        s = ift.RGSpace((200,))
256
        f = ift.Field.full(s, 27)
Martin Reinecke's avatar
Martin Reinecke committed
257
258
259
        assert_equal(f.local_data, 27)
        assert_equal(f.shape, (200,))
        assert_equal(f.dtype, np.int)
Martin Reinecke's avatar
step 1    
Martin Reinecke committed
260
        fx = ift.full(f.domain, 0)
Martin Reinecke's avatar
Martin Reinecke committed
261
262
263
        assert_equal(f.dtype, fx.dtype)
        assert_equal(f.shape, fx.shape)
        assert_equal(fx.local_data, 0)
Martin Reinecke's avatar
step 1    
Martin Reinecke committed
264
        fx = ift.full(f.domain, 1)
Martin Reinecke's avatar
Martin Reinecke committed
265
266
267
        assert_equal(f.dtype, fx.dtype)
        assert_equal(f.shape, fx.shape)
        assert_equal(fx.local_data, 1)
Martin Reinecke's avatar
step 1    
Martin Reinecke committed
268
        fx = ift.full(f.domain, 67.)
Martin Reinecke's avatar
Martin Reinecke committed
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
        assert_equal(f.shape, fx.shape)
        assert_equal(fx.local_data, 67.)
        f = ift.Field.from_random("normal", s)
        f2 = ift.Field.from_random("normal", s)
        assert_equal((f > f2).local_data, f.local_data > f2.local_data)
        assert_equal((f >= f2).local_data, f.local_data >= f2.local_data)
        assert_equal((f < f2).local_data, f.local_data < f2.local_data)
        assert_equal((f <= f2).local_data, f.local_data <= f2.local_data)
        assert_equal((f != f2).local_data, f.local_data != f2.local_data)
        assert_equal((f == f2).local_data, f.local_data == f2.local_data)
        assert_equal((f+f2).local_data, f.local_data+f2.local_data)
        assert_equal((f-f2).local_data, f.local_data-f2.local_data)
        assert_equal((f*f2).local_data, f.local_data*f2.local_data)
        assert_equal((f/f2).local_data, f.local_data/f2.local_data)
        assert_equal((-f).local_data, -(f.local_data))
        assert_equal(abs(f).local_data, abs(f.local_data))
Martin Reinecke's avatar
Martin Reinecke committed
285
286
287
288
289
290
291
292
293

    def test_emptydomain(self):
        f = ift.Field.full((), 3.)
        assert_equal(f.sum(), 3.)
        assert_equal(f.prod(), 3.)
        assert_equal(f.local_data, 3.)
        assert_equal(f.local_data.shape, ())
        assert_equal(f.local_data.size, 1)
        assert_equal(f.vdot(f), 9.)