static double bench_wavelet_thresh(int version, long scale)
{
long dims[DIMS] = { 1, 256 * scale, 256 * scale, 1, 16, 1, 1, 1 };
long minsize[DIMS] = { [0 ... DIMS - 1] = 1 };
minsize[0] = MIN(dims[0], 16);
minsize[1] = MIN(dims[1], 16);
minsize[2] = MIN(dims[2], 16);
const struct operator_p_s* p;
switch (version) {
case 2:
p = prox_wavethresh_create(DIMS, dims, 7, minsize, 1.1, true, false);
break;
case 3:
p = prox_wavelet3_thresh_create(DIMS, dims, 6, minsize, 1.1, true);
break;
default:
assert(0);
}
complex float* x = md_alloc(DIMS, dims, CFL_SIZE);
md_gaussian_rand(DIMS, dims, x);
double tic = timestamp();
operator_p_apply(p, 0.98, DIMS, dims, x, DIMS, dims, x);
double toc = timestamp();
md_free(x);
operator_p_free(p);
return toc - tic;
}
/**
* Free the linear operator and associated data,
* Note: only frees the data if its reference count is zero
*
* @param op linear operator
*/
void linop_free(const struct linop_s* op)
{
operator_free(op->forward);
operator_free(op->adjoint);
operator_free(op->normal);
operator_p_free(op->norm_inv);
free((void*)op);
}
static void lrthresh(unsigned int D, const long dims[D], int llrblk, float lambda, unsigned int flags, complex float* out, const complex float* in)
{
long blkdims[MAX_LEV][D];
int levels = llr_blkdims(blkdims, ~flags, dims, llrblk);
UNUSED(levels);
const struct operator_p_s* p = lrthresh_create(dims, false, ~flags, (const long (*)[])blkdims, lambda, false, false);
operator_p_apply(p, 1., D, dims, out, D, dims, in);
operator_p_free(p);
}
static void prox_4pt_dfwavelet_del(const operator_data_t* _data)
{
struct prox_4pt_dfwavelet_data* data = CONTAINER_OF(_data, struct prox_4pt_dfwavelet_data, base);
md_free(data->vx);
md_free(data->vy);
md_free(data->vz);
md_free(data->ph0);
md_free(data->pc0);
md_free(data->pc1);
md_free(data->pc2);
md_free(data->pc3);
dfwavelet_free(data->plan);
operator_p_free(data->wthresh_op);
linop_free(data->w_op);
free(data);
}
static void dfthresh(unsigned int D, const long dims[D], float lambda, complex float* out, const complex float* in)
{
long minsize[3];
md_singleton_dims(3, minsize);
long coarse_scale[3] = MD_INIT_ARRAY(3, 16);
md_min_dims(3, ~0u, minsize, dims, coarse_scale);
complex float res[3];
res[0] = 1.;
res[1] = 1.;
res[2] = 1.;
assert(3 == dims[TE_DIM]);
const struct operator_p_s* p = prox_dfwavelet_create(dims, minsize, res, TE_DIM, lambda, false);
operator_p_apply(p, 1., D, dims, out, D, dims, in);
operator_p_free(p);
}
// FIXME: consider moving this to a more accessible location?
static void wthresh(unsigned int D, const long dims[D], float lambda, unsigned int flags, complex float* out, const complex float* in)
{
long minsize[D];
md_singleton_dims(D, minsize);
long course_scale[3] = MD_INIT_ARRAY(3, 16);
md_copy_dims(3, minsize, course_scale);
unsigned int wflags = 7; // FIXME
for (unsigned int i = 0; i < 3; i++)
if (dims[i] < minsize[i])
wflags = MD_CLEAR(wflags, i);
long strs[D];
md_calc_strides(D, strs, dims, CFL_SIZE);
const struct linop_s* w = linop_wavelet_create(D, wflags, dims, strs, minsize, false);
const struct operator_p_s* p = prox_unithresh_create(D, w, lambda, flags);
operator_p_apply(p, 1., D, dims, out, D, dims, in);
operator_p_free(p);
}
void thresh_free(const struct operator_p_s* o)
{
operator_p_free(o);
}
