test_nifty_spaces.py 59 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

theos's avatar
theos committed
21
from nifty.rg.rg_space import RG_DISTRIBUTION_STRATEGIES,\
csongor's avatar
csongor committed
22
                              gc as RG_GC,\
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:
35
    from nifty import LMSpace
Ultima's avatar
Ultima committed
36
37
38
39
40
except ImportError:
    pass
else:
    available += ['lm_space']
try:
41
    from nifty import GLSpace
Ultima's avatar
Ultima committed
42
43
44
45
46
except ImportError:
    pass
else:
    available += ['gl_space']
try:
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),
172
                  'rg_space': RGSpace((8, 8)),
173
                  }
Ultima's avatar
Ultima committed
174
    if 'lm_space' in available:
175
        space_dict['lm_space'] = LMSpace(mmax=11, lmax=11)
Ultima's avatar
Ultima committed
176
    if 'hp_space' in available:
177
        space_dict['hp_space'] = HPSpace(8)
Ultima's avatar
Ultima committed
178
    if 'gl_space' in available:
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),
187
                  'rg_space': RGSpace((num, num)),
188
189
                  }
    if 'lm_space' in available:
190
        space_dict['lm_space'] = LMSpace(mmax=num, lmax=num)
191
    if 'hp_space' in available:
192
        space_dict['hp_space'] = HPSpace(num)
193
    if 'gl_space' in available:
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

    @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))
Ultima's avatar
Ultima committed
293
#        assert(isinstance(s.harmonic, bool))
294
        assert(isinstance(s.distances, tuple))
Ultima's avatar
Ultima committed
295
296
297
        if hasattr(s, 'harmonic'):
            if s.harmonic:
                assert(isinstance(s.power_indices, power_indices))
298
299
300

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

306
        assert(isinstance(s.dof, np.int))
307

Ultima's avatar
Ultima committed
308
309
        assert(isinstance(s.get_vol(), np.float))

310
311
312
        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))))
313
        assert_almost_equal(
314
            s.meta_volume, s.meta_volume_split.sum(), 2)
315

316
317
318
319
320
321
322
    @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
323

324
325
326
327

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

Ultima's avatar
Ultima committed
328
class Test_Point_Space(unittest.TestCase):
329
330
331

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

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

Ultima's avatar
Ultima committed
341
342
###############################################################################

343
344
345
346
347
348
349
350
351
    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
352
353
###############################################################################

354
355
356
357
358
    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
359
360
361
###############################################################################

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

        t = s.apply_scalar_function(d, lambda x: x**2, inplace=True)
372
        assert(check_equality(s, d, t))
Ultima's avatar
Ultima committed
373
374
375
376
377
378
        assert(id(d) == id(t))

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

    @parameterized.expand(
        itertools.product([1, 10],
csongor's avatar
csongor committed
379
                          unary_operations),
Ultima's avatar
Ultima committed
380
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
381
382
    def test_unary_operations(self, num, op):
        s = point_space(num)
Ultima's avatar
Ultima committed
383
384
385
386
387
388
        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
389
                          binary_operations),
Ultima's avatar
Ultima committed
390
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
391
392
    def test_binary_operations(self, num, op):
        s = point_space(num)
Ultima's avatar
Ultima committed
393
394
395
396
397
398
399
400
        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
401
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
402
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
403
    def test_get_shape_dim(self, dtype):
Ultima's avatar
Ultima committed
404
        num = 10
csongor's avatar
csongor committed
405
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
406

407
408
        assert_equal(s.shape, (num,))
        assert_equal(s.dim, num)
