test_nifty_spaces.py 59.4 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
# -*- coding: utf-8 -*-

from numpy.testing import assert_equal,\
    assert_almost_equal,\
    assert_raises

from nose_parameterized import parameterized
import unittest
import itertools
import numpy as np

12
from nifty.field import Field
csongor's avatar
csongor committed
13
14

from d2o import distributed_data_object
15
16

from nifty.nifty_paradict import space_paradict
csongor's avatar
csongor committed
17
18
19
from nifty.nifty_core import POINT_DISTRIBUTION_STRATEGIES,\
    space,\
    point_space
20

21
from nifty.rg.nifty_rg import RG_DISTRIBUTION_STRATEGIES,\
csongor's avatar
csongor committed
22
                              gc as RG_GC,\
csongor's avatar
csongor committed
23
                              RgSpace
Ultima's avatar
Ultima committed
24
from nifty.lm.nifty_lm import LM_DISTRIBUTION_STRATEGIES,\
Ultima's avatar
Ultima committed
25
26
                              GL_DISTRIBUTION_STRATEGIES,\
                              HP_DISTRIBUTION_STRATEGIES
Ultima's avatar
Ultima committed
27
from nifty.nifty_power_indices import power_indices
28
from nifty.nifty_utilities import _hermitianize_inverter as \
Ultima's avatar
Ultima committed
29
                                                        hermitianize_inverter
30

31
32
from nifty.operators.nifty_operators import power_operator

Ultima's avatar
Ultima committed
33
34
available = []
try:
csongor's avatar
csongor committed
35
    from nifty import LmSpace
Ultima's avatar
Ultima committed
36
37
38
39
40
except ImportError:
    pass
else:
    available += ['lm_space']
try:
csongor's avatar
csongor committed
41
    from nifty import GlSpace
Ultima's avatar
Ultima committed
42
43
44
45
46
except ImportError:
    pass
else:
    available += ['gl_space']
try:
csongor's avatar
csongor committed
47
    from nifty import HpSpace
Ultima's avatar
Ultima committed
48
49
50
51
52
53
except ImportError:
    pass
else:
    available += ['hp_space']


54

Ultima's avatar
Ultima committed
55
###############################################################################
56

57
58
59
60
61
62
63
64
65
def custom_name_func(testcase_func, param_num, param):
    return "%s_%s" % (
        testcase_func.__name__,
        parameterized.to_safe_name("_".join(str(x) for x in param.args)),
    )

###############################################################################
###############################################################################

Ultima's avatar
Ultima committed
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
all_point_datatypes = [np.dtype('bool'),
                       np.dtype('int16'),
                       np.dtype('int32'),
                       np.dtype('int64'),
                       np.dtype('float32'),
                       np.dtype('float64'),
                       np.dtype('complex64'),
                       np.dtype('complex128')]

all_lm_datatypes = [np.dtype('complex64'),
                    np.dtype('complex128')]

all_gl_datatypes = [np.dtype('float64'),
                    np.dtype('float128')]

all_hp_datatypes = [np.dtype('float64')]
82
83
84

###############################################################################

Ultima's avatar
Ultima committed
85
DATAMODELS = {}
86
87
88
89
90
DATAMODELS['point_space'] = POINT_DISTRIBUTION_STRATEGIES
DATAMODELS['rg_space'] = RG_DISTRIBUTION_STRATEGIES
DATAMODELS['lm_space'] = LM_DISTRIBUTION_STRATEGIES
DATAMODELS['gl_space'] = GL_DISTRIBUTION_STRATEGIES
DATAMODELS['hp_space'] = HP_DISTRIBUTION_STRATEGIES
91
92
93

###############################################################################

94
95
96
97
98
99
100
fft_modules = []
for name in ['gfft', 'gfft_dummy', 'pyfftw']:
    if RG_GC.validQ('fft_module', name):
        fft_modules += [name]

###############################################################################

Ultima's avatar
Ultima committed
101
102
103
104
105
106
107
108
all_spaces = ['space', 'point_space', 'rg_space']
if 'lm_space' in available:
    all_spaces += ['lm_space']
if 'gl_space' in available:
    all_spaces += ['gl_space']
if 'hp_space' in available:
    all_spaces += ['hp_space']

109

Ultima's avatar
Ultima committed
110
111
112
113
114
115
116
point_like_spaces = ['point_space', 'rg_space']
if 'lm_space' in available:
    point_like_spaces += ['lm_space']
if 'gl_space' in available:
    point_like_spaces += ['gl_space']
if 'hp_space' in available:
    point_like_spaces += ['hp_space']
117

Ultima's avatar
Ultima committed
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
###############################################################################

np_spaces = point_like_spaces
d2o_spaces = []
if POINT_DISTRIBUTION_STRATEGIES != []:
    d2o_spaces += ['point_space']
if RG_DISTRIBUTION_STRATEGIES != []:
    d2o_spaces += ['rg_space']
if LM_DISTRIBUTION_STRATEGIES != []:
    d2o_spaces += ['lm_space']
if GL_DISTRIBUTION_STRATEGIES != []:
    d2o_spaces += ['gl_space']
if HP_DISTRIBUTION_STRATEGIES != []:
    d2o_spaces += ['hp_space']


unary_operations = ['pos', 'neg', 'abs', 'real', 'imag', 'nanmin', 'amin',
                    'nanmax', 'amax', 'median', 'mean', 'std', 'var', 'argmin',
csongor's avatar
csongor committed
136
137
138
                    'argmin_nonflat', 'argmax', 'argmax_nonflat', 'conjugate',
                    'sum', 'prod', 'unique', 'copy', 'copy_empty', 'isnan',
                    'isinf', 'isfinite', 'nan_to_num', 'all', 'any', 'None']
Ultima's avatar
Ultima committed
139
140
141
142

binary_operations = ['add', 'radd', 'iadd', 'sub', 'rsub', 'isub', 'mul',
                     'rmul', 'imul', 'div', 'rdiv', 'idiv', 'pow', 'rpow',
                     'ipow', 'ne', 'lt', 'le', 'eq', 'ge', 'gt', 'None']
143
144
145

###############################################################################

