def test_ipfp_no_values_no_name(self):
r = ipfp([[6, 12, 18], [6, 12, 18]])
assert_array_equal(r,
[[1.0, 2.0, 3.0], [2.0, 4.0, 6.0], [3.0, 6.0, 9.0]])
r = ipfp([[2, 1], [1, 2]])
assert_array_equal(r, [[2 / 3, 1 / 3], [4 / 3, 2 / 3]])
def test_ipfp_non_larray(self):
initial = [[2, 1], [1, 2]]
# sums already correct
r = ipfp([[3, 3], [3, 3]], initial)
assert_array_equal(r, [[2, 1], [1, 2]])
# different sums (ie the usual case)
r = ipfp([[2, 1], [1, 2]], initial)
assert_array_equal(r, [[0.8, 0.2], [1.0, 1.0]])
def test_ipfp_no_values():
# 6, 12, 18
along_a = ndtest([(3, 'b')], start=1) * 6
# 6, 12, 18
along_b = ndtest([(3, 'a')], start=1) * 6
r = ipfp([along_a, along_b])
assert_array_equal(r, [[1.0, 2.0, 3.0], [2.0, 4.0, 6.0], [3.0, 6.0, 9.0]])
along_a = Array([2, 1], Axis(2, 'b'))
along_b = Array([1, 2], Axis(2, 'a'))
r = ipfp([along_a, along_b])
assert_array_equal(r, [[2 / 3, 1 / 3], [4 / 3, 2 / 3]])
def test_ipfp_no_name(self):
initial = LArray([[2, 1], [1, 2]])
# sums already correct
# [3, 3], [3, 3]
r = ipfp([initial.sum(axis=0), initial.sum(axis=1)], initial)
assert_array_equal(r, [[2, 1], [1, 2]])
# different sums (ie the usual case)
along_a = LArray([2, 1])
along_b = LArray([1, 2])
r = ipfp([along_a, along_b], initial)
assert_array_equal(r, [[0.8, 0.2], [1.0, 1.0]])
def test_ipfp_3d(self):
initial = ndtest((2, 2, 2))
initial_axes = initial.axes
# array sums already match target sums
targets = [initial.sum(axis) for axis in initial.axes]
r = ipfp(targets, initial)
assert_array_equal(r, initial)
self.assertEqual(r.axes, initial_axes)
# array sums do not match target sums (ie the usual case)
targets = [initial.sum(axis) + 1 for axis in initial.axes]
r = ipfp(targets, initial)
assert_array_equal(
r, [[[0.0, 2.0], [2.688963210702341, 3.311036789297659]],
[[4.551453540217585, 5.448546459782415],
[6.450132391879964, 7.549867608120035]]])
self.assertEqual(r.axes, initial_axes)
# same as above but using a more precise threshold
r = ipfp(targets, initial, threshold=0.01)
assert_array_equal(r, [[[0.0, 1.9999999999999998],
[2.994320023433978, 3.0056799765660225]],
[[4.990248916408187, 5.009751083591813],
[6.009541632308118, 7.990458367691883]]])
self.assertEqual(r.axes, initial_axes)
def test_ipfp(self):
a = Axis(2, 'a')
b = Axis(2, 'b')
initial = LArray([[2, 1], [1, 2]], [a, b])
# array sums already match target sums
# [3, 3], [3, 3]
r = ipfp([initial.sum(a), initial.sum(b)], initial)
assert_array_equal(r, [[2, 1], [1, 2]])
# array sums do not match target sums (ie the usual case)
along_a = LArray([2, 1], b)
along_b = LArray([1, 2], a)
r = ipfp([along_a, along_b], initial)
assert_array_equal(r, [[0.8, 0.2], [1.0, 1.0]])
# same as above but using a more precise threshold
r = ipfp([along_a, along_b], initial, threshold=0.01)
assert_array_equal(r, [[0.8450704225352113, 0.15492957746478875],
[1.1538461538461537, 0.8461538461538463]])
# inverted target sums
with self.assertRaisesRegexp(
ValueError,
"axes of target sum along axis 0 \(a\) do not match corresponding "
"array axes: got {a\*} but expected {b\*}. Are the target sums in the "
"correct order\?"):
ipfp([along_b, along_a], initial, threshold=0.01)
def test_combine(col):
res = col.combine_axes((lipro, sex))
assert res.names == ['lipro_sex', 'age']
assert res.size == col.size
assert res.shape == (4 * 2, 8)
print(res.info)
assert_array_equal(res.lipro_sex.labels[0], 'P01_M')
res = col.combine_axes((lipro, age))
assert res.names == ['lipro_age', 'sex']
assert res.size == col.size
assert res.shape == (4 * 8, 2)
assert_array_equal(res.lipro_age.labels[0], 'P01_0')
res = col.combine_axes((sex, age))
assert res.names == ['lipro', 'sex_age']
assert res.size == col.size
assert res.shape == (4, 2 * 8)
assert_array_equal(res.sex_age.labels[0], 'M_0')
def test_combine(col):
res = col.combine_axes((lipro, sex))
assert res.names == ['lipro_sex', 'age']
assert res.size == col.size
assert res.shape == (4 * 2, 8)
print(res.info)
assert_array_equal(res.lipro_sex.labels[0], 'P01_M')
res = col.combine_axes((lipro, age))
assert res.names == ['lipro_age', 'sex']
assert res.size == col.size
assert res.shape == (4 * 8, 2)
assert_array_equal(res.lipro_age.labels[0], 'P01_0')
res = col.combine_axes((sex, age))
assert res.names == ['lipro', 'sex_age']
assert res.size == col.size
assert res.shape == (4, 2 * 8)
assert_array_equal(res.sex_age.labels[0], 'M_0')
def test_combine(self):
col = self.collection.copy()
lipro, sex, age = self.lipro, self.sex, self.age
res = col.combine_axes((lipro, sex))
self.assertEqual(res.names, ['lipro_sex', 'age'])
self.assertEqual(res.size, col.size)
self.assertEqual(res.shape, (4 * 2, 8))
print(res.info)
assert_array_equal(res.lipro_sex.labels[0], 'P01_M')
res = col.combine_axes((lipro, age))
self.assertEqual(res.names, ['lipro_age', 'sex'])
self.assertEqual(res.size, col.size)
self.assertEqual(res.shape, (4 * 8, 2))
assert_array_equal(res.lipro_age.labels[0], 'P01_0')
res = col.combine_axes((sex, age))
self.assertEqual(res.names, ['lipro', 'sex_age'])
self.assertEqual(res.size, col.size)
self.assertEqual(res.shape, (4, 2 * 8))
assert_array_equal(res.sex_age.labels[0], 'M_0')
def test_ipfp(self):
a = Axis('a=a0,a1')
b = Axis('b=b0,b1')
initial = LArray([[2, 1], [1, 2]], [a, b])
# array sums already match target sums
# [3, 3], [3, 3]
r = ipfp([initial.sum(a), initial.sum(b)], initial)
assert_array_equal(r, initial)
# array sums do not match target sums (ie the usual case)
along_a = LArray([2, 1], b)
along_b = LArray([1, 2], a)
r = ipfp([along_a, along_b], initial)
assert_array_equal(r, [[0.8, 0.2], [1.0, 1.0]])
# same as above but using a more precise threshold
r = ipfp([along_a, along_b], initial, threshold=0.01)
assert_array_equal(r, [[0.8450704225352113, 0.15492957746478875],
[1.1538461538461537, 0.8461538461538463]])
# inverted target sums
with self.assertRaisesRegexp(
ValueError,
"axes of target sum along a \(axis 0\) do not match corresponding "
"array axes: got {a} but expected {b}. Are the target sums in the "
"correct order\?"):
ipfp([along_b, along_a], initial)
# different target sums totals
along_a = LArray([2, 1], b)
along_b = LArray([1, 3], a)
with self.assertRaisesRegexp(
ValueError,
"target sum along b \(axis 1\) is different than target sum along "
"a \(axis 0\): 4 vs 3"):
ipfp([along_a, along_b], initial)
# all zero values
initial = LArray([[0, 0], [1, 2]], [a, b])
along_a = LArray([2, 1], b)
along_b = LArray([1, 2], a)
with self.assertRaisesRegexp(
ValueError,
"found all zero values sum along b \(axis 1\) but non zero target "
"sum:\na0: 1"):
ipfp([along_a, along_b], initial)
# zero target sum
initial = LArray([[2, 1], [1, 2]], [a, b])
along_a = LArray([0, 1], b)
along_b = LArray([1, 0], a)
with self.assertRaisesRegexp(
ValueError,
"found Non Zero Values but Zero target Sum \(nzvzs\) along a "
"\(axis 0\), use nzvzs='warn' or 'fix' to set them to zero "
"automatically:\nb0: 3"):
ipfp([along_a, along_b], initial)
# negative initial values
initial = LArray([[2, -1], [1, 2]], [a, b])
with self.assertRaisesRegexp(ValueError,
"negative value\(s\) found:\na0_b1: -1"):
ipfp([along_a, along_b], initial)
def test_init_from_group():
lipro_subset = lipro[:'P03']
col2 = AxisCollection((lipro_subset, sex))
assert col2.names == ['lipro', 'sex']
assert_array_equal(col2.lipro.labels, ['P01', 'P02', 'P03'])
assert_array_equal(col2.sex.labels, ['M', 'F'])
def test_init():
axis = Axis(3)
assert len(axis) == 3
assert list(axis.labels) == list(range(3))
axis = Axis(np.int32(3))
assert len(axis) == 3
assert list(axis.labels) == list(range(3))
axis = Axis([0, 1], name='test')
assert axis.name == 'test'
assert_nparray_equal(axis.labels, [0, 1])
axis = Axis([0, 1], name=np.str_('test'))
assert axis.name == 'test'
assert type(axis.name) is not np.str_
assert_nparray_equal(axis.labels, [0, 1])
sex_tuple = ('M', 'F')
sex_list = ['M', 'F']
sex_array = np.array(sex_list)
assert_array_equal(Axis(sex_tuple, 'sex').labels, sex_array)
assert_array_equal(Axis(sex_list, 'sex').labels, sex_array)
assert_array_equal(Axis(sex_array, 'sex').labels, sex_array)
assert_array_equal(Axis('sex=M,F').labels, sex_array)
assert_array_equal(Axis(range(116), 'age').labels, np.arange(116))
axis = Axis('0..115', 'age')
assert_array_equal(axis.labels, np.arange(116))
assert_array_equal(
Axis('01..12', 'zero_padding').labels,
[str(i).zfill(2) for i in range(1, 13)])
assert_array_equal(
Axis('01,02,03,10,11,12', 'zero_padding').labels,
['01', '02', '03', '10', '11', '12'])
group = axis[:10]
group_axis = Axis(group)
assert_array_equal(group_axis.labels, np.arange(11))
assert_array_equal(group_axis.name, 'age')
other = Axis('other=0..10')
axis = Axis(other, 'age')
assert_array_equal(axis.labels, other.labels)
assert_array_equal(axis.name, 'age')
def test_h5_io(tmpdir):
age = Axis('age=0..10')
lipro = Axis('lipro=P01..P05')
anonymous = Axis(range(3))
wildcard = Axis(3, 'wildcard')
string_axis = Axis(['@!àéè&%µ$~', '/*-+_§()><', 'another label'],
'string_axis')
fpath = os.path.join(str(tmpdir), 'axes.h5')
# ---- default behavior ----
# int axis
age.to_hdf(fpath)
age2 = read_hdf(fpath, key=age.name)
assert age.equals(age2)
# string axis
lipro.to_hdf(fpath)
lipro2 = read_hdf(fpath, key=lipro.name)
assert lipro.equals(lipro2)
# anonymous axis
with pytest.raises(
ValueError,
match=
"Argument key must be provided explicitly in case of anonymous axis"
):
anonymous.to_hdf(fpath)
# wildcard axis
wildcard.to_hdf(fpath)
wildcard2 = read_hdf(fpath, key=wildcard.name)
assert wildcard2.iswildcard
assert wildcard.equals(wildcard2)
# string axis
string_axis.to_hdf(fpath)
string_axis2 = read_hdf(fpath, string_axis.name)
assert string_axis.equals(string_axis2)
# ---- specific key ----
# int axis
key = 'axis_age'
age.to_hdf(fpath, key)
age2 = read_hdf(fpath, key=key)
assert age.equals(age2)
# string axis
key = 'axis_lipro'
lipro.to_hdf(fpath, key)
lipro2 = read_hdf(fpath, key=key)
assert lipro.equals(lipro2)
# anonymous axis
key = 'axis_anonymous'
anonymous.to_hdf(fpath, key)
anonymous2 = read_hdf(fpath, key=key)
assert anonymous2.name is None
assert_array_equal(anonymous.labels, anonymous2.labels)
# wildcard axis
key = 'axis_wildcard'
wildcard.to_hdf(fpath, key)
wildcard2 = read_hdf(fpath, key=key)
assert wildcard2.iswildcard
assert wildcard.equals(wildcard2)
# ---- specific hdf group + key ----
hdf_group = 'my_axes'
# int axis
key = hdf_group + '/axis_age'
age.to_hdf(fpath, key)
age2 = read_hdf(fpath, key=key)
assert age.equals(age2)
# string axis
key = hdf_group + '/axis_lipro'
lipro.to_hdf(fpath, key)
lipro2 = read_hdf(fpath, key=key)
assert lipro.equals(lipro2)
# anonymous axis
key = hdf_group + '/axis_anonymous'
anonymous.to_hdf(fpath, key)
anonymous2 = read_hdf(fpath, key=key)
assert anonymous2.name is None
assert_array_equal(anonymous.labels, anonymous2.labels)
# wildcard axis
key = hdf_group + '/axis_wildcard'
wildcard.to_hdf(fpath, key)
wildcard2 = read_hdf(fpath, key=key)
assert wildcard2.iswildcard
assert wildcard.equals(wildcard2)
def test_init_from_group():
code = Axis('code=C01..C03')
code_group = code[:'C02']
subset_axis = Axis(code_group, 'code_subset')
assert_array_equal(subset_axis.labels, ['C01', 'C02'])
def test_asarray_igroup(igroups):
assert_array_equal(np.asarray(igroups.slice_both),
np.array(['a1', 'a2', 'a3']))
def test_init_from_group():
code = Axis('code=C01..C03')
code_group = code[:'C02']
subset_axis = Axis(code_group, 'code_subset')
assert_array_equal(subset_axis.labels, ['C01', 'C02'])
def test_init():
axis = Axis(3)
assert len(axis) == 3
assert list(axis.labels) == list(range(3))
axis = Axis(np.int32(3))
assert len(axis) == 3
assert list(axis.labels) == list(range(3))
sex_tuple = ('M', 'F')
sex_list = ['M', 'F']
sex_array = np.array(sex_list)
assert_array_equal(Axis(sex_tuple, 'sex').labels, sex_array)
assert_array_equal(Axis(sex_list, 'sex').labels, sex_array)
assert_array_equal(Axis(sex_array, 'sex').labels, sex_array)
assert_array_equal(Axis('sex=M,F').labels, sex_array)
assert_array_equal(Axis(range(116), 'age').labels, np.arange(116))
axis = Axis('0..115', 'age')
assert_array_equal(axis.labels, np.arange(116))
assert_array_equal(Axis('01..12', 'zero_padding').labels, [str(i).zfill(2) for i in range(1, 13)])
assert_array_equal(Axis('01,02,03,10,11,12', 'zero_padding').labels, ['01', '02', '03', '10', '11', '12'])
group = axis[:10]
group_axis = Axis(group)
assert_array_equal(group_axis.labels, np.arange(11))
assert_array_equal(group_axis.name, 'age')
other = Axis('other=0..10')
axis = Axis(other, 'age')
assert_array_equal(axis.labels, other.labels)
assert_array_equal(axis.name, 'age')
def test_asarray(self):
assert_array_equal(np.asarray(self.slice_both_named_wh_named_axis), np.array([1, 2, 3, 4, 5]))
assert_array_equal(np.asarray(self.slice_none_wh_named_axis), np.array(['P01', 'P02', 'P03', 'P04', 'P05']))
def test_asarray_lgroup(lgroups):
assert_array_equal(np.asarray(lgroups.slice_both_named_wh_named_axis), np.array([1, 2, 3, 4, 5]))
assert_array_equal(np.asarray(lgroups.slice_none_wh_named_axis), np.array(['P01', 'P02', 'P03', 'P04', 'P05']))
def test_ipfp_3d_with_axes(self):
initial = ndtest((2, 2, 2))
initial_axes = initial.axes
# array sums already match target sums (first axes)
axes = (X.a, X.b)
targets = [initial.sum(axis) for axis in axes]
r = ipfp(targets, initial, axes=axes)
assert_array_equal(r, initial)
self.assertEqual(r.axes, initial_axes)
# array sums already match target sums (other axes)
axes = (X.a, X.c)
targets = [initial.sum(axis) for axis in axes]
r = ipfp(targets, initial, axes=axes)
assert_array_equal(r, initial)
self.assertEqual(r.axes, initial_axes)
# array sums do not match target sums (ie the usual case) (first axes)
axes = (X.a, X.b)
targets = [initial.sum(axis) + 1 for axis in axes]
r = ipfp(targets, initial, axes=axes)
assert_array_equal(
r, [[[0.0, 1.3059701492537312], [3.0, 3.6940298507462686]],
[[4.680851063829787, 5.603448275862069],
[6.319148936170213, 7.3965517241379315]]])
self.assertEqual(r.axes, initial_axes)
# check that the result is the same as N 2D ipfp calls
assert_array_equal(r['c0'],
ipfp([t['c0'] for t in targets], initial['c0']))
assert_array_equal(r['c1'],
ipfp([t['c1'] for t in targets], initial['c1']))
# array sums do not match target sums (ie the usual case) (other axes)
axes = (X.a, X.c)
targets = [initial.sum(axis) + 1 for axis in axes]
r = ipfp(targets, initial, axes=axes)
assert_array_equal(
r, [[[0.0, 2.0], [2.432432432432432, 3.567567567567567]],
[[4.615384615384615, 5.384615384615385],
[6.539792387543252, 7.460207612456748]]])
self.assertEqual(r.axes, initial_axes)
# check that the result is the same as N 2D ipfp calls
assert_array_equal(r['b0'],
ipfp([t['b0'] for t in targets], initial['b0']))
assert_array_equal(r['b1'],
ipfp([t['b1'] for t in targets], initial['b1']))
def test_init_from_group():
lipro_subset = lipro[:'P03']
col2 = AxisCollection((lipro_subset, sex))
assert col2.names == ['lipro', 'sex']
assert_array_equal(col2.lipro.labels, ['P01', 'P02', 'P03'])
assert_array_equal(col2.sex.labels, ['M', 'F'])
def test_init(self):
sex_tuple = ('M', 'F')
sex_list = ['M', 'F']
sex_array = np.array(sex_list)
# wildcard axis
axis = Axis(10, 'axis')
assert len(axis) == 10
assert list(axis.labels) == list(range(10))
# tuple of strings
assert_array_equal(Axis(sex_tuple, 'sex').labels, sex_array)
# list of strings
assert_array_equal(Axis(sex_list, 'sex').labels, sex_array)
# array of strings
assert_array_equal(Axis(sex_array, 'sex').labels, sex_array)
# single string
assert_array_equal(Axis('sex=M,F').labels, sex_array)
# list of ints
assert_array_equal(Axis(range(116), 'age').labels, np.arange(116))
# range-string
axis = Axis('0..115', 'age')
assert_array_equal(axis.labels, np.arange(116))
# another axis group
group = axis[:10]
group_axis = Axis(group)
assert_array_equal(group_axis.labels, np.arange(11))
assert_array_equal(group_axis.name, 'age')
# another axis as labels argument
other = Axis('other=0..10')
axis = Axis(other, 'age')
assert_array_equal(axis.labels, other.labels)
assert_array_equal(axis.name, 'age')
def test_asarray_igroup(igroups):
assert_array_equal(np.asarray(igroups.slice_both), np.array(['a1', 'a2', 'a3']))
def test_init(self):
sex_tuple = ('M', 'F')
sex_list = ['M', 'F']
sex_array = np.array(sex_list)
# tuple of strings
assert_array_equal(Axis(sex_tuple, 'sex').labels, sex_array)
# list of strings
assert_array_equal(Axis(sex_list, 'sex').labels, sex_array)
# array of strings
assert_array_equal(Axis(sex_array, 'sex').labels, sex_array)
# single string
assert_array_equal(Axis('sex=M,F').labels, sex_array)
# list of ints
assert_array_equal(Axis(range(116), 'age').labels, np.arange(116))
# range-string
axis = Axis('0..115', 'age')
assert_array_equal(axis.labels, np.arange(116))
# another axis group
group = axis[:10]
group_axis = Axis(group)
assert_array_equal(group_axis.labels, np.arange(11))
assert_array_equal(group_axis.name, 'age')
def test_asarray(self):
assert_array_equal(np.asarray(self.slice_both), np.array(['a1', 'a2', 'a3']))
def test_h5_io(tmpdir):
age = Axis('age=0..10')
lipro = Axis('lipro=P01..P05')
anonymous = Axis(range(3))
wildcard = Axis(3, 'wildcard')
fpath = os.path.join(str(tmpdir), 'axes.h5')
# ---- default behavior ----
# int axis
age.to_hdf(fpath)
age2 = read_hdf(fpath, key=age.name)
assert age.equals(age2)
# string axis
lipro.to_hdf(fpath)
lipro2 = read_hdf(fpath, key=lipro.name)
assert lipro.equals(lipro2)
# anonymous axis
with pytest.raises(ValueError, message="Argument key must be provided explicitly in case of anonymous axis"):
anonymous.to_hdf(fpath)
# wildcard axis
wildcard.to_hdf(fpath)
wildcard2 = read_hdf(fpath, key=wildcard.name)
assert wildcard2.iswildcard
assert wildcard.equals(wildcard2)
# ---- specific key ----
# int axis
key = 'axis_age'
age.to_hdf(fpath, key)
age2 = read_hdf(fpath, key=key)
assert age.equals(age2)
# string axis
key = 'axis_lipro'
lipro.to_hdf(fpath, key)
lipro2 = read_hdf(fpath, key=key)
assert lipro.equals(lipro2)
# anonymous axis
key = 'axis_anonymous'
anonymous.to_hdf(fpath, key)
anonymous2 = read_hdf(fpath, key=key)
assert anonymous2.name is None
assert_array_equal(anonymous.labels, anonymous2.labels)
# wildcard axis
key = 'axis_wildcard'
wildcard.to_hdf(fpath, key)
wildcard2 = read_hdf(fpath, key=key)
assert wildcard2.iswildcard
assert wildcard.equals(wildcard2)
# ---- specific hdf group + key ----
hdf_group = 'my_axes'
# int axis
key = hdf_group + '/axis_age'
age.to_hdf(fpath, key)
age2 = read_hdf(fpath, key=key)
assert age.equals(age2)
# string axis
key = hdf_group + '/axis_lipro'
lipro.to_hdf(fpath, key)
lipro2 = read_hdf(fpath, key=key)
assert lipro.equals(lipro2)
# anonymous axis
key = hdf_group + '/axis_anonymous'
anonymous.to_hdf(fpath, key)
anonymous2 = read_hdf(fpath, key=key)
assert anonymous2.name is None
assert_array_equal(anonymous.labels, anonymous2.labels)
# wildcard axis
key = hdf_group + '/axis_wildcard'
wildcard.to_hdf(fpath, key)
wildcard2 = read_hdf(fpath, key=key)
assert wildcard2.iswildcard
assert wildcard.equals(wildcard2)