Ultima's avatar
Ultima committed
409
410
411
412

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

    @parameterized.expand(
csongor's avatar
csongor committed
413
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
414
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
415
    def test_get_shape_dof(self, dtype):
Ultima's avatar
Ultima committed
416
        num = 10
csongor's avatar
csongor committed
417
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
418
419

        if issubclass(dtype.type, np.complexfloating):
420
            assert_equal(s.dof, 2 * num)
Ultima's avatar
Ultima committed
421
        else:
422
            assert_equal(s.dof, num)
Ultima's avatar
Ultima committed
423
424
425
426

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

    @parameterized.expand(
csongor's avatar
csongor committed
427
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
428
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
429
    def test_get_shape_vol(self, dtype):
Ultima's avatar
Ultima committed
430
        num = 10
csongor's avatar
csongor committed
431
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
432
433
434
435
436
437
438

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

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

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

445
446
        assert_equal(s.meta_volume, 10.)
        assert(check_equality(s, s.meta_volume_split, s.cast(1)))
Ultima's avatar
Ultima committed
447
448
449
450

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

    @parameterized.expand(
csongor's avatar
csongor committed
451
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
452
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
453
    def test_cast_from_scalar(self, dtype):
Ultima's avatar
Ultima committed
454
455
        num = 10
        scalar = 4
csongor's avatar
csongor committed
456
457
458
459
        s = point_space(num, dtype)
        d = distributed_data_object(scalar,
                                    global_shape=(num,),
                                    dtype=dtype)
Ultima's avatar
Ultima committed
460
461

        casted_scalar = s.cast(scalar)
462
        assert(check_equality(s, casted_scalar, d))
csongor's avatar
csongor committed
463
        assert(d.equal(casted_scalar))
Ultima's avatar
Ultima committed
464
465
466
467

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

    @parameterized.expand(
csongor's avatar
csongor committed
468
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
469
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
470
    def test_cast_from_field(self, dtype):
Ultima's avatar
Ultima committed
471
472
        num = 10
        a = np.arange(num,).astype(dtype)
csongor's avatar
csongor committed
473
        s = point_space(num, dtype)
474
        f = Field(s, val=a)
Ultima's avatar
Ultima committed
475

csongor's avatar
csongor committed
476
        d = distributed_data_object(a, dtype=dtype)
Ultima's avatar
Ultima committed
477
478

        casted_f = s.cast(f)
479
        assert(check_equality(s, casted_f, d))
csongor's avatar
csongor committed
480
        assert(d.equal(casted_f))
Ultima's avatar
Ultima committed
481
482
483
484

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

    @parameterized.expand(
csongor's avatar
csongor committed
485
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
486
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
487
    def test_cast_from_ndarray(self, dtype):
Ultima's avatar
Ultima committed
488
489
        num = 10
        a = np.arange(num,)
csongor's avatar
csongor committed
490
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
491

csongor's avatar
csongor committed
492
        d = distributed_data_object(a, dtype=dtype)
Ultima's avatar
Ultima committed
493
494

        casted_a = s.cast(a)
495
        assert(check_equality(s, casted_a, d))
csongor's avatar
csongor committed
496
        assert(d.equal(casted_a))
Ultima's avatar
Ultima committed
497
498
499
500

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

    @parameterized.expand(
csongor's avatar
csongor committed
501
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
502
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
503
    def test_cast_from_d2o(self, dtype):
Ultima's avatar
Ultima committed
504
505
506
        num = 10
        pre_a = np.arange(num,)
        a = distributed_data_object(pre_a)
csongor's avatar
csongor committed
507
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
508

csongor's avatar
csongor committed
509
        d = distributed_data_object(a, dtype=dtype)
Ultima's avatar
Ultima committed
510
511

        casted_a = s.cast(a)
512
        assert(check_equality(s, casted_a, d))
csongor's avatar
csongor committed
513
        assert(d.equal(casted_a))
Ultima's avatar
Ultima committed
514
515
516
517
518
519


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

    def test_raise_on_not_implementable_methods(self):
        s = point_space(10)
520
521
522
523
        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
524
525
526
527

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

    @parameterized.expand(
csongor's avatar
csongor committed
528
529
530
        [[10, np.dtype('float64')],
         [10, np.dtype('float32')],
         [12, np.dtype('float64')]],
Ultima's avatar
Ultima committed
531
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
532
533
    def test_get_check_codomain(self, num, dtype):
        s = point_space(10, dtype=np.dtype('float64'))
Ultima's avatar
Ultima committed
534
535
536
537

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

csongor's avatar
csongor committed
538
        t_bad = point_space(num, dtype=dtype)
Ultima's avatar
Ultima committed
539
540
541
542
543
544
545
        assert(s.check_codomain(t_bad) == False)

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

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

    @parameterized.expand(
csongor's avatar
csongor committed
546
        itertools.product(all_point_datatypes),
Ultima's avatar
Ultima committed
547
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
548
    def test_get_random_values(self, dtype):
549
550
551
        if dtype == np.dtype('bool'):
            return None

Ultima's avatar
Ultima committed
552
        num = 100000
csongor's avatar
csongor committed
553
        s = point_space(num, dtype)
Ultima's avatar
Ultima committed
554
555

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

558
559
560
561
562
        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
563

564
565
566
567
568
        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
569

570
###############################################################################
Ultima's avatar
Ultima committed
571

572
    @parameterized.expand(
csongor's avatar
csongor committed
573
        itertools.product(all_point_datatypes),
574
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
575
    def test_get_calc_weight(self, dtype):
576
        num = 100
csongor's avatar
csongor committed
577
        s = point_space(num, dtype)
578
579
580
581
        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
582

583
584
        data = s.cast(2)
        assert(check_equality(s, data, s.calc_weight(data)))
Ultima's avatar
Ultima committed
585

586
587
588
###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
589
        itertools.product(all_point_datatypes),
590
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
591
    def test_calc_dot(self, dtype):
592
        num = 100
csongor's avatar
csongor committed
593
        s = point_space(num, dtype)
594
595
596
597
598
599
        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
600
601
602
###############################################################################

    @parameterized.expand(
csongor's avatar
csongor committed
603
        itertools.product(),
Ultima's avatar
Ultima committed
604
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
605
    def test_calc_norm(self):
Ultima's avatar
Ultima committed
606
        num = 10
csongor's avatar
csongor committed
607
        s = point_space(num)
Ultima's avatar
Ultima committed
608
609
610
611
        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)

612
###############################################################################
Ultima's avatar
Ultima committed
613

614
    @parameterized.expand(
csongor's avatar
csongor committed
615
        itertools.product(),
616
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
617
    def test_calc_real_Q(self):
618
        num = 100
csongor's avatar
csongor committed
619
        s = point_space(num, dtype=np.complex)
620
621
622
623
        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
624

625
###############################################################################
Ultima's avatar
Ultima committed
626

627
    @parameterized.expand(
csongor's avatar
csongor committed
628
        itertools.product(),
629
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
630
    def test_calc_bincount(self):
631
        num = 10
csongor's avatar
csongor committed
632
        s = point_space(num, dtype=np.int)
633
634
635
636
637
638
        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
639
640


641
642
###############################################################################
###############################################################################
Ultima's avatar
Ultima committed
643

644
class Test_RG_Space(unittest.TestCase):
645

646
647
648
649
650
651
    @parameterized.expand(
        itertools.product([(1,), (10, 10)],
                          [0, 1, 2],
                          [True, False],
                          [None, 0.5],
                          [True, False],
csongor's avatar
csongor committed
652
                          fft_modules),
653
654
        testcase_func_name=custom_name_func)
    def test_successfull_init(self, shape, complexity, zerocenter, distances,
csongor's avatar
csongor committed
655
                              harmonic, fft_module):
656
        x = RGSpace(shape,
657
658
659
660
                     complexity=complexity,
                     zerocenter=zerocenter,
                     distances=distances,
                     harmonic=harmonic,
csongor's avatar
csongor committed
661
                     fft_module=fft_module)
Ultima's avatar
Ultima committed
662
        assert(isinstance(x.harmonic, bool))
663
        assert_equal(x.shape, shape)
664
665
666
667
668
669
        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)
670

671
###############################################################################
672

673
674
675
676
    def test_para(self):
        shape = (10, 10)
        zerocenter = True
        complexity = 2
677
        x = RGSpace(shape, zerocenter=zerocenter, complexity=complexity)
678
679
680
681
682
683
684
685
686
        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):
687
688
689
        assert_raises(ValueError, lambda: RGSpace((-3, 10)))
        assert_raises(ValueError, lambda: RGSpace((10, 10), complexity=3))
        assert_raises(ValueError, lambda: RGSpace((10, 10),
690
                                                   distances=[1, 1, 1]))
691
        assert_raises(ValueError, lambda: RGSpace((10, 10),
692
693
694
695
                                                   zerocenter=[1, 1, 1]))

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

csongor's avatar
csongor committed
696
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
697
    def test_cast_to_hermitian(self):
698
699
700
701
702
703
704
705
706
        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
707
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
708
    def test_enforce_power(self):
709
        shape = (6, 6)
710
        x = RGSpace(shape)
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729

        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)
730
        x = RGSpace(shape, complexity=complexity, distances=distances,
731
732
733
734
735
736
737
                     harmonic=harmonic)
        y = x.get_codomain()
        assert(x.check_codomain(y))
        assert(y.check_codomain(x))

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

738
739
740
741
742
743
#    @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):
744
#        x = RGSpace((4, 4), complexity=1, harmonic=harmonic,
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
#                     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))
767
768
769

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

csongor's avatar
csongor committed
770
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
771
    def test_calc_dot(self):
772
773
        shape = (8, 8)
        a = np.arange(np.prod(shape)).reshape(shape)
774
        x = RGSpace(shape)
775
776
777
778
779
780
781
        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
782
        itertools.product([0, 1]),
783
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
784
    def test_calc_transform_general(self, complexity):
785
786
787
        data = fft_test_data.copy()
        shape = data.shape

788
        x = RGSpace(shape, complexity=complexity)
789
790
791
792
793
794
795
        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
796
        itertools.product(fft_modules),
797
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
798
    def test_calc_transform_explicit(self, fft_module):
799
800
801
        data = fft_test_data.copy()
        shape = data.shape

802
        x = RGSpace(shape, complexity=2, zerocenter=False,
csongor's avatar
csongor committed
803
                     fft_module=fft_module)
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
        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]])))

825
        x = RGSpace(shape, complexity=2, zerocenter=True,
csongor's avatar
csongor committed
826
                     fft_module=fft_module)
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
        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]])))