146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
fft_test_data = np.array(
    [[0.38405405 + 0.32460996j, 0.02718878 + 0.08326207j,
      0.78792080 + 0.81192595j, 0.17535687 + 0.68054781j,
      0.93044845 + 0.71942995j, 0.21179999 + 0.00637665j],
     [0.10905553 + 0.3027462j, 0.37361237 + 0.68434316j,
      0.94070232 + 0.34129582j, 0.04658034 + 0.4575192j,
      0.45057929 + 0.64297612j, 0.01007361 + 0.24953504j],
     [0.39579662 + 0.70881906j, 0.01614435 + 0.82603832j,
      0.84036344 + 0.50321592j, 0.87699553 + 0.40337862j,
      0.11816016 + 0.43332373j, 0.76627757 + 0.66327959j],
     [0.77272335 + 0.18277367j, 0.93341953 + 0.58105518j,
      0.27227913 + 0.17458168j, 0.70204032 + 0.81397425j,
      0.12422993 + 0.19215286j, 0.30897158 + 0.47364969j],
     [0.24702012 + 0.54534373j, 0.55206013 + 0.98406613j,
      0.57408167 + 0.55685406j, 0.87991341 + 0.52534323j,
      0.93912604 + 0.97186519j, 0.77778942 + 0.45812051j],
     [0.79367868 + 0.48149411j, 0.42484378 + 0.74870011j,
      0.79611264 + 0.50926774j, 0.35372794 + 0.10468412j,
      0.46140736 + 0.09449825j, 0.82044644 + 0.95992843j]])

###############################################################################


169
170
171
def generate_space(name):
    space_dict = {'space': space(),
                  'point_space': point_space(10),
csongor's avatar
csongor committed
172
                  'rg_space': RgSpace((8, 8)),
173
                  }
Ultima's avatar
Ultima committed
174
    if 'lm_space' in available:
csongor's avatar
csongor committed
175
        space_dict['lm_space'] = LmSpace(mmax=11, lmax=11)
Ultima's avatar
Ultima committed
176
    if 'hp_space' in available:
csongor's avatar
csongor committed
177
        space_dict['hp_space'] = HpSpace(8)
Ultima's avatar
Ultima committed
178
    if 'gl_space' in available:
csongor's avatar
csongor committed
179
        space_dict['gl_space'] = GlSpace(nlat=10, nlon=19)
Ultima's avatar
Ultima committed
180

181
182
183
    return space_dict[name]


csongor's avatar
csongor committed
184
def generate_space_with_size(name, num):
185
    space_dict = {'space': space(),
csongor's avatar
csongor committed
186
                  'point_space': point_space(num),
csongor's avatar
csongor committed
187
                  'rg_space': RgSpace((num, num)),
188
189
                  }
    if 'lm_space' in available:
csongor's avatar
csongor committed
190
        space_dict['lm_space'] = LmSpace(mmax=num, lmax=num)
191
    if 'hp_space' in available:
csongor's avatar
csongor committed
192
        space_dict['hp_space'] = HpSpace(num)
193
    if 'gl_space' in available:
csongor's avatar
csongor committed
194
        space_dict['gl_space'] = GlSpace(nlat=num, nlon=num)
195
196
197

    return space_dict[name]

Ultima's avatar
Ultima committed
198
def generate_data(space):
199
    a = np.arange(space.dim).reshape(space.shape)
Ultima's avatar
Ultima committed
200
201
202
203
    data = space.cast(a)
    return data


204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
def check_equality(space, data1, data2):
    return space.unary_operation(space.binary_operation(data1, data2, 'eq'),
                                 'all')


def check_almost_equality(space, data1, data2, integers=7):
    return space.unary_operation(
        space.binary_operation(
            space.unary_operation(
                space.binary_operation(data1, data2, 'sub'),
                'abs'),
            10.**(-1. * integers), 'le'),
        'all')


def flip(space, data):
    return space.unary_operation(hermitianize_inverter(data), 'conjugate')

Ultima's avatar
Ultima committed
222

223
224
225
226
###############################################################################
###############################################################################

class Test_Common_Space_Features(unittest.TestCase):
227

228
229
230
231
232
233
234
235
236
237
    @parameterized.expand(all_spaces,
                          testcase_func_name=custom_name_func)
    def test_successfull_init_and_attributes(self, name):
        s = generate_space(name)
        assert(isinstance(s.paradict, space_paradict))

    @parameterized.expand(all_spaces,
                          testcase_func_name=custom_name_func)
    def test_successfull_init_and_methods(self, name):
        s = generate_space(name)
Ultima's avatar
Ultima committed
238
        assert(callable(s.__hash__))
239
240
241
242
243
244
245
246
247
        assert(callable(s.__eq__))
        assert(callable(s.__ne__))
        assert(callable(s.__len__))
        assert(callable(s.copy))
        assert(callable(s.getitem))
        assert(callable(s.setitem))
        assert(callable(s.apply_scalar_function))
        assert(callable(s.unary_operation))
        assert(callable(s.binary_operation))
248
249
250
        #assert(callable(s.get_shape))
        #assert(callable(s.get_dim))
        #assert(callable(s.dof))
251
252
253
254
255
256
257
        assert(callable(s.cast))
        assert(callable(s.enforce_power))
        assert(callable(s.check_codomain))
        assert(callable(s.get_codomain))
        assert(callable(s.get_random_values))
        assert(callable(s.calc_weight))
        assert(callable(s.get_weight))
Ultima's avatar
Ultima committed
258
        assert(callable(s.calc_norm))
259
260
261
262
263
264
265
266
267
268
        assert(callable(s.calc_dot))
        assert(callable(s.calc_transform))
        assert(callable(s.calc_smooth))
        assert(callable(s.calc_power))
        assert(callable(s.calc_real_Q))
        assert(callable(s.calc_bincount))
        assert(callable(s.get_plot))
        assert(callable(s.__repr__))
        assert(callable(s.__str__))

Ultima's avatar
Ultima committed
269
270
271
        assert(s.check_codomain(None) == False)
        assert(isinstance(repr(s), str))

Ultima's avatar
Ultima committed
272
273
274
275
276
277
278
    @parameterized.expand(all_spaces,
                          testcase_func_name=custom_name_func)
    def test_successfull_hashing(self, name):
        s1 = generate_space(name)
        s2 = generate_space(name)
        assert(s1.__hash__() == s2.__hash__())

