function test_suite = test_chunkize
% tests for cosmo_chunkize
%
% # 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_chunkize_basis
ds=cosmo_synthetic_dataset('type','timelock','nreps',8);
ds.sa.chunks=reshape(repmat((1:8),6,1),[],1);
ds=cosmo_slice(ds,randperm(48));
chunks=cosmo_chunkize(ds,8);
assertEqual(chunks,ds.sa.chunks);
for j=1:2:7
chunks=cosmo_chunkize(ds,j);
eq_chunks=bsxfun(@eq,chunks,chunks');
eq_ds=bsxfun(@eq,ds.sa.chunks,ds.sa.chunks');
m=eq_ds & ~eq_chunks;
assert(~any(m(:)));
end
assertExceptionThrown(@()cosmo_chunkize(ds,9),'');
ds=rmfield(ds.sa,'chunks');
assertExceptionThrown(@()cosmo_chunkize(ds,2),'');
function test_chunkize_imbalance()
ds=struct();
ds.samples=(1:5)';
assertExceptionThrown(@()cosmo_chunkize(ds,2),'');
ds.sa.chunks=2+[1 1 2 2 2]';
assertExceptionThrown(@()cosmo_chunkize(ds,2),'');
ds.sa.targets=10+[1 2 1 2 2]';
assertExceptionThrown(@()cosmo_chunkize(ds,3),'');
count=2;
res=cosmo_chunkize(ds,count);
assert_chunkize_ok(ds,res,count);
ds2=cosmo_stack({ds,ds});
res2=cosmo_chunkize(ds2,count);
assert_chunkize_ok(ds2,res2,count);
function test_all_unique_chunks_tiny()
ds=struct();
ds.samples=(1:5)';
ds.sa.targets=2+[1 1 2 2 2]';
ds.sa.chunks=10+[1 2 3 4 5]';
for count=2:5
res=cosmo_chunkize(ds,count);
assert_chunkize_ok(ds,res,count);
end
assertExceptionThrown(@()cosmo_chunkize(ds,6),'');
function test_chunkize_very_unbalanced_chunks_big()
% all chunks are unique, want a similar number of targets in each
% output chunk
ds=cosmo_synthetic_dataset('nreps',6,'ntargets',5);
nsamples=size(ds.samples,1);
ds.sa.chunks(:)=repmat((1:nsamples/10),1,10);
n_combis=max(ds.sa.chunks)*max(ds.sa.targets);
targets=ds.sa.targets;
n_swap=5;
while true
rp=randperm(nsamples);
ds.sa.targets=targets;
ds.sa.targets(rp(1:n_swap))=ds.sa.targets(rp(n_swap:-1:1));
idxs=cosmo_index_unique({ds.sa.targets,ds.sa.chunks});
n=cellfun(@numel,idxs);
if min(n)>=1 && max(n)<=3 && std(n)<.1 && numel(n)==n_combis
% not too unbalanced
break;
end
end
nchunks=ceil(3+rand()*4);
res=cosmo_chunkize(ds,nchunks);
assert_chunkize_ok(ds,res,nchunks);
function test_chunkize_slight_unbalanced_chunks_big()
% all chunks are unique, want a similar number of targets in each
% output chunk
ds=cosmo_synthetic_dataset('nreps',6,'ntargets',5);
nsamples=size(ds.samples,1);
ds.sa.chunks(:)=repmat((1:nsamples/2),1,2);
ds.sa.targets(1:5)=ds.sa.targets(2:6); % slight imbalance
nchunks=ceil(rand()*5);
res=cosmo_chunkize(ds,nchunks);
assert_chunkize_ok(ds,res,nchunks);
function test_chunkize_all_unique_independent_chunks()
% each sample has its own unique chunk value
ds=cosmo_synthetic_dataset('ntargets',2,'nchunks',6*6);
nsamples=size(ds.samples,1);
ds.sa.chunks(:)=ceil(rand()*10)+(1:nsamples);
ds.sa.targets=ds.sa.targets(randperm(nsamples));
nchunks_candidates=[1 2 3 4 6 12 18];
for nchunks=nchunks_candidates
chunks=cosmo_chunkize(ds,nchunks);
assert_chunkize_ok(ds,chunks,nchunks);
idxs=cosmo_index_unique([ds.sa.targets chunks]);
n=cellfun(@numel,idxs);
% require full balance
assert(all(n(1)==n(2:end)));
end
function test_chunkize_dependent_balanced_chunks()
% each combination of chunks and targets occurs equally often
ntargets=ceil(2+rand()*4);
nreps=ceil(2+rand()*4);
nchunks=36;
ds=cosmo_synthetic_dataset('ntargets',ntargets,...
'nchunks',nchunks,'nreps',nreps);
nsamples=size(ds.samples,1);
ds=cosmo_slice(ds,randperm(nsamples));
rep_idxs=cosmo_index_unique({ds.sa.chunks,ds.sa.targets});
assert(all(cellfun(@numel,rep_idxs)==nreps));
nchunks_candidates=[1 2 3 4 6 12 18];
for nchunks=nchunks_candidates
chunks=cosmo_chunkize(ds,nchunks);
assert_chunkize_ok(ds,chunks,nchunks);
idxs=cosmo_index_unique([ds.sa.targets chunks]);
n=cellfun(@numel,idxs);
% require full balance
assert(all(n(1)==n(2:end)));
end
function assert_chunkize_ok(src_ds,chunks,count)
% number of items must match input dataset
assertEqual(numel(src_ds.sa.chunks),numel(chunks));
% must be balanced
assert_chunks_targets_balanced(src_ds,chunks);
% cannot have double dipping
assert_no_double_dipping(src_ds,chunks);
% must have the proper number of chunks
assertEqual(numel(unique(chunks)),count);
assert_chunks_targets_nonzero(src_ds,chunks);
function assert_chunks_targets_balanced(src_ds,chunks)
idxs=cosmo_index_unique([src_ds.sa.targets chunks]);
n=cellfun(@numel,idxs);
% cannot test for 'optimal' balance due to combinatorial explosion;
% this is a decent approach to make sure that chunks are not too
% imbalanced
assert(std(n)<=1.5);
assert(min(n)+2>=max(n));
function assert_chunks_targets_nonzero(src_ds,chunks)
[unused,unused,t_idxs]=unique(src_ds.sa.targets);
[unused,unused,c_idxs]=unique(chunks);
nt=max(t_idxs);
nc=max(c_idxs);
h=zeros(nt,nc);
ns=numel(chunks);
for k=1:ns
t=t_idxs(k);
c=c_idxs(k);
h(t,c)=h(t,c)+1;
end
assert(all(max(h,[],1)>0));
assert(all(max(h,[],2)>0));
function assert_no_double_dipping(src_ds,chunks)
% samples that were in different chunks in src_ds must not be in the
% same chunk in trg_ds
[unq_src,unused,src_ids]=unique(src_ds.sa.chunks);
[unq_trg,unused,trg_ids]=unique(chunks);
n_src=numel(unq_src);
n_trg=numel(unq_trg);
n_samples=numel(src_ds.sa.chunks);
chunk_count=zeros(n_src,n_trg);
for k=1:n_samples
i=src_ids(k);
j=trg_ids(k);
chunk_count(i,j)=chunk_count(i,j)+1;
end
assert(all(sum(chunk_count>0,2)==1));
