void
zt_opts_usage(char *argv[], struct zt_opt_args *opts, char *option_string, int max_opts, int show_defaults)
{
int i = 0;
fprintf(stderr, "usage: %s %s" NL, basename(argv[0]), option_string);
if (max_opts > 0) {
fprintf(stderr, NL "Options:" NL);
}
for (i = 0; i < max_opts; i++) {
int offt = 0;
if (opts[i].description != NULL) {
if (isoptchar(opts[i].opt)) {
offt = fprintf(stderr, BLANK "-%c", INDENT(1), opts[i].opt);
}
#ifdef HAVE_GETOPT_LONG
if (opts[i].long_opt) {
if (isoptchar(opts[i].opt)) {
offt += fprintf(stderr, ", --%s", opts[i].long_opt);
} else {
offt += fprintf(stderr, BLANK " --%s", INDENT(1), opts[i].long_opt);
}
}
#endif /* ifdef HAVE_GETOPT_LONG */
offt += fprintf(stderr, BLANK "%s", INDENT_TO(30, 5, offt), opts[i].description ? opts[i].description : "");
if (show_defaults) {
print_default(opts[i].type, opts[i].val);
}
if (opts[i].usage) {
fprintf(stderr, BLANK ": %s" NL, INDENT(1), opts[i].usage);
} else
if (zt_opts_usage_t[opts[i].type].desc) {
if (isoptchar(opts[i].opt)) {
fprintf(stderr,
BLANK ": eg. -%c %s" NL,
INDENT(1),
opts[i].opt,
zt_opts_usage_t[opts[i].type].desc ? zt_opts_usage_t[opts[i].type].desc : "");
} else {
fprintf(stderr,
BLANK ": eg. --%s %s" NL,
INDENT(1),
opts[i].long_opt,
zt_opts_usage_t[opts[i].type].desc ? zt_opts_usage_t[opts[i].type].desc : "");
}
} else {
fprintf(stderr, NL);
}
}
}
} /* zt_opts_usage */
static void print_bool_help(struct isl_arg *decl,
struct isl_prefixes *prefixes, void *opt)
{
int pos;
unsigned *p = opt ? (unsigned *)(((char *) opt) + decl->offset) : NULL;
int no = p ? *p == 1 : 0;
pos = print_arg_help(decl, prefixes, no);
pos = print_help_msg(decl, pos);
if (decl->offset != (size_t) -1)
print_default(decl, no ? "yes" : "no", pos);
printf("\n");
}
static void print_str_help(struct isl_arg *decl,
struct isl_prefixes *prefixes, void *opt)
{
int pos;
const char *a = decl->argument_name ? decl->argument_name : "string";
const char **p = (const char **)(((char *) opt) + decl->offset);
pos = print_arg_help(decl, prefixes, 0);
pos = print_argument_name(decl, a, pos);
pos = print_help_msg(decl, pos);
if (*p)
print_default(decl, *p, pos);
printf("\n");
}
static void print_int_help(struct isl_arg *decl,
struct isl_prefixes *prefixes, void *opt)
{
int pos;
char val[20];
int *p = (int *)(((char *) opt) + decl->offset);
pos = print_arg_help(decl, prefixes, 0);
pos = print_argument_name(decl, decl->argument_name, pos);
pos = print_help_msg(decl, pos);
snprintf(val, sizeof(val), "%d", *p);
print_default(decl, val, pos);
printf("\n");
}
void optimize_full(viennacl::io::parameter_database & paras,
TimingType & timings,
F functor,
TestConfig & config,
TestData & data)
{
record_full_timings(timings, functor, config, data);
record_kernel_parameters(paras, config.kernel_name(), timings);
#ifdef ENABLE_VIENNAPROFILER
write_viennaprofiler(timings, config.program_name(), config.kernel_name());
#endif
print_best(timings, config.kernel_name());
print_default(timings, config.kernel_name());
}
static void print_default_choice(struct isl_arg *decl, void *opt, int pos)
{
int i;
const char *s = "none";
unsigned *p;
p = (unsigned *)(((char *) opt) + decl->offset);
for (i = 0; decl->u.choice.choice[i].name; ++i)
if (decl->u.choice.choice[i].value == *p) {
s = decl->u.choice.choice[i].name;
break;
}
print_default(decl, s, pos);
}
void ProjectionsCase_tests::MyTest()
{
TH2DA * h_1 = new TH2DA("h_1", "h_1", x_size, 0, 10, y_size, 0, 10);
fill_default(h_1);
double def_int;
double def_err_u;
double def_err_l;
// test proper integral calculation
defaults_integral(def_int, def_err_u, def_err_l);
CPPUNIT_ASSERT_DOUBLES_EQUAL( def_int, h_1->Integral(), 0.0001 );
TH1D * h_1_p01 = h_1->ProjectionY("h_1_p01",0, 2);
defaults_integral(def_int, def_err_u, def_err_l, 0, 2, 0, y_size);
CPPUNIT_ASSERT_DOUBLES_EQUAL( def_int, h_1_p01->Integral() , 0.0001 );
print_default(1);
TGraphAsymmErrors * assym_errors = nullptr;
for (uint i = 0; i < y_size; ++i)
{
assym_errors = h_1->ErrorsProjectionY(0, i+1);
for (uint j = 0; j < x_size; ++j)
{
defaults_integral(def_int, def_err_u, def_err_l, j, j+1, 0, i+1);
// printf("testing dy=%d, x=%d\n", i+1, j);
CPPUNIT_ASSERT_DOUBLES_EQUAL( def_err_u, assym_errors->GetErrorYhigh(j), 0.0000000001 );
CPPUNIT_ASSERT_DOUBLES_EQUAL( def_err_l, assym_errors->GetErrorYlow(j), 0.0000000001 );
}
}
for (uint i = 0; i < x_size; ++i)
{
assym_errors = h_1->ErrorsProjectionX(0, i+1);
for (uint j = 0; j < y_size; ++j)
{
defaults_integral(def_int, def_err_u, def_err_l, 0, i+1, j, j+1);
// printf("testing dx=%d, y=%d\n", i+1, j);
CPPUNIT_ASSERT_DOUBLES_EQUAL( def_err_u, assym_errors->GetErrorYhigh(j), 0.0000000001 );
CPPUNIT_ASSERT_DOUBLES_EQUAL( def_err_l, assym_errors->GetErrorYlow(j), 0.0000000001 );
}
}
}
static void
print_default(matvar_t *matvar)
{
if ( NULL == matvar )
return;
switch ( matvar->class_type ) {
case MAT_C_DOUBLE:
case MAT_C_SINGLE:
case MAT_C_INT64:
case MAT_C_UINT64:
case MAT_C_INT32:
case MAT_C_UINT32:
case MAT_C_INT16:
case MAT_C_UINT16:
case MAT_C_INT8:
case MAT_C_UINT8:
{
if ( matvar->rank == 2 )
print_default_numeric_2d(matvar);
else if ( matvar->rank == 3 )
print_default_numeric_3d(matvar);
break;
}
case MAT_C_CHAR:
case MAT_C_SPARSE:
Mat_VarPrint(matvar, printdata);
break;
case MAT_C_STRUCT:
{
matvar_t **fields = (matvar_t **)matvar->data;
int nfields;
int i;
size_t nmemb;
if ( matvar->name )
Mat_Message(" Name: %s", matvar->name);
Mat_Message(" Rank: %d", matvar->rank);
if ( matvar->rank == 0 )
return;
Mat_Message("Class Type: Structure");
nfields = Mat_VarGetNumberOfFields(matvar);
nmemb = matvar->dims[0];
for ( i = 1; i < matvar->rank; i++ )
nmemb *= matvar->dims[i];
if ( nfields > 0 && nmemb < 1 ) {
char * const *fieldnames = Mat_VarGetStructFieldnames(matvar);
Mat_Message("Fields[%d] {", nfields);
indent++;
for ( i = 0; i < nfields; i++ )
Mat_Message(" Name: %s", fieldnames[i]);
indent--;
Mat_Message("}");
} else if ( nfields > 0 && nmemb > 0 ) {
Mat_Message("Fields[%d] {", nfields);
indent++;
for ( i = 0; i < nfields*nmemb; i++ )
print_default(fields[i]);
indent--;
Mat_Message("}");
}
break;
}
case MAT_C_CELL:
{
matvar_t **cells = (matvar_t **)matvar->data;
size_t ncells;
int i;
if ( matvar->name )
Mat_Message(" Name: %s", matvar->name);
Mat_Message(" Rank: %d", matvar->rank);
if ( matvar->rank == 0 )
return;
ncells = matvar->dims[0];
for ( i = 1; i < matvar->rank; i++ )
ncells *= matvar->dims[i];
Mat_Message("Class Type: Cell Array");
Mat_Message("{");
indent++;
for ( i = 0; i < ncells; i++ )
print_default(cells[i]);
indent--;
Mat_Message("}");
break;
}
default:
Mat_Message("Empty");
}
}