279
280
281
282

###############################################################################
###############################################################################

Ultima's avatar
Ultima committed
283
class Test_Common_Point_Like_Space_Interface(unittest.TestCase):
284
285
286
287
288
289
290
291
292
293

    @parameterized.expand(point_like_spaces,
                          testcase_func_name=custom_name_func)
    def test_successfull_init_and_attributes(self, name):
        s = generate_space(name)

        assert(isinstance(s.paradict, space_paradict))
        assert(isinstance(s.paradict, space_paradict))
        assert(isinstance(s.dtype, np.dtype))
        assert(isinstance(s.discrete, bool))
Ultima's avatar
Ultima committed
294
#        assert(isinstance(s.harmonic, bool))
295
        assert(isinstance(s.distances, tuple))
Ultima's avatar
Ultima committed
296
297
298
        if hasattr(s, 'harmonic'):
            if s.harmonic:
                assert(isinstance(s.power_indices, power_indices))
299
300
301

    @parameterized.expand(point_like_spaces,
                          testcase_func_name=custom_name_func)
Ultima's avatar
Ultima committed
302
    def test_getters(self, name):
303
        s = generate_space(name)
304
305
        assert(isinstance(s.shape, tuple))
        assert(isinstance(s.dim, np.int))
306

307
308
309
        assert(isinstance(s.dof, np.int))
        assert(isinstance(s.dof_split, tuple))
        assert_equal(s.dof, np.prod(s.dof_split))
310

Ultima's avatar
Ultima committed
311
        assert(isinstance(s.get_vol(), np.float))
312
        assert(isinstance(s.dof_split, tuple))
Ultima's avatar
Ultima committed
313

314
315
316
        assert(isinstance(s.meta_volume, np.float))
        print(s.meta_volume_split, type(s.cast(1)))
        assert(isinstance(s.meta_volume_split, type(s.cast(1))))
317
        assert_almost_equal(
318
            s.meta_volume, s.meta_volume_split.sum(), 2)
319

320
321
322
323
324
325
326
    @parameterized.expand(point_like_spaces,
                          testcase_func_name=custom_name_func)
    def test_copy(self, name):
        s = generate_space(name)
        t = s.copy()
        assert(s == t)
        assert(id(s) != id(t))
Ultima's avatar
Ultima committed
327

328
329
330
331

###############################################################################
###############################################################################