848
        x = RGSpace(shape, complexity=2, zerocenter=[True, False],
csongor's avatar
csongor committed
849
                     fft_module=fft_module)
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
        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]])))

871
        x = RGSpace(shape, complexity=2, zerocenter=[True, False],
csongor's avatar
csongor committed
872
                     fft_module=fft_module)
873
        y = RGSpace(shape, complexity=2, zerocenter=[False, True],
874
                     distances=[1, 1], harmonic=True,
csongor's avatar
csongor committed
875
                     fft_module=fft_module)
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
        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
898
899
900
901
902
903
904
905
###############################################################################

    @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
906
                           (True, False), (False, True)]),
Ultima's avatar
Ultima committed
907
908
        testcase_func_name=custom_name_func)
    def test_calc_transform_variations(self, fft_module, shape, zerocenter_in,
csongor's avatar
csongor committed
909
                                       zerocenter_out):
Ultima's avatar
Ultima committed
910
        data = np.arange(np.prod(shape)).reshape(shape)
911
        x = RGSpace(shape, complexity=2, zerocenter=zerocenter_in,
csongor's avatar
csongor committed
912
                     fft_module=fft_module)
Ultima's avatar
Ultima committed
913
914
915
916
917
918
919
920
921
922
923
924
925
        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))

926
927
###############################################################################

