function test_suite = test_cross_neighborhood()
% tests for cosmo_cross_neighborhood
%
% # For CoSMoMVPA's copyright information and license terms, #
% # see the COPYING file distributed with CoSMoMVPA. #
try % assignment of 'localfunctions' is necessary in Matlab >= 2016
test_functions = localfunctions();
catch % no problem; early Matlab versions can use initTestSuite fine
end
initTestSuite;
function test_cross_neighborhood_time_freq()
helper_test_cross_neighborhood(false);
function test_cross_neighborhood_chan_time_freq()
if cosmo_skip_test_if_no_external('fieldtrip')
return
end
helper_test_cross_neighborhood(true);
function helper_test_cross_neighborhood(can_use_chan_nbrhood)
ds_full = cosmo_synthetic_dataset('type', 'timefreq', 'size', 'big');
msk = cosmo_match(ds_full.fa.chan, @(x)x < 20);
ds_full = cosmo_slice(ds_full, msk, 2);
ds_full = cosmo_dim_prune(ds_full);
% make it sparse
nfeatures = size(ds_full.samples, 2);
nkeep = round(nfeatures / 4);
fdim_values = ds_full.a.fdim.values;
nchan = numel(fdim_values{1});
nfreq = numel(fdim_values{2});
ntime = numel(fdim_values{3});
while true
rp = randperm(nfeatures);
ds = cosmo_slice(ds_full, rp(1:nkeep), 2);
ds = cosmo_dim_prune(ds);
n = numel(ds.a.fdim.values{1});
ds.a.fdim.values{1} = ds.a.fdim.values{1}(randperm(n));
if numel(unique(ds.fa.chan)) == nchan && ...
numel(unique(ds.fa.freq)) == nfreq && ...
numel(unique(ds.fa.time)) == ntime
break
end
end
nfeatures = size(ds.samples, 2);
% define neighborhoods
freq_nbrhood = cosmo_interval_neighborhood(ds, 'freq', 'radius', 2);
time_nbrhood = cosmo_interval_neighborhood(ds, 'time', 'radius', 1);
if can_use_chan_nbrhood
chan_nbrhood = cosmo_meeg_chan_neighborhood(ds, 'count', 5, ...
'chantype', 'all', 'label', 'dataset');
else
chan_nbrhood = 'dummy';
end
all_nbrhoods = {chan_nbrhood, freq_nbrhood, time_nbrhood};
ndim = numel(all_nbrhoods);
dim_labels = {'chan'; 'freq'; 'time'};
ntest = 5; % number of positions to test
for i = 7:-1:1
use_chan = i <= 4;
use_freq = mod(i, 2) == 1;
use_time = mod(ceil(i / 2), 2) == 1;
if ~can_use_chan_nbrhood && use_chan
% no support for channel neighborhood, skip
continue
end
use_dim_msk = [use_chan; use_freq; use_time];
nbrhood = cosmo_cross_neighborhood(ds, all_nbrhoods(use_dim_msk), ...
'progress', false);
assertEqual(nbrhood.a.fdim.labels, dim_labels(use_dim_msk));
assertEqual(fieldnames(nbrhood.fa), dim_labels(use_dim_msk));
n = numel(nbrhood.neighbors);
rp = randperm(n);
for iter = 1:min(n, ntest)
pos = rp(iter);
% verify neighborhoods in ds
ds_fa = cosmo_slice(ds.fa, nbrhood.neighbors{pos}, 2, 'struct');
nbr_fa = cosmo_slice(nbrhood.fa, pos, 2, 'struct');
nbr_msk = true(1, nfeatures);
for dim = 1:ndim
dim_label = dim_labels{dim};
if use_dim_msk(dim)
dim_nbrhood = all_nbrhoods{dim};
j = find(dim_nbrhood.fa.(dim_label) == nbr_fa.(dim_label));
assert(numel(j) == 1);
m = false(1, nfeatures);
m(dim_nbrhood.neighbors{j}) = true;
else
assert(~isfield(nbrhood.fa, dim_label));
m = true(1, nfeatures);
end
nbr_msk = nbr_msk & m;
fa = cosmo_slice(ds.fa.(dim_label), m, 2);
assert(isempty(setdiff(ds_fa.(dim_label), fa)));
end
assertEqual(nbrhood.neighbors{pos}, find(nbr_msk));
% test agreement between the crossed nbrhood and the
% individual neighborhoods
dim_nbr_msk = true(1, nfeatures);
dim_pos = 0;
for dim = 1:ndim
if ~use_dim_msk(dim)
continue
end
dim_pos = dim_pos + 1;
dim_label = dim_labels{dim};
nbr_fa = nbrhood.fa.(dim_label);
nbr_values = nbrhood.a.fdim.values{dim_pos}(nbr_fa(pos));
dim_nbrhood = all_nbrhoods{dim};
dim_nbr_values = dim_nbrhood.a.fdim.values{1};
nbr_msk = cosmo_match(dim_nbr_values, nbr_values);
m = false(size(dim_nbr_msk));
m(dim_nbrhood.neighbors{nbr_msk}) = true;
dim_nbr_msk = dim_nbr_msk & m;
end
assertEqual(nbrhood.neighbors{pos}, find(dim_nbr_msk));
end
end
function test_cross_neighborhood_transpose
opt = struct();
opt.progress = false;
ds = cosmo_synthetic_dataset('type', 'timefreq', 'size', 'normal');
ds = cosmo_dim_remove(ds, 'chan');
nh_time = cosmo_interval_neighborhood(ds, 'time', 'radius', 1);
nh_freq = cosmo_interval_neighborhood(ds, 'freq', 'radius', 0);
nh = cosmo_cross_neighborhood(ds, {nh_freq, nh_time}, opt);
cp = cosmo_cartprod(repmat({[false, true]}, 4, 1));
n = size(cp, 1);
for k = 1:n
t_label = cp{k, 1};
t_value = cp{k, 2};
t_elem1 = cp{k, 3};
t_elem2 = cp{k, 4};
ds2 = ds;
if t_label
ds2.a.fdim.labels = ds2.a.fdim.labels';
end
if t_value
ds2.a.fdim.values = ds2.a.fdim.values';
end
if t_elem1
ds2.a.fdim.values{1} = ds2.a.fdim.values{1}';
end
if t_elem2
ds2.a.fdim.values{2} = ds2.a.fdim.values{2}';
end
nh2_time = cosmo_interval_neighborhood(ds2, 'time', 'radius', 1);
nh2_freq = cosmo_interval_neighborhood(ds2, 'freq', 'radius', 0);
nh2 = cosmo_cross_neighborhood(ds2, {nh2_freq, nh2_time}, opt);
assertEqual(nh2.a, nh.a);
assertEqual(nh2.fa, nh.fa);
assertEqual(nh2.neighbors, nh.neighbors);
end
function test_cross_neighborhood_exceptions()
ds = cosmo_synthetic_dataset('type', 'meeg', 'size', 'big');
time_nbrhood = cosmo_interval_neighborhood(ds, 'time', 'radius', 1);
% test exceptions
aet = @(varargin)assertExceptionThrown(@() ...
cosmo_cross_neighborhood(varargin{:}), '');
aet(ds, {});
aet(ds, struct);
aet(ds, struct, time_nbrhood);
aet(ds, time_nbrhood, time_nbrhood);
aet(ds, ds);
% should be fine
assertEqual(cosmo_cross_neighborhood(ds, {time_nbrhood}), time_nbrhood);
% no values too big
time_nbrhood2 = time_nbrhood;
time_nbrhood2.neighbors{1} = 1e9;
aet(ds, {time_nbrhood2});
% non-integers not supported
time_nbrhood2 = time_nbrhood;
time_nbrhood2.neighbors{1} = 1.5;
aet(ds, {time_nbrhood2});
% illegal labels
time_nbrhood2 = time_nbrhood;
time_nbrhood2.a.fdim.labels{1} = 'foo';
time_nbrhood2.fa.foo = time_nbrhood.fa.time;
aet(ds, {time_nbrhood2});
% duplicate labels
aet(ds, {time_nbrhood, time_nbrhood});
function test_cross_neighborhood_unsorted_neighbors
ds = cosmo_synthetic_dataset();
nh = cosmo_interval_neighborhood(ds, 'i', 'radius', 1);
nh_unsorted = nh;
nh_unsorted.neighbors = cellfun(@(x)x(randperm(numel(x))), ...
nh_unsorted.neighbors, ...
'UniformOutput', false);
assertEqual(nh, cosmo_cross_neighborhood(ds, {nh_unsorted}));
function test_cross_neighborhood_progress()
if cosmo_skip_test_if_no_external('!evalc')
return
end
ds = cosmo_synthetic_dataset();
nh1 = cosmo_interval_neighborhood(ds, 'i', 'radius', 0);
nh2 = cosmo_interval_neighborhood(ds, 'j', 'radius', 0);
f = @()cosmo_cross_neighborhood(ds, {nh1, nh2});
res = evalc('f();');
assert(~isempty(strfind(res, '[####################]')));
assert(~isempty(strfind(res, 'crossing neighborhoods')));
function test_warning_weird_dimension_order
if cosmo_skip_test_if_no_external('fieldtrip')
return
end
ds = cosmo_synthetic_dataset('type', 'timefreq', 'size', 'big');
keep = ds.fa.chan < 20;
ds = cosmo_slice(ds, keep, 2);
ds = cosmo_dim_prune(ds);
nh_time = cosmo_interval_neighborhood(ds, 'time', 'radius', 0);
nh_freq = cosmo_interval_neighborhood(ds, 'freq', 'radius', 0);
nh_chan = cosmo_meeg_chan_neighborhood(ds, 'count', 4, ...
'chantype', 'meg_planar', ...
'label', 'dataset');
nh_cell = {nh_chan, nh_freq, nh_time};
for ndim = 1:3
idxs = nchoosek(1:3, ndim);
order = perms(1:ndim);
for k = 1:size(idxs, 1)
for j = 1:size(order, 1)
idx = idxs(k, order(j, :));
nh_sel = nh_cell(idx);
is_weird_order = ~issorted(idx);
func = @()cosmo_cross_neighborhood(ds, nh_sel, ...
'progress', false);
assert_warning_being_shown(func, is_weird_order);
end
end
end
function assert_warning_being_shown(func, flag)
warning_state = cosmo_warning();
cleaner = onCleanup(@()cosmo_warning(warning_state));
cosmo_warning('reset');
cosmo_warning('off');
% initially must be empty
s = cosmo_warning();
assertEqual(s.shown_warnings, {});
func();
s = cosmo_warning();
if flag
% must have warning added
assertTrue(iscellstr(s.shown_warnings));
assertTrue(numel(s.shown_warnings) > 0);
else
% still without warning
assertEqual(s.shown_warnings, {});
end