Ultima's avatar
Ultima committed
332
class Test_Point_Space(unittest.TestCase):
333
334
335

    @parameterized.expand(
        itertools.product([0, 1, 10],
csongor's avatar
csongor committed
336
                          all_point_datatypes),
337
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
338
339
    def test_successfull_init(self, num, dtype):
        p = point_space(num, dtype)
340
341
342
343
344
345
        assert_equal(p.paradict['num'], num)
        assert_equal(p.dtype, dtype)

        assert_equal(p.discrete, True)
        assert_equal(p.distances, (np.float(1.),))

Ultima's avatar
Ultima committed
346
347
###############################################################################

348
349
350
351
352
353
354
355
356
    def test_para(self):
        num = 10
        p = point_space(num)
        assert_equal(p.para[0], num)

        new_num = 15
        p.para = np.array([new_num])
        assert_equal(p.para[0], new_num)

Ultima's avatar
Ultima committed
357
358
###############################################################################

359
360
361
362
363
    def test_init_fail(self):
        assert_raises(ValueError, lambda: point_space(-5))
        assert_raises(ValueError, lambda: point_space((10, 10)))
        assert_raises(ValueError, lambda: point_space(10, np.uint))

Ultima's avatar
Ultima committed
364
365
366
###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
367
        itertools.product([0, 1, 10]),
Ultima's avatar
Ultima committed
368
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
369
370
    def test_apply_scalar_function(self, num):
        s = point_space(num)
Ultima's avatar
Ultima committed
371
372
        d = generate_data(s)
        t = s.apply_scalar_function(d, lambda x: x**2)
373
        assert(check_equality(s, d**2, t))
Ultima's avatar
Ultima committed
374
375
376
        assert(id(d) != id(t))

        t = s.apply_scalar_function(d, lambda x: x**2, inplace=True)
377
        assert(check_equality(s, d, t))
Ultima's avatar
Ultima committed
378
379
380
381
382
383
        assert(id(d) == id(t))

###############################################################################

    @parameterized.expand(
        itertools.product([1, 10],
csongor's avatar
csongor committed
384
                          unary_operations),
Ultima's avatar
Ultima committed
385
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
386
387
    def test_unary_operations(self, num, op):
        s = point_space(num)
Ultima's avatar
Ultima committed
388
389
390
391
392
393
        d = s.cast(np.arange(num))
        s.unary_operation(d, op)
        # TODO: Implement value verification

    @parameterized.expand(
        itertools.product([1, 10],
csongor's avatar
csongor committed
394
                          binary_operations),
Ultima's avatar
Ultima committed
395
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
396
397
    def test_binary_operations(self, num, op):
        s = point_space(num)
Ultima's avatar
Ultima committed
398
399
400
401
402
403
404
405
        d = s.cast(np.arange(num))
        d2 = d[::-1]
        s.binary_operation(d, d2, op)
        # TODO: Implement value verification

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
406
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
407
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
408
    def test_get_shape_dim(self, dtype):
Ultima's avatar
Ultima committed
409
        num = 10
csongor's avatar
csongor committed
410
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
411

412
413
        assert_equal(s.shape, (num,))
        assert_equal(s.dim, num)
Ultima's avatar
Ultima committed
414
415
416
417

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
418
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
419
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
420
    def test_get_shape_dof(self, dtype):
Ultima's avatar
Ultima committed
421
        num = 10
csongor's avatar
csongor committed
422
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
423
424

        if issubclass(dtype.type, np.complexfloating):
425
426
            assert_equal(s.dof, 2 * num)
            assert_equal(s.dof_split, (2 * num,))
Ultima's avatar
Ultima committed
427
        else:
428
429
            assert_equal(s.dof, num)
            assert_equal(s.dof_split, (num,))
Ultima's avatar
Ultima committed
430
431
432
433

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
434
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
435
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
436
    def test_get_shape_vol(self, dtype):
Ultima's avatar
Ultima committed
437
        num = 10
csongor's avatar
csongor committed
438
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
439
440
441
442
443
444
445

        assert_equal(s.get_vol(), 1.)
        assert_equal(s.get_vol(split=True), (1.,))

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
446
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
447
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
448
    def test_get_shape_metavolume(self, dtype):
Ultima's avatar
Ultima committed
449
        num = 10
csongor's avatar
csongor committed
450
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
451

452
453
        assert_equal(s.meta_volume, 10.)
        assert(check_equality(s, s.meta_volume_split, s.cast(1)))
Ultima's avatar
Ultima committed
454
455
456
457

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
458
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
459
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
460
    def test_cast_from_scalar(self, dtype):
Ultima's avatar
Ultima committed
461
462
        num = 10
        scalar = 4
csongor's avatar
csongor committed
463
464
465
466
        s = point_space(num, dtype)
        d = distributed_data_object(scalar,
                                    global_shape=(num,),
                                    dtype=dtype)
Ultima's avatar
Ultima committed
467
468

        casted_scalar = s.cast(scalar)
469
        assert(check_equality(s, casted_scalar, d))
csongor's avatar
csongor committed
470
        assert(d.equal(casted_scalar))
Ultima's avatar
Ultima committed
471
472
473
474

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
475
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
476
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
477
    def test_cast_from_field(self, dtype):
Ultima's avatar
Ultima committed
478
479
        num = 10
        a = np.arange(num,).astype(dtype)
csongor's avatar
csongor committed
480
        s = point_space(num, dtype)
481
        f = Field(s, val=a)
Ultima's avatar
Ultima committed
482

csongor's avatar
csongor committed
483
        d = distributed_data_object(a, dtype=dtype)
Ultima's avatar
Ultima committed
484
485

        casted_f = s.cast(f)
486
        assert(check_equality(s, casted_f, d))
csongor's avatar
csongor committed
487
        assert(d.equal(casted_f))
Ultima's avatar
Ultima committed
488
489
490
491

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
492
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
493
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
494
    def test_cast_from_ndarray(self, dtype):
Ultima's avatar
Ultima committed
495
496
        num = 10
        a = np.arange(num,)
csongor's avatar
csongor committed
497
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
498

csongor's avatar
csongor committed
499
        d = distributed_data_object(a, dtype=dtype)
Ultima's avatar
Ultima committed
500
501

        casted_a = s.cast(a)
502
        assert(check_equality(s, casted_a, d))
csongor's avatar
csongor committed
503
        assert(d.equal(casted_a))
Ultima's avatar
Ultima committed
504
505
506
507

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
508
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
509
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
510
    def test_cast_from_d2o(self, dtype):
Ultima's avatar
Ultima committed
511
512
513
        num = 10
        pre_a = np.arange(num,)
        a = distributed_data_object(pre_a)
csongor's avatar
csongor committed
514
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
515

csongor's avatar
csongor committed
516
        d = distributed_data_object(a, dtype=dtype)
Ultima's avatar
Ultima committed
517
518

        casted_a = s.cast(a)
519
        assert(check_equality(s, casted_a, d))
csongor's avatar
csongor committed
520
        assert(d.equal(casted_a))
Ultima's avatar
Ultima committed
521
522
523
524
525
526


###############################################################################

    def test_raise_on_not_implementable_methods(self):
        s = point_space(10)
527
528
529
530
        assert_raises(AttributeError, lambda: s.enforce_power(1))
        assert_raises(AttributeError, lambda: s.calc_smooth(1))
        assert_raises(AttributeError, lambda: s.calc_power(1))
        assert_raises(AttributeError, lambda: s.calc_transform(1))
Ultima's avatar
Ultima committed
531
532
533
534

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
535
536
537
        [[10, np.dtype('float64')],
         [10, np.dtype('float32')],
         [12, np.dtype('float64')]],
Ultima's avatar
Ultima committed
538
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
539
540
    def test_get_check_codomain(self, num, dtype):
        s = point_space(10, dtype=np.dtype('float64'))
Ultima's avatar
Ultima committed
541
542
543
544

        t = s.get_codomain()
        assert(s.check_codomain(t))

csongor's avatar
csongor committed
545
        t_bad = point_space(num, dtype=dtype)
Ultima's avatar
Ultima committed
546
547
548
549
550
551
552
        assert(s.check_codomain(t_bad) == False)

        assert(s.check_codomain(None) == False)

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
553
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
554
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
555
    def test_get_random_values(self, dtype):
556
557
558
        if dtype == np.dtype('bool'):
            return None

Ultima's avatar
Ultima committed
559
        num = 100000
csongor's avatar
csongor committed
560
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
561
562

        pm = s.get_random_values(random='pm1')
563
        assert(abs(s.unary_operation(pm, op='mean')) < 0.1)
Ultima's avatar
Ultima committed
564

565
566
567
568
569
        std = 4
        mean = 5
        gau = s.get_random_values(random='gau', mean=mean, std=std)
        assert(abs(gau.std() - std) / std < 0.2)
        assert(abs(gau.mean() - mean) / mean < 0.2)
Ultima's avatar
Ultima committed
570

571
572
573
574
575
        vmin = -4
        vmax = 10
        uni = s.get_random_values(random='uni', vmin=vmin, vmax=vmax)
        assert(abs(uni.real.mean() - 3.) / 3. < 0.1)
        assert(abs(uni.real.std() - 4.) / 4. < 0.1)
Ultima's avatar
Ultima committed
576

577
###############################################################################
Ultima's avatar
Ultima committed
578

579
    @parameterized.expand(
csongor's avatar
csongor committed
580
        itertools.product(all_point_datatypes),
581
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
582
    def test_get_calc_weight(self, dtype):
583
        num = 100
csongor's avatar
csongor committed
584
        s = point_space(num, dtype)
585
586
587
588
        weight = 1
        assert_equal(s.get_weight(), weight)
        assert_equal(s.get_weight(power=4), weight)
        assert_equal(s.get_weight(power=4, split=True), (weight,))
Ultima's avatar
Ultima committed
589

590
591
        data = s.cast(2)
        assert(check_equality(s, data, s.calc_weight(data)))
Ultima's avatar
Ultima committed
592

593
594
595
###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
596
        itertools.product(all_point_datatypes),
597
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
598
    def test_calc_dot(self, dtype):
599
        num = 100
csongor's avatar
csongor committed
600
        s = point_space(num, dtype)
601
602
603
604
605
606
        if dtype == np.dtype('bool'):
            assert_equal(s.calc_dot(1, 1), 1)
        else:
            assert_equal(s.calc_dot(1, 1), num)
            assert_equal(s.calc_dot(np.arange(num), 1), num * (num - 1.) / 2.)

Ultima's avatar
Ultima committed
607
608
609
###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
610
        itertools.product(),
Ultima's avatar
Ultima committed
611
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
612
    def test_calc_norm(self):
Ultima's avatar
Ultima committed
613
        num = 10
csongor's avatar
csongor committed
614
        s = point_space(num)
Ultima's avatar
Ultima committed
615
616
617
618
        d = s.cast(np.arange(num))
        assert_almost_equal(s.calc_norm(d), 16.881943016134134)
        assert_almost_equal(s.calc_norm(d, q=3), 12.651489979526238)

619
###############################################################################
Ultima's avatar
Ultima committed
620

621
    @parameterized.expand(
csongor's avatar
csongor committed
622
        itertools.product(),
623
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
624
    def test_calc_real_Q(self):
625
        num = 100
csongor's avatar
csongor committed
626
        s = point_space(num, dtype=np.complex)
627
628
629
630
        real_data = s.cast(1)
        assert(s.calc_real_Q(real_data))
        complex_data = s.cast(1 + 1j)
        assert(s.calc_real_Q(complex_data) == False)
Ultima's avatar
Ultima committed
631

632
###############################################################################
Ultima's avatar
Ultima committed
633

634
    @parameterized.expand(
csongor's avatar
csongor committed
635
        itertools.product(),
636
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
637
    def test_calc_bincount(self):
638
        num = 10
csongor's avatar
csongor committed
639
        s = point_space(num, dtype=np.int)
640
641
642
643
644
645
        data = s.cast(np.array([1, 1, 2, 0, 5, 8, 4, 5, 4, 5]))
        weights = np.arange(10) / 10.
        assert_equal(s.calc_bincount(data),
                     np.array([1, 2, 1, 0, 2, 3, 0, 0, 1]))
        assert_equal(s.calc_bincount(data, weights=weights),
                     np.array([0.3, 0.1, 0.2, 0, 1.4, 2, 0, 0, 0.5]))
Ultima's avatar
Ultima committed
646
647


648
649
###############################################################################
###############################################################################
Ultima's avatar
Ultima committed
650

651
class Test_RG_Space(unittest.TestCase):
652

653
654
655
656
657
658
    @parameterized.expand(
        itertools.product([(1,), (10, 10)],
                          [0, 1, 2],
                          [True, False],
                          [None, 0.5],
                          [True, False],
csongor's avatar
csongor committed
659
                          fft_modules),
660
661
        testcase_func_name=custom_name_func)
    def test_successfull_init(self, shape, complexity, zerocenter, distances,
csongor's avatar
csongor committed
662
                              harmonic, fft_module):
csongor's avatar
csongor committed
663
        x = RgSpace(shape,
664
665
666
667
                     complexity=complexity,
                     zerocenter=zerocenter,
                     distances=distances,
                     harmonic=harmonic,
csongor's avatar
csongor committed
668
                     fft_module=fft_module)
Ultima's avatar
Ultima committed
669
        assert(isinstance(x.harmonic, bool))
670
        assert_equal(x.shape, shape)
671
672
673
674
675
676
        assert_equal(x.dtype,
                     np.dtype('float64') if complexity == 0 else
                     np.dtype('complex128'))
        assert_equal(x.distances,
                     1. / np.array(shape) if distances is None else
                     np.ones(len(shape)) * distances)
677

678
###############################################################################
679

680
681
682
683
    def test_para(self):
        shape = (10, 10)
        zerocenter = True
        complexity = 2
csongor's avatar
csongor committed
684
        x = RgSpace(shape, zerocenter=zerocenter, complexity=complexity)
685
686
687
688
689
690
691
692
693
        assert_equal(x.para, np.array([10, 10, 2, 1, 1]))

        new_para = np.array([6, 6, 1, 0, 1])
        x.para = new_para
        assert_equal(x.para, new_para)

###############################################################################

    def test_init_fail(self):
csongor's avatar
csongor committed
694
695
696
        assert_raises(ValueError, lambda: RgSpace((-3, 10)))
        assert_raises(ValueError, lambda: RgSpace((10, 10), complexity=3))
        assert_raises(ValueError, lambda: RgSpace((10, 10),
697
                                                   distances=[1, 1, 1]))
csongor's avatar
csongor committed
698
        assert_raises(ValueError, lambda: RgSpace((10, 10),
699
700
701
702
                                                   zerocenter=[1, 1, 1]))

###############################################################################

csongor's avatar
csongor committed
703
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
704
    def test_cast_to_hermitian(self):
705
706
707
708
709
710
711
712
713
        shape = (10, 10)
        x = rg_space(shape, complexity=1)
        data = np.random.random(shape) + np.random.random(shape) * 1j
        casted_data = x.cast(data)
        flipped_data = flip(x, casted_data)
        assert(check_equality(x, flipped_data, casted_data))

###############################################################################

csongor's avatar
csongor committed
714
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
715
    def test_enforce_power(self):
716
        shape = (6, 6)
csongor's avatar
csongor committed
717
        x = RgSpace(shape)
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736

        assert_equal(x.enforce_power(2),
                     np.array([2., 2., 2., 2., 2., 2., 2., 2., 2., 2.]))
        assert_almost_equal(
            x.enforce_power(lambda x: 42 / (1 + x)**5),
            np.array([4.20000000e+01, 1.31250000e+00, 5.12118970e-01,
                      1.72839506e-01, 1.18348051e-01, 5.10678257e-02,
                      4.10156250e-02, 3.36197167e-02, 2.02694134e-02,
                      1.06047106e-02]))

###############################################################################

    @parameterized.expand(
        itertools.product([0, 1, 2],
                          [None, 1, 10],
                          [False, True]),
        testcase_func_name=custom_name_func)
    def test_get_check_codomain(self, complexity, distances, harmonic):
        shape = (6, 6)
csongor's avatar
csongor committed
737
        x = RgSpace(shape, complexity=complexity, distances=distances,
738
739
740
741
742
743
744
                     harmonic=harmonic)
        y = x.get_codomain()
        assert(x.check_codomain(y))
        assert(y.check_codomain(x))

###############################################################################

745
746
747
748
749
750
#    @parameterized.expand(
#        itertools.product([True], #[True, False],
#                          ['fftw']),
#                          #DATAMODELS['rg_space']),
#        testcase_func_name=custom_name_func)
#    def test_get_random_values(self, harmonic, datamodel):
csongor's avatar
csongor committed
751
#        x = RgSpace((4, 4), complexity=1, harmonic=harmonic,
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
#                     datamodel=datamodel)
#
#        # pm1
#        data = x.get_random_values(random='pm1')
#        flipped_data = flip(x, data)
#        assert(check_almost_equality(x, data, flipped_data))
#
#        # gau
#        data = x.get_random_values(random='gau', mean=4 + 3j, std=2)
#        flipped_data = flip(x, data)
#        assert(check_almost_equality(x, data, flipped_data))
#
#        # uni
#        data = x.get_random_values(random='uni', vmin=-2, vmax=4)
#        flipped_data = flip(x, data)
#        assert(check_almost_equality(x, data, flipped_data))
#
#        # syn
#        data = x.get_random_values(random='syn',
#                                   spec=lambda x: 42 / (1 + x)**3)
#        flipped_data = flip(x, data)
#        assert(check_almost_equality(x, data, flipped_data))
774
775
776

###############################################################################

csongor's avatar
csongor committed
777
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
778
    def test_calc_dot(self):
779
780
        shape = (8, 8)
        a = np.arange(np.prod(shape)).reshape(shape)
csongor's avatar
csongor committed
781
        x = RgSpace(shape)
782
783
784
785
786
787
788
        assert_equal(x.calc_dot(a, a), 85344)
        assert_equal(x.calc_dot(a, 1), 2016)
        assert_equal(x.calc_dot(1, a), 2016)

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
789
        itertools.product([0, 1]),
790
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
791
    def test_calc_transform_general(self, complexity):
792
793
794
        data = fft_test_data.copy()
        shape = data.shape

csongor's avatar
csongor committed
795
        x = RgSpace(shape, complexity=complexity)
796
797
798
799
800
801
802
        data = fft_test_data.copy()
        data = x.cast(data)
        check_equality(x, data, x.calc_transform(x.calc_transform(data)))

###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
803
        itertools.product(fft_modules),
804
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
805
    def test_calc_transform_explicit(self, fft_module):
806
807
808
        data = fft_test_data.copy()
        shape = data.shape

csongor's avatar
csongor committed
809
        x = RgSpace(shape, complexity=2, zerocenter=False,
csongor's avatar
csongor committed
810
                     fft_module=fft_module)
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
        casted_data = x.cast(data)
        assert(check_almost_equality(x, x.calc_transform(casted_data),
                                     np.array([[0.50541615 + 0.50558267j, -0.01458536 - 0.01646137j,
                                                0.01649006 + 0.01990988j, 0.04668049 - 0.03351745j,
                                                -0.04382765 - 0.06455639j, -0.05978564 + 0.01334044j],
                                               [-0.05347464 + 0.04233343j, -0.05167177 + 0.00643947j,
                                                -0.01995970 - 0.01168872j, 0.10653817 + 0.03885947j,
                                                -0.03298075 - 0.00374715j, 0.00622585 - 0.01037453j],
                                               [-0.01128964 - 0.02424692j, -0.03347793 - 0.0358814j,
                                                -0.03924164 - 0.01978305j, 0.03821242 - 0.00435542j,
                                                0.07533170 + 0.14590143j, -0.01493027 - 0.02664675j],
                                               [0.02238926 + 0.06140625j, -0.06211313 + 0.03317753j,
                                                0.01519073 + 0.02842563j, 0.00517758 + 0.08601604j,
                                                -0.02246912 - 0.01942764j, -0.06627311 - 0.08763801j],
                                               [-0.02492378 - 0.06097411j, 0.06365649 - 0.09346585j,
                                                0.05031486 + 0.00858656j, -0.00881969 + 0.01842357j,
                                                -0.01972641 - 0.00994365j, 0.05289453 - 0.06822038j],
                                               [-0.01865586 - 0.08640926j, 0.03414096 - 0.02605602j,
                                                -0.09492552 + 0.01306734j, 0.09355730 + 0.07553701j,
                                                -0.02395259 - 0.02185743j, -0.03107832 - 0.04714527j]])))

csongor's avatar
csongor committed
832
        x = RgSpace(shape, complexity=2, zerocenter=True,
csongor's avatar
csongor committed
833
                     fft_module=fft_module)
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
        casted_data = x.cast(data)
        assert(check_almost_equality(x, x.calc_transform(casted_data),
                                     np.array([[0.00517758 + 0.08601604j, 0.02246912 + 0.01942764j,
                                                -0.06627311 - 0.08763801j, -0.02238926 - 0.06140625j,
                                                -0.06211313 + 0.03317753j, -0.01519073 - 0.02842563j],
                                               [0.00881969 - 0.01842357j, -0.01972641 - 0.00994365j,
                                                -0.05289453 + 0.06822038j, -0.02492378 - 0.06097411j,
                                                -0.06365649 + 0.09346585j, 0.05031486 + 0.00858656j],
                                               [0.09355730 + 0.07553701j, 0.02395259 + 0.02185743j,
                                                -0.03107832 - 0.04714527j, 0.01865586 + 0.08640926j,
                                                0.03414096 - 0.02605602j, 0.09492552 - 0.01306734j],
                                               [-0.04668049 + 0.03351745j, -0.04382765 - 0.06455639j,
                                                0.05978564 - 0.01334044j, 0.50541615 + 0.50558267j,
                                                0.01458536 + 0.01646137j, 0.01649006 + 0.01990988j],
                                               [0.10653817 + 0.03885947j, 0.03298075 + 0.00374715j,
                                                0.00622585 - 0.01037453j, 0.05347464 - 0.04233343j,
                                                -0.05167177 + 0.00643947j, 0.01995970 + 0.01168872j],
                                               [-0.03821242 + 0.00435542j, 0.07533170 + 0.14590143j,
                                                0.01493027 + 0.02664675j, -0.01128964 - 0.02424692j,
                                                0.03347793 + 0.0358814j, -0.03924164 - 0.01978305j]])))

csongor's avatar
csongor committed
855
        x = RgSpace(shape, complexity=2, zerocenter=[True, False],
csongor's avatar
csongor committed
856
                     fft_module=fft_module)
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
        casted_data = x.cast(data)
        assert(check_almost_equality(x, x.calc_transform(casted_data),
                                     np.array([[-0.02238926 - 0.06140625j, 0.06211313 - 0.03317753j,
                                                -0.01519073 - 0.02842563j, -0.00517758 - 0.08601604j,
                                                0.02246912 + 0.01942764j, 0.06627311 + 0.08763801j],
                                               [-0.02492378 - 0.06097411j, 0.06365649 - 0.09346585j,
                                                0.05031486 + 0.00858656j, -0.00881969 + 0.01842357j,
                                                -0.01972641 - 0.00994365j, 0.05289453 - 0.06822038j],
                                               [0.01865586 + 0.08640926j, -0.03414096 + 0.02605602j,
                                                0.09492552 - 0.01306734j, -0.09355730 - 0.07553701j,
                                                0.02395259 + 0.02185743j, 0.03107832 + 0.04714527j],
                                               [0.50541615 + 0.50558267j, -0.01458536 - 0.01646137j,
                                                0.01649006 + 0.01990988j, 0.04668049 - 0.03351745j,
                                                -0.04382765 - 0.06455639j, -0.05978564 + 0.01334044j],
                                               [0.05347464 - 0.04233343j, 0.05167177 - 0.00643947j,
                                                0.01995970 + 0.01168872j, -0.10653817 - 0.03885947j,
                                                0.03298075 + 0.00374715j, -0.00622585 + 0.01037453j],
                                               [-0.01128964 - 0.02424692j, -0.03347793 - 0.0358814j,
                                                -0.03924164 - 0.01978305j, 0.03821242 - 0.00435542j,
                                                0.07533170 + 0.14590143j, -0.01493027 - 0.02664675j]])))

csongor's avatar
csongor committed
878
        x = RgSpace(shape, complexity=2, zerocenter=[True, False],
csongor's avatar
csongor committed
879
                     fft_module=fft_module)
csongor's avatar
csongor committed
880
        y = RgSpace(shape, complexity=2, zerocenter=[False, True],
881
                     distances=[1, 1], harmonic=True,
csongor's avatar
csongor committed
882
                     fft_module=fft_module)
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
        casted_data = x.cast(data)
        assert(check_almost_equality(x, x.calc_transform(casted_data,
                                                         codomain=y),
                                     np.array([[0.04668049 - 0.03351745j, -0.04382765 - 0.06455639j,
                                                -0.05978564 + 0.01334044j, 0.50541615 + 0.50558267j,
                                                -0.01458536 - 0.01646137j, 0.01649006 + 0.01990988j],
                                               [-0.10653817 - 0.03885947j, 0.03298075 + 0.00374715j,
                                                -0.00622585 + 0.01037453j, 0.05347464 - 0.04233343j,
                                                0.05167177 - 0.00643947j, 0.01995970 + 0.01168872j],
                                               [0.03821242 - 0.00435542j, 0.07533170 + 0.14590143j,
                                                -0.01493027 - 0.02664675j, -0.01128964 - 0.02424692j,
                                                -0.03347793 - 0.0358814j, -0.03924164 - 0.01978305j],
                                               [-0.00517758 - 0.08601604j, 0.02246912 + 0.01942764j,
                                                0.06627311 + 0.08763801j, -0.02238926 - 0.06140625j,
                                                0.06211313 - 0.03317753j, -0.01519073 - 0.02842563j],
                                               [-0.00881969 + 0.01842357j, -0.01972641 - 0.00994365j,
                                                0.05289453 - 0.06822038j, -0.02492378 - 0.06097411j,
                                                0.06365649 - 0.09346585j, 0.05031486 + 0.00858656j],
                                               [-0.09355730 - 0.07553701j, 0.02395259 + 0.02185743j,
                                                0.03107832 + 0.04714527j, 0.01865586 + 0.08640926j,
                                                -0.03414096 + 0.02605602j, 0.09492552 - 0.01306734j]])))

Ultima's avatar
Ultima committed
905
906
907
908
909
910
911
912
###############################################################################

    @parameterized.expand(
        itertools.product(fft_modules,
                          [(6, 6), (8, 8), (6, 8)],
                          [(True, True), (False, False),
                           (True, False), (False, True)],
                          [(True, True), (False, False),
csongor's avatar
csongor committed
913
                           (True, False), (False, True)]),
Ultima's avatar
Ultima committed
914
915
        testcase_func_name=custom_name_func)
    def test_calc_transform_variations(self, fft_module, shape, zerocenter_in,
csongor's avatar
csongor committed
916
                                       zerocenter_out):
Ultima's avatar
Ultima committed
917
        data = np.arange(np.prod(shape)).reshape(shape)
csongor's avatar
csongor committed
918
        x = RgSpace(shape, complexity=2, zerocenter=zerocenter_in,
csongor's avatar
csongor committed
919
                     fft_module=fft_module)
Ultima's avatar
Ultima committed
920
921
922
923
924
925
926
927
928
929
930
931
932
        y = x.get_codomain()
        y.paradict['zerocenter'] = zerocenter_out

        casted_data = x.cast(data)
        x_result = x.calc_transform(casted_data, codomain=y)

        np_data = data.copy()
        np_data = np.fft.fftshift(np_data, axes=np.where(zerocenter_in)[0])
        np_data = np.fft.fftn(np_data)
        np_data = np.fft.fftshift(np_data, axes=np.where(zerocenter_out)[0])
        np_result = np_data/np.prod(shape)
        assert(check_almost_equality(x, x_result, np_result))

933
934
###############################################################################

csongor's avatar
csongor committed
935
    @parameterized.expand([],testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
936
    def test_calc_smooth(self):
937
938
939
        sigma = 0.01
        shape = (8, 8)
        a = np.arange(np.prod(shape)).reshape(shape)
csongor's avatar
csongor committed
940
        x = RgSpace(shape)
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
        casted_a = x.cast(a)
        assert(check_almost_equality(x, x.calc_smooth(casted_a, sigma=sigma),
                                     np.array([[0.3869063,   1.33370382,   2.34906384,   3.3400879,
                                                4.34774552,   5.33876958,   6.3541296,   7.30092712],
                                               [7.96128648,   8.90808401,   9.92344403,  10.91446809,
                                                11.9221257,  12.91314976,  13.92850978,  14.87530731],
                                               [16.08416664,  17.03096417,  18.04632419,  19.03734824,
                                                20.04500586,  21.03602992,  22.05138994,  22.99818747],
                                               [24.01235911,  24.95915664,  25.97451666,  26.96554072,
                                                27.97319833,  28.96422239,  29.97958241,  30.92637994],
                                               [32.07362006,  33.02041759,  34.03577761,  35.02680167,
                                                36.03445928,  37.02548334,  38.04084336,  38.98764089],
                                               [40.00181253,  40.94861006,  41.96397008,  42.95499414,
                                                43.96265176,  44.95367581,  45.96903583,  46.91583336],
                                               [48.12469269,  49.07149022,  50.08685024,  51.0778743,
                                                52.08553191,  53.07655597,  54.09191599,  55.03871352],
                                               [55.69907288,  56.6458704,  57.66123042,  58.65225448,
                                                59.6599121,  60.65093616,  61.66629618,  62.6130937]])))

###############################################################################

csongor's avatar
csongor committed
962
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
963
    def test_calc_power(self):
964
965
        shape = (8, 8)
        a = np.arange(np.prod(shape)).reshape(shape)
csongor's avatar
csongor committed
966
        x = RgSpace(shape)
967
968
969
970
971
        assert_almost_equal(x.calc_power(a),
                            np.array([992.25, 55.48097039, 0., 16.25,
                                      0., 0., 9.51902961, 0.,
                                      0., 8.125, 0., 0.,
                                      0., 0., 0.]))
Ultima's avatar
Ultima committed
972
973
974
975
976
977
978
979
980
981


###############################################################################
###############################################################################

class Test_Lm_Space(unittest.TestCase):

    @parameterized.expand(
        itertools.product([1, 17],
                          [None, 12, 17],
csongor's avatar
csongor committed
982
                          all_lm_datatypes),
Ultima's avatar
Ultima committed
983
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
984
985
    def test_successfull_init(self, lmax, mmax, dtype):
        # TODO Look at this
986
        if datamodel in ['not']:
csongor's avatar
csongor committed
987
            l = LmSpace(lmax, mmax=mmax, dtype=dtype)
988
989
990
991
992
993
994
995
996
997
            assert(isinstance(l.harmonic, bool))
            assert_equal(l.paradict['lmax'], lmax)
            if mmax is None or mmax > lmax:
                assert_equal(l.paradict['mmax'], lmax)
            else:
                assert_equal(l.paradict['mmax'], mmax)
            assert_equal(l.dtype, dtype)
            assert_equal(l.discrete, True)
            assert_equal(l.harmonic, True)
            assert_equal(l.distances, (np.float(1),))
Ultima's avatar
Ultima committed
998
        else:
csongor's avatar
csongor committed
999
            with assert_raises(NotImplementedError): LmSpace(lmax, mmax=mmax, dtype=dtype)
1000

Ultima's avatar
Ultima committed
1001
1002
1003
1004
1005
1006

###############################################################################

    def test_para(self):
        lmax = 17
        mmax = 12
csongor's avatar
csongor committed
1007
        l = LmSpace(lmax, mmax=mmax)
Ultima's avatar
Ultima committed
1008
1009
1010
1011
1012
1013
1014
1015
1016
        assert_equal(l.para, np.array([lmax, mmax]))

        new_para = np.array([9, 12])
        l.para = new_para
        assert_equal(l.para, np.array([9, 9]))

    def test_get_shape_dof_meta_volume(self):
        lmax = 17
        mmax = 12
csongor's avatar
csongor committed
1017
        l = LmSpace(lmax, mmax=mmax)
Ultima's avatar
Ultima committed
1018

1019
1020
1021
1022
1023
        assert_equal(l.shape, (156,))
        assert_equal(l.dof, 294)
        assert_equal(l.dof_split, (294,))
        assert_equal(l.meta_volume, 294.)
        assert_equal(l.meta_volume_split,
Ultima's avatar
Ultima committed
1024
1025
1026
1027
1028
                     l.cast(np.concatenate([np.ones(18), np.ones(138)*2])))

    def test_cast(self):
        lmax = 17
        mmax = 12
csongor's avatar
csongor committed
1029
        l = LmSpace(lmax, mmax=mmax)
Ultima's avatar
Ultima committed
1030
1031
1032
1033
1034
1035
1036

        casted = l.cast(1+1j)
        real_part = casted[:18]
        assert(real_part,  l.unary_operation(real_part, 'real'))

###############################################################################

csongor's avatar
csongor committed
1037
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
1038
    def test_enforce_power(self):
Ultima's avatar
Ultima committed
1039
1040
        lmax = 17
        mmax = 12
csongor's avatar
csongor committed
1041
        # TODO Look at this
1042
        if datamodel in ['not']:
csongor's avatar
csongor committed
1043
            l = LmSpace(lmax, mmax=mmax, datamodel=datamodel)
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054
1055

            assert_equal(l.enforce_power(2),
                         np.ones(18)*2)
            assert_almost_equal(
                l.enforce_power(lambda x: 42 / (1 + x)**5),
                np.array([  4.20000000e+01,   1.31250000e+00,   1.72839506e-01,
             4.10156250e-02,   1.34400000e-02,   5.40123457e-03,
             2.49895877e-03,   1.28173828e-03,   7.11273688e-04,
             4.20000000e-04,   2.60786956e-04,   1.68788580e-04,
             1.13118211e-04,   7.80924615e-05,   5.53086420e-05,
             4.00543213e-05,   2.95804437e-05,   2.22273027e-05]))
        else:
csongor's avatar
csongor committed
1056
            with assert_raises(NotImplementedError): LmSpace(lmax, mmax=mmax, datamodel=datamodel)
Ultima's avatar
Ultima committed
1057
1058
1059

##############################################################################

csongor's avatar
csongor committed
1060
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
1061