csongor's avatar
csongor committed
928
    @parameterized.expand([],testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
929
    def test_calc_smooth(self):
930
931
932
        sigma = 0.01
        shape = (8, 8)
        a = np.arange(np.prod(shape)).reshape(shape)
933
        x = RGSpace(shape)
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
        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
955
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
956
    def test_calc_power(self):
957
958
        shape = (8, 8)
        a = np.arange(np.prod(shape)).reshape(shape)
959
        x = RGSpace(shape)
960
961
962
963
964
        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
965
966
967
968
969
970
971
972
973
974


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

class Test_Lm_Space(unittest.TestCase):

    @parameterized.expand(
        itertools.product([1, 17],
                          [None, 12, 17],
csongor's avatar
csongor committed
975
                          all_lm_datatypes),
Ultima's avatar
Ultima committed
976
        testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
977
978
    def test_successfull_init(self, lmax, mmax, dtype):
        # TODO Look at this
979
        if datamodel in ['not']:
980
            l = LMSpace(lmax, mmax=mmax, dtype=dtype)
981
982
983
984
985
986
987
988
989
            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.harmonic, True)
            assert_equal(l.distances, (np.float(1),))
Ultima's avatar
Ultima committed
990
        else:
991
            with assert_raises(NotImplementedError): LMSpace(lmax, mmax=mmax, dtype=dtype)
992

Ultima's avatar
Ultima committed
993
994
995
996
997
998

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

    def test_para(self):
        lmax = 17
        mmax = 12
999
        l = LMSpace(lmax, mmax=mmax)
Ultima's avatar
Ultima committed
1000
1001
1002
1003
1004
1005
1006
1007
1008
        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
1009
        l = LMSpace(lmax, mmax=mmax)
Ultima's avatar
Ultima committed
1010

1011
1012
1013
1014
        assert_equal(l.shape, (156,))
        assert_equal(l.dof, 294)
        assert_equal(l.meta_volume, 294.)
        assert_equal(l.meta_volume_split,
Ultima's avatar
Ultima committed
1015
1016
1017
1018
1019
                     l.cast(np.concatenate([np.ones(18), np.ones(138)*2])))

    def test_cast(self):
        lmax = 17
        mmax = 12
1020
        l = LMSpace(lmax, mmax=mmax)
Ultima's avatar
Ultima committed
1021
1022
1023
1024
1025
1026
1027

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

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

csongor's avatar
csongor committed
1028
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
1029
    def test_enforce_power(self):
Ultima's avatar
Ultima committed
1030
1031
        lmax = 17
        mmax = 12
csongor's avatar
csongor committed
1032
        # TODO Look at this
1033
        if datamodel in ['not']:
1034
            l = LMSpace(lmax, mmax=mmax, datamodel=datamodel)
1035
1036
1037
1038
1039
1040
1041
1042
1043
1044
1045
1046

            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:
1047
            with assert_raises(NotImplementedError): LMSpace(lmax, mmax=mmax, datamodel=datamodel)
Ultima's avatar
Ultima committed
1048
1049
1050

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

csongor's avatar
csongor committed
1051
    @parameterized.expand([], testcase_func_name=custom_name_func)
csongor's avatar
csongor committed
1052
    def test_get_check_codomain(self):
Ultima's avatar
Ultima committed
1053
1054
        lmax = 23
        mmax = 23
csongor's avatar
csongor committed
1055
        # TODO Look at this