int ZoltanLibClass::
color(Teuchos::ParameterList& zoltanParamList,
std::vector<int>& properties)
{
zoltanParamList_ = zoltanParamList;
// Distance 2 coloring by default.
if (!zoltanParamList_.isParameter("COLORING_PROBLEM"))
zoltanParamList_.set("COLORING_PROBLEM", "DISTANCE-2");
precompute();
//Generate Load Balance
int num_gid_entries = 1;
// Use ColMap to have directly answers for columns !
properties.resize(num_obj_);
// TODO64 - This only works if the global IDs fit in an int.
ZOLTAN_ID_TYPE *gids=NULL;
if (sizeof(ZOLTAN_ID_TYPE) != sizeof(int)){
gids = new ZOLTAN_ID_TYPE [num_obj_];
if (num_obj_ && ! gids){
throw Isorropia::Exception("Out of memory in ZoltanLibClass::color()");
return -1;
}
int *intIds = queryObject_->RowMap().MyGlobalElements();
for (int i=0; i < num_obj_; i++){
gids[i] = (ZOLTAN_ID_TYPE)intIds[i];
}
}
else{
gids = (ZOLTAN_ID_PTR)queryObject_->RowMap().MyGlobalElements();
}
int err = zz_->Color(num_gid_entries, num_obj_, gids, &properties[0]);
if (sizeof(ZOLTAN_ID_TYPE) != sizeof(int)){
delete [] gids;
}
if (err != ZOLTAN_OK){
throw Isorropia::Exception("Error computing coloring with Zoltan");
return -1;
}
postcompute();
return (0);
}
int main()
{
long long int n;
//int t;
precompute();
//scanf("%d",&t);
//while(t--)
//{
scanf("%lld",&n);
printf("%lld\n",A[n]+B[n]);
//}
return 0;
}
// Multipairing
void do_multi(int m){
int i = 0;
lpoly list[m];
lpoly *tmp_list;
// prevalues
element_t gg[m];
element_ptr ggg[m];
element_t hh[m];
for(i = 0; i < m; i++){
element_init_G2(gg[i], pairing);
element_random(gg[i]);
ggg[i] = malloc(sizeof(element_ptr));
element_init(ggg[i], gg[i]->field);
element_set(ggg[i], gg[i]);
element_init_G1(hh[i], pairing);
element_random(hh[i]);
}
// precomputation
gettimeofday(&tvBegin, NULL);
for(i = 0; i < m; i++){
tmp_list = lpoly_init();
precompute(tmp_list, pairing->r, hh[i], gg[i]);
list[i] = *tmp_list;
}
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1000);
// compute
gettimeofday(&tvBegin, NULL);
compute_millers(temp2, list, ggg, m, pairing);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1000);
gettimeofday(&tvBegin, NULL);
element_prod_pairing(temp1, hh, gg, m);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1000);
for(i = 0; i < m; i++){
lpoly_free2(list[i]);
}
}
Camera::Camera(const Mat4f &transform, const Vec2u &res)
: _tonemapOp("gamma"),
_transform(transform),
_res(res)
{
_colorBufferSettings.setType(OutputColor);
_pos = _transform*Vec3f(0.0f, 0.0f, 2.0f);
_lookAt = _transform*Vec3f(0.0f, 0.0f, -1.0f);
_up = _transform*Vec3f(0.0f, 1.0f, 0.0f);
_transform.setRight(-_transform.right());
precompute();
}
int main(int argc, char** args)
{
precompute();
int numTestCases;
scanf("%d\n", &numTestCases);
int n;
while(numTestCases-->0)
{
scanf("%d\n", &n);
factorial(n);
}
return 0;
}
void gcm_init(gcm* g,int nk,char *key,char *iv)
{ /* assumes iv is 96 bits/12 bytes. AES key can be 16,24 or 32 bytes */
int i;
MR_BYTE H[16];
for (i=0;i<16;i++) {H[i]=0; g->stateX[i]=0;}
aes_init(&(g->a),MR_ECB,nk,key,iv);
aes_ecb_encrypt(&(g->a),H); /* E(K,0) */
precompute(g,H);
g->counter=1;
for (i=0;i<12;i++) g->a.f[i]=iv[i];
unpack(g->counter,(MR_BYTE *)&(g->a.f[12])); /* initialise IV */
g->status=GCM_ACCEPTING_HEADER;
g->lenA[0]=g->lenC[0]=g->lenA[1]=g->lenC[1]=0;
}
int ZoltanLibClass::
order(Teuchos::ParameterList& zoltanParamList,
std::vector<int>& properties)
{
zoltanParamList_ = zoltanParamList;
precompute();
/* Note : this works because epetra ordinal type is int */
int num_gid_entries = 1;
properties.resize(num_obj_);
// TODO64 - This only works if the global IDs fit in an int.
ZOLTAN_ID_TYPE *gids=NULL;
if (sizeof(ZOLTAN_ID_TYPE) != sizeof(int)){
gids = new ZOLTAN_ID_TYPE [num_obj_];
if (num_obj_ && ! gids){
throw Isorropia::Exception("Out of memory in ZoltanLibClass::order()");
return -1;
}
int *intIds = queryObject_->RowMap().MyGlobalElements();
for (int i=0; i < num_obj_; i++){
gids[i] = (ZOLTAN_ID_TYPE)intIds[i];
}
}
else{
gids = (ZOLTAN_ID_PTR)queryObject_->RowMap().MyGlobalElements();
}
int err = zz_->Order(num_gid_entries, num_obj_, gids, &properties[0], NULL);
if (sizeof(ZOLTAN_ID_TYPE) != sizeof(int)){
delete [] gids;
}
if (err != ZOLTAN_OK){
throw Isorropia::Exception("Error computing ordering with Zoltan");
return -1;
}
postcompute();
return (0);
}
bool CNumericalVGLikelihood::set_variational_distribution(SGVector<float64_t> mu,
SGVector<float64_t> s2, const CLabels* lab)
{
bool status = true;
status = CVariationalGaussianLikelihood::set_variational_distribution(mu, s2, lab);
if (status)
{
if (supports_binary())
{
REQUIRE(lab->get_label_type()==LT_BINARY,
"Labels must be type of CBinaryLabels\n");
}
else
{
if (supports_regression())
{
REQUIRE(lab->get_label_type()==LT_REGRESSION,
"Labels must be type of CRegressionLabels\n");
}
else
SG_ERROR("Unsupported Label type\n");
}
if (supports_binary())
m_lab=((CBinaryLabels*)lab)->get_labels();
else
m_lab=((CRegressionLabels*)lab)->get_labels();
if (!m_is_init_GHQ)
{
m_xgh=SGVector<float64_t>(m_GHQ_N);
m_wgh=SGVector<float64_t>(m_GHQ_N);
CIntegration::generate_gauher(m_xgh, m_wgh);
m_is_init_GHQ=true;
}
precompute();
}
return status;
}
/***********************************************************************//**
* @brief Read point spread function from FITS table
*
* @param[in] table FITS table.
*
* @exception GException::invalid_value
* Response table is not three-dimensional.
*
* Reads the point spread function form the FITS @p table. The following
* column names are mandatory:
*
* ENERG_LO - Energy lower bin boundaries
* ENERG_HI - Energy upper bin boundaries
* THETA_LO - Offset angle lower bin boundaries
* THETA_HI - Offset angle upper bin boundaries
* RAD_LO - Delta angle lower bin boundaries
* RAD_HI - Delta angle upper bin boundaries
* RPSF - PSF histogram
*
* The data are stored in the m_psf member. The energy axis will be set to
* log10, the offset and delta angle axes to radians.
***************************************************************************/
void GCTAPsfTable::read(const GFitsTable& table)
{
// Clear response table
m_psf.clear();
// Read PSF table
m_psf.read(table);
// Get mandatory indices (throw exception if not found)
m_inx_energy = m_psf.axis("ENERG");
m_inx_theta = m_psf.axis("THETA");
m_inx_delta = m_psf.axis("RAD");
m_inx_rpsf = m_psf.table("RPSF");
// Throw an exception if the table is not three-dimensional
if (m_psf.axes() != 3) {
std::string msg = "Expected three-dimensional point spread function "
"response table but found "+
gammalib::str(m_psf.axes())+
" dimensions. Please specify a three-dimensional "
"point spread function.";
throw GException::invalid_value(G_READ, msg);
}
// Set energy axis to logarithmic scale
m_psf.axis_log10(m_inx_energy);
// Set offset angle axis to radians
m_psf.axis_radians(m_inx_theta);
// Set delta angle axis to radians
m_psf.axis_radians(m_inx_delta);
// Precompute PSF information
precompute();
// Return
return;
}
bool CLogitVGPiecewiseBoundLikelihood::set_variational_distribution(SGVector<float64_t> mu,
SGVector<float64_t> s2, const CLabels* lab)
{
bool status = true;
status=CVariationalGaussianLikelihood::set_variational_distribution(mu, s2, lab);
if (status)
{
REQUIRE(lab->get_label_type()==LT_BINARY,
"Labels must be type of CBinaryLabels\n");
m_lab = (((CBinaryLabels*)lab)->get_labels()).clone();
//Convert the input label to standard label used in the class
//Note that Shogun uses -1 and 1 as labels and this class internally uses
//0 and 1 repectively.
for(index_t i = 0; i < m_lab.size(); ++i)
m_lab[i] = CMath::max(m_lab[i], 0.0);
precompute();
}
return status;
}
void CDualVariationalGaussianLikelihood::set_dual_parameters(SGVector<float64_t> lambda, const CLabels* lab)
{
REQUIRE(lab, "Labels are required (lab should not be NULL)\n");
REQUIRE((lambda.vlen==lab->get_num_labels()),
"Length of the vector of lambda (%d) "
"and number of labels (%d) should be the same\n",
lambda.vlen, lab->get_num_labels());
REQUIRE(lab->get_label_type()==LT_BINARY,
"Labels (%s) must be type of CBinaryLabels\n",
lab->get_name());
m_lab=(((CBinaryLabels*)lab)->get_labels()).clone();
//Convert the input label to standard label used in the class
//Note that Shogun uses -1 and 1 as labels and this class internally uses
//0 and 1 repectively.
for(index_t i = 0; i < m_lab.size(); ++i)
m_lab[i]=CMath::max(m_lab[i], 0.0);
m_lambda=lambda;
precompute();
}
void Camera::prepareForRender()
{
precompute();
}
void Camera::setLookAt(const Vec3f &lookAt)
{
_lookAt = lookAt;
_transform = Mat4f::lookAt(_pos, _lookAt - _pos, _up);
precompute();
}
int main(void)
{
pairing_t pairing;
char param[50000];
size_t count = fread(param, 1, 50000, stdin);
if (!count) pbc_die("input error");
pairing_init_set_buf(pairing, param, count);
// int cont = 0;
struct timeval tvBegin, tvEnd;
element_t g, h;
element_t public_key, secret_key;
element_t sig;
element_t temp1, temp2;
element_init_G2(g, pairing);
element_init_G2(public_key, pairing);
element_init_G1(h, pairing);
element_init_G1(sig, pairing);
element_init_GT(temp1, pairing);
element_init_GT(temp2, pairing);
element_init_Zr(secret_key, pairing);
// Generating key
element_random(g);
element_random(secret_key);
element_pow_zn(public_key, g, secret_key);
// Generating message
element_from_hash(h, "ABCDEF", 6);
element_pow_zn(sig, h, secret_key);
// RANDOM TESTS
/*
// Fp
element_t p1, p2;
element_init(p1, element_x(h)->field);
element_init(p2, p1->field);
element_random(p1);
element_random(p2);
// multiplication
element_t puntos[2000];
for(cont = 0; cont < 1000; cont++){
element_init(puntos[cont], element_x(h)->field);
element_init(puntos[2*cont], element_x(h)->field);
element_random(puntos[cont]);
element_random(puntos[2*cont]);
}
gettimeofday(&tvBegin, NULL);
for(cont = 0; cont < 1000; cont++){
element_mul(puntos[cont], puntos[cont], puntos[2*cont]);
}
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
//square
gettimeofday(&tvBegin, NULL);
for(cont = 0; cont < 1000; cont++) element_square(puntos[cont], puntos[2*cont]);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
// add
gettimeofday(&tvBegin, NULL);
for(cont = 0; cont < 1000; cont++) element_add(puntos[cont], puntos[cont], puntos[2*cont]);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
// invers
gettimeofday(&tvBegin, NULL);
for(cont = 0; cont < 1000; cont++) element_invert(puntos[cont], puntos[2*cont]);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
// Fpk
element_t q1, q2;
element_init_GT(q1, pairing);
element_init_GT(q2, pairing);
element_random(q1);
element_random(q2);
// multiplication
for(cont = 0; cont < 1000; cont++){
element_init_GT(puntos[cont], pairing);
element_init_GT(puntos[2*cont], pairing);
element_random(puntos[cont]);
element_random(puntos[2*cont]);
}
gettimeofday(&tvBegin, NULL);
for(cont = 0; cont < 1000; cont++) {
element_mul(puntos[cont], puntos[cont], puntos[2*cont]);
}
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
//square
gettimeofday(&tvBegin, NULL);
for(cont = 0; cont < 1000; cont++) element_square(puntos[cont], puntos[cont]);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
// add
gettimeofday(&tvBegin, NULL);
for(cont = 0; cont < 1000; cont++){
element_add(element_x(puntos[cont]), element_x(puntos[cont]), element_x(puntos[2*cont]));
element_add(element_y(puntos[cont]), element_y(puntos[cont]), element_y(puntos[2*cont]));
}
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
// invers
gettimeofday(&tvBegin, NULL);
for(cont = 0; cont < 1000; cont++) element_invert(puntos[cont], puntos[2*cont]);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
// CURVE OPERATIONS
element_t punto, punto2;
element_init(punto, h->field); element_random(punto);
element_init(punto2, h->field); element_random(punto2);
// add
gettimeofday(&tvBegin, NULL);
element_mul(punto, punto, punto2);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
// double
gettimeofday(&tvBegin, NULL);
element_double(punto, punto2);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1);
// SIZE GROUP
int m = mpz_sizeinbase(pairing->r, 2) - 2;
printf("%i\n", m);
int contador = 0;
for(;;){
if(!m) break;
if(mpz_tstbit(pairing->r,m)) contador++;
m--;
}
printf("%i\n", contador);
*/
// One pairing
gettimeofday(&tvBegin, NULL);
eval_miller(temp1, sig, g, pairing);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1000);
//print_contador();
// One pairing (with precomputed values)
// Original method
pairing_pp_t pp;
// Precomp
gettimeofday(&tvBegin, NULL);
pairing_pp_init(pp, sig, pairing);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1000);
// Eval
gettimeofday(&tvBegin, NULL);
pairing_pp_apply(temp1, g, pp);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1000);
pairing_pp_clear(pp);
void do_precomp(){
lpoly *list;
// precomputation
gettimeofday(&tvBegin, NULL);
list = lpoly_init();
precompute(list, pairing->r, sig, g);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1000);
// DMAX
printf("%i\n", list->MAXD);
// eval
gettimeofday(&tvBegin, NULL);
compute_miller(temp2, list, g, pairing);
gettimeofday(&tvEnd, NULL);
timeval_subtract(&tvEnd, &tvBegin, 1000);
lpoly_free(list);
}
int main(int argc, char *argv[])
{
precompute();
#ifdef USE_HASH
hash_init();
#endif
// load_endgames();
// load_bitbases();
if (argc == 2 && !strcmp(argv[1], "nobook"))
{
printf("Skipping opening book\n");
}
else if (argc == 2 && !strcmp(argv[1], "makebook"))
{
load_opening_book(1);
opening_book_grow(0);
return 0;
}
else if (argc == 2 && !strcmp(argv[1], "showbook"))
{
load_opening_book(1);
opening_book_grow(1);
return 0;
}
else
load_opening_book(2);
new_game();
int ply;
int i, j, k;
FILE * input;
FILE * output;
char command[80] = "";
char buffer[4100] = "";
/* if (argc == 2 && !strcmp(argv[1], "files"))
{
printf("Using files for I/O\n");
input = fopen("input.txt", "r+");
output = fopen("output.txt", "w");
}
else */
{
input = stdin;
output = stdout;
}
if (argc == 2 && !strcmp(argv[1], "bitbases"))
{
bitbase_report();
return 0;
}
if (argc == 7 && !strcmp(argv[1], "position"))
{
i = bitbase_test(
atoi(argv[2])
,atoi(argv[3])
,atoi(argv[4])
,atoi(argv[5])
,atoi(argv[6])
);
printf("%s\n", i ? "is a win for black" : "not a win for black");
int pieces[MAX_BDB_PIECES];
int total_pieces = 0;
for (i = 0; i < atoi(argv[2]); ++i) pieces[total_pieces++] = 0;
for (i = 0; i < atoi(argv[3]); ++i) pieces[total_pieces++] = 1;
for (i = 0; i < atoi(argv[4]); ++i) pieces[total_pieces++] = 2;
for (i = 0; i < atoi(argv[5]); ++i) pieces[total_pieces++] = 3;
position_decode(atoi(argv[6]), pieces, total_pieces);
print_board(0);
return 0;
}
if (argc == 2 && !strcmp(argv[1], "sanity"))
{
sanity_checks();
memory_report();
return 0;
}
if (argc == 2 && !strcmp(argv[1], "perft"))
{
iterative_performance_test();
#ifdef SORT_STATISTIC
for (i = 0; i < 5; ++i)
printf("Returns at sort level %d: %d\n"
, i
, sort_statistic[i]);
#endif
return 0;
}
if (argc >= 4 && !strcmp(argv[1], "pdn"))
{
ply = 0;
FILE * pdn;
pdn = fopen(argv[3], "a+");
if (!pdn)
{
printf("error: fopen \"%s\" for append/create\n", argv[3]);
// printf("err: %d - %s\n", errno, strerror(errno));
// getcwd(buffer, sizeof(buffer));
// printf("pwd: %s\n", buffer);
return 1;
}
while (!feof(pdn)) // fixme: this loader sux...
{
if (!fgets(buffer, 4096, pdn))
break;
//if (!buffer || feof(pdn))
// break;
i = 0;
while (j = load_move_from_pdn(buffer, command, &i))
{
generate_moves(0, 0);
k = find_move(0, command);
if (k < 0 || k >= move_counter[0])
{
fprintf(output, "error invalid move from pdn (%s)\n"
, command);
for (k = 0; k < move_counter[0]; ++k)
{
fprintf(output, "move %d ",k);
print_move(&moves[0][k], 0);
fprintf(output, "\n");
}
}
else
{
++ply;
//fprintf(output, "executing move at index %d: ", k);
if (!strcmp(argv[2], "show") || !strcmp(argv[2], "step"))
{
if (ply % 2 == 1)
printf("%3d. ", (ply+1) / 2);
print_move(&moves[0][k], 0);
if (ply % 2 == 0)
{
printf("\n");
//print_board(0);
}
else
printf(" ");
if (!strcmp(argv[2], "step") && ply % 2 == 0)
{
print_board(0);
getc(stdin);
}
}
//fprintf(output, "\n");
move_do(&moves[0][k], 0);
move_list_push(&moves[0][k]);
}
}
if (feof(pdn))
break;
}
fclose(pdn);
if (!strcmp(argv[2], "play"))
{
pdn = fopen(argv[3], "a");
if (!pdn)
{
printf("error: fopen \"%s\" for append\n", argv[3]);
return 1;
}
if (argc >= 5 && strcmp(argv[4], "hint") && strcmp(argv[4], "move"))
{
generate_moves(0, 0);
i = find_move(0, argv[4]);
if (i < 0 || i >= move_counter[0])
{
print_moves(0);
i = -1;
}
else
{
move_do(&moves[0][i], 0);
move_list_push(&moves[0][i]);
fprintf(pdn, "%s ", argv[4]);
if (moves[0][i].same_player_square != -1)
i = -1;
}
}
if (i != -1)
{
if (argc >= 6)
strength = atoi(argv[5]);
if (argc >= 7)
thinking_time = atoi(argv[6]);
if (strength == 1)
thinking_time = 1;
if (!strcmp(argv[4], "hint"))
bestmove(0, 0);
else
while (bestmove(pdn, 1));
}
fclose(pdn);
fprintf(output, "boardok ");
for (i = 0; i < 64; ++i)
fprintf(output, "%d", board[i]);
fprintf(output, " %d", state.tactical_square);
fprintf(output, " %d", state.side_to_move);
fprintf(output, " %d", state.this_piece_must_take);
fprintf(output, "\n");
}
else
{
print_board(0);
//debug_moves = 1;
generate_moves(0, 0);
if (!strcmp(argv[2], "show"))
print_moves(0);
}
if (!strcmp(argv[2], "load"))
{
printf("PDN loaded\n");
command[0] = 0;
buffer[0] = 0;
}
else
return 0;
}
for (;;)
{
fscanf(input, "%20s", command);
if (parse(command, "quit"))
break;
else if (parse(command, "gnt"))
fprintf(output, "id name GNTredux\nid author QuakePhil\ngntok\n");
else if (parse(command, "new"))
new_game();
else if (parse(command, "flipside"))
state.side_to_move ^= 1;
else if (parse(command, "flipkings"))
{
for (i = 0; i < 64; ++i) if (initial_board[i] != 4)
{
if (initial_board[i] < 2)
initial_board[i] += 2;
else
initial_board[i] -= 2;
}
new_game();
}
else if (parse(command, "flipboardonly"))
{ // fixme: need to re-do materials here?
int temp[64];
int flip_piece[5] = {1,0,3,2,4};
j = 64;
for (i = 0; i < 64; ++i)
temp[--j] = flip_piece[board[i]];
for (i = 0; i < 64; ++i)
board[i] = temp[i];
state.side_to_move ^= 1;
}
else if (parse(command, "rand"))
rand_board();
else if (parse(command, "think"))
{
bestmove(0, 0);
}
else if (parse(command, "go"))
{
bestmove(0, 1);
}
else if (parse(command, "perft"))
{
iterative_performance_test();
}
else if (parse(command, "ping"))
{
fprintf(output, "pong %.6lf\n", timer());
}
else if (parse(command, "pboard"))
print_board(0);
else if (parse(command, "board"))
{
fprintf(output, "boardok ");
for (i = 0; i < 64; ++i)
fprintf(output, "%d", board[i]);
fprintf(output, " %d", state.tactical_square);
fprintf(output, " %d", state.side_to_move);
fprintf(output, " %d", state.this_piece_must_take);
fprintf(output, "\n");
}
else if (parse(command, "time"))
{
fscanf(input, "%d", &thinking_time);
printf("Think time limit set to: %d seconds\n", thinking_time);
}
else if (parse(command, "pdn"))
{
fscanf(input, "%20s", buffer);
generate_moves(0, 0);
i = find_move(0, buffer);
if (i < 0 || i >= move_counter[0])
fprintf(output, "error invalid move\n");
else
{
move_do(&moves[0][i], 0);
move_list_push(&moves[0][i]);
//fprintf(output, "executing move at index %d: ", i);
//print_move(&moves[0][i], 0);
//fprintf(output, "\n");
fprintf(output, "done\n");
}
}
else if (parse(command, "do") || parse(command, "toggle"))
{
fscanf(input, "%d", &i);
fprintf(output, "executing move %d\n", i);
generate_moves(0, 0);
if (i < 0)
fprintf(output, "error move can't be negative\n");
else if (i >= move_counter[0])
fprintf(output, "error no such move\n");
else
{
move_do(&moves[0][i], 0);
move_list_push(&moves[0][i]);
if (parse(command, "toggle"))
{
print_board(0);
fprintf(output, "undoing move %d\n", i);
move_undo(&moves[0][i], 0);
print_board(0);
}
}
fprintf(output, "done\n");
}
else if (parse(command, "list"))
{
print_move_list();
}
else if (parse(command, "pbook"))
{
print_book();
}
else if (parse(command, "moves"))
{
generate_moves(0, 0);
for (i = 0; i < move_counter[0]; ++i)
{
fprintf(output, "move %d ",i);
print_move(&moves[0][i], 1);
fprintf(output, "\n");
}
fprintf(output, "movesok\n");
}
else // if (!strcmp(command, "help"))
{
// fprintf(output, "?\n");
}
fflush(output);
}
#ifdef HASH_STATISTIC
printf("Hash saves: %d\n", hash_saves);
printf("Hash collisions: %d\n", hash_collisions);
printf("Hash probes: %d\n", hash_probes);
printf("Hash hits: %d\n", hash_hits);
#endif
#ifdef SORT_STATISTIC
for (i = 0; i < 5; ++i)
printf("Returns at sort level %d: %d\n"
, i
, sort_statistic[i]);
#endif
fclose(output);
fclose(input);
return 0;
}
void Camera::setUp(const Vec3f &up)
{
_up = up;
_transform = Mat4f::lookAt(_pos, _lookAt - _pos, _up);
precompute();
}
PinholeCamera::PinholeCamera(const Mat4f &transform, const Vec2u &res, float fov)
: Camera(transform, res),
_fovDeg(fov)
{
precompute();
}
int ZoltanLibClass::
repartition(Teuchos::ParameterList& zoltanParamList,
std::vector<int>& properties,
int& exportsSize,
std::vector<int>& imports)
{
zoltanParamList_ = zoltanParamList;
// Avoid to construct import list.
// Perhaps "PARTITION ASSIGNMENTS" will be better in term of performance.
zoltanParamList_.set("RETURN_LISTS", "EXPORT AND IMPORT");
preCheckPartition();
precompute();
// Set part sizes
if (numPartSizes > 0){
int err;
int *wgtIdx = NULL;
err = zz_->LB_Set_Part_Sizes(1, numPartSizes, partGIDs, wgtIdx, partSizes);
if (err != ZOLTAN_OK){
throw Isorropia::Exception("Error in LB_Set_Part_Sizes");
return -1;
}
}
//Generate Load Balance
int changes=0, num_gid_entries=0, num_lid_entries=0, num_import=0, num_export=0;
ZOLTAN_ID_PTR import_global_ids=NULL, import_local_ids=NULL;
ZOLTAN_ID_PTR export_global_ids=NULL, export_local_ids=NULL;
int * import_procs=NULL, * export_procs=NULL;
int *import_to_part=NULL, *export_to_part=NULL;
int err = zz_->LB_Partition(changes, num_gid_entries, num_lid_entries,
num_import, import_global_ids, import_local_ids, import_procs, import_to_part,
num_export, export_global_ids, export_local_ids, export_procs, export_to_part );
if (err != ZOLTAN_OK){
throw Isorropia::Exception("Error computing partitioning with Zoltan");
return -1;
}
exportsSize = num_export;
imports.clear();
imports.assign(import_global_ids, import_global_ids + num_import);
properties.assign(num_obj_, queryObject_->RowMap().Comm().MyPID());
for( int i = 0; i < num_export; ++i )
{
properties[export_local_ids[i]] = export_to_part[i];
}
//Free Zoltan Data
zz_->LB_Free_Part(&import_global_ids, &import_local_ids,
&import_procs, &import_to_part);
zz_->LB_Free_Part(&export_global_ids, &export_local_ids,
&export_procs, &export_to_part);
postcompute();
return (0);
}
Gaussian::Gaussian(double alpha, int m, int n, int N) : SmoothingFunction(alpha, m, n, N)
{
precompute();
}
PinholeCamera::PinholeCamera()
: Camera(),
_fovDeg(60.0f)
{
precompute();
}
ReconstructionFilter(const std::string &name = "tent")
: _typeString(name),
_type(stringToType(name))
{
precompute();
}
Quad4ShapeFunction::Quad4ShapeFunction(const MasterElement &mel)
: ShapeFunction(4, mel)
{
precompute(mel);
}
Tri3ShapeFunction::Tri3ShapeFunction(const MasterElement &mel)
: ShapeFunction(3, mel)
{
precompute(mel);
}
CFeatures* CFeatureSelection<ST>::apply_backward_elimination(CFeatures* features)
{
SG_DEBUG("Entering!\n");
// precompute whenever appropriate for performing the rest of the tasks
precompute();
// NULL check for features is handled in get_num_features
index_t num_features=get_num_features(features);
SG_DEBUG("Initial number of features %d!\n", num_features);
// the main loop
while (num_features>m_target_dim)
{
// tune the measurement parameters whenever necessary based on current
// features
adapt_params(features);
// compute the measures for each of the current dimensions
SGVector<float64_t> measures(num_features);
for (index_t i=0; i<num_features; ++i)
measures[i]=compute_measures(features, i);
if (io->get_loglevel()==MSG_DEBUG || io->get_loglevel()==MSG_GCDEBUG)
measures.display_vector("measures");
// rank the measures
SGVector<index_t> argsorted=CMath::argsort(measures);
if (io->get_loglevel()==MSG_DEBUG || io->get_loglevel()==MSG_GCDEBUG)
argsorted.display_vector("argsorted");
// make sure that we don't end up with lesser feats than target dim
index_t to_remove;
if (m_policy==N_SMALLEST || m_policy==N_LARGEST)
to_remove=m_num_remove;
else
to_remove=num_features*m_num_remove*0.01;
index_t can_remove=num_features-m_target_dim;
// if policy is to remove N feats corresponding to smallest/largest
// measures, we just replace N with can_remove. if policy is to remove
// N% feats, then we change the policy temporarily and remove a fixed
// can_remove number of feats instead
index_t orig_remove=m_num_remove;
EFeatureRemovalPolicy orig_policy=m_policy;
if (to_remove>can_remove)
{
m_num_remove=can_remove;
SG_DEBUG("Can only remove %d features in this iteration!\n",
can_remove);
if (m_policy==PERCENTILE_SMALLEST)
m_policy=N_SMALLEST;
else if (m_policy==PERCENTILE_LARGEST)
m_policy=N_LARGEST;
}
// remove appropriate number of features based on the measures and the
// removal policy. this internally update the subset for selected
// features as well
features=remove_feats(features, argsorted);
// restore original removal policy and numbers if necessary for the
// sake of consistency
if (to_remove>can_remove)
{
m_policy=orig_policy;
m_num_remove=orig_remove;
}
// update the number of features
num_features=get_num_features(features);
SG_DEBUG("Current number of features %d!\n", num_features);
}
// sanity check
ASSERT(m_subset->get_size()==m_target_dim);
SG_DEBUG("Leaving!\n");
return features;
}
void Camera::setPos(const Vec3f &pos)
{
_pos = pos;
_transform = Mat4f::lookAt(_pos, _lookAt - _pos, _up);
precompute();
}
int main (int argc, char *argv[])
{
printf("Number of haplotypes: %d\n", atoi(argv[1]) );
int temp =0;
temp = atoi(argv[1]);
printf("Number of time intervals: %d\n", atoi(argv[2]) );
printf("File name: %s\n", argv[3] );
int num_haps = atoi(argv[1]);
int num_times = atoi(argv[2]);
//make_bins(num_haps);
//readfile(argv[3]);
read_binned_file(argv[3]);
//make_custom_bins(num_haps); // one bin per match length
// printf("num_loci = %d\n", num_loci);
// printf("marker %f\n", 1.7);
// printf("a;lskdjf %d\n", 3);
make_times(num_haps, num_times);
read_quant_file(argv[4]);
precompute(num_haps, num_times);
/*
struct scenario the_scenario;
the_scenario.num_haps = argv[1];
the_scenario.num_times = argv[2];*/
size_t iter = 0;
// size_t i; // commented out to fix the problem labelled XYRQ below
// there was a comparison between signed/unsiged int
int status;
const gsl_multimin_fdfminimizer_type *T;
gsl_multimin_fdfminimizer *s;
/* Position of the minimum (1,2). */
int j=0;
double par[2];
par[0] = num_haps;
par[1] = num_times;
gsl_vector *x;
gsl_multimin_function_fdf my_func;
my_func.f = &my_f;
my_func.df = &my_df;
my_func.fdf = &my_fdf;
my_func.n = num_times;
my_func.params = ∥
/* Starting point, x = (5,7) */
x = gsl_vector_alloc (num_times);
for (j=0; j<num_times; j++)
{
if(j<=50){gsl_vector_set (x, j, 30000 );}
else {gsl_vector_set (x, j, 20000 );}
}
T = gsl_multimin_fdfminimizer_conjugate_fr;
// T = gsl_multimin_fdfminimizer_vector_bfgs2;
s = gsl_multimin_fdfminimizer_alloc (T, num_times);
// likelihood setting
gsl_multimin_fdfminimizer_set (s, &my_func, x, 10000, .000001);
// quantile setting
//gsl_multimin_fdfminimizer_set (s, &my_func, x, 3000.0, .100);
do
{
iter++;
status = gsl_multimin_fdfminimizer_iterate (s);
//printf("help %d\n", 3);
if (status){
printf ("Iteration terminated at:\nSTART HERE\n");
//printf ("%5zu ", iter); // using %zu instead of %d b/c iter is type size_t not type int
int k=0;
for (k = 0; k < num_times; k++)
{
printf ("%f\t%10.3f\n", time[k], gsl_vector_get (s->x, k)); // problem XYRQ
// using k here renders size_t i above unused
}
printf ("f() = %7.3f \n", s->f);
// q
break;}
//printf("help %d\n", 4);
//.likelihood setting
status = gsl_multimin_test_gradient (s->gradient, 1e-10 );
// quantile setting
// status = gsl_multimin_test_gradient (s->gradient, .010 );
if (status == GSL_SUCCESS)
{ printf ("Minimum found at:\nSTART HERE\n");}
int k=0;
for (k = 0; k < num_times; k++)
{
printf ("%f\t%10.3f\n", time[k], gsl_vector_get (s->x, k)); // problem XYRQ
// using k here renders size_t i above unused
}
//printf ("f() = %7.3f \n", s->f);
// printf ("Minimum found at:\n");
//
// printf ("%5zu ", iter); // using %zu instead of %d b/c iter is type size_t not type int
// int k=0;
// for (k = 0; k < num_times; k++)
// {
// printf ("%10.3e ", gsl_vector_get (s->x, k)); // problem XYRQ
// using k here renders size_t i above unused
// }
// printf ("%5d %.5f %.5f %10.5f\n", iter,
// gsl_vector_get (s->x, 0),
// gsl_vector_get (s->x, 1),
// s->f);
}
while (status == GSL_CONTINUE && iter < 1000);
gsl_multimin_fdfminimizer_free (s);
gsl_vector_free (x);
return 0;
}
static void set_property (GObject *object, guint property_id, const GValue *value, GParamSpec *pspec)
{
QCADRectangleElectrode *rc_electrode = QCAD_RECTANGLE_ELECTRODE (object) ;
switch (property_id)
{
case QCAD_RECTANGLE_ELECTRODE_PROPERTY_CX:
{
double new_cx = g_value_get_double (value) ;
if (new_cx == rc_electrode->cxWorld) break ;
rc_electrode->cxWorld = new_cx ;
precompute (QCAD_ELECTRODE (object)) ;
g_object_notify (object, "width") ;
break ;
}
case QCAD_RECTANGLE_ELECTRODE_PROPERTY_CY:
{
double new_cy = g_value_get_double (value) ;
if (new_cy == rc_electrode->cyWorld) break ;
rc_electrode->cyWorld = new_cy ;
precompute (QCAD_ELECTRODE (object)) ;
g_object_notify (object, "height") ;
break ;
}
case QCAD_RECTANGLE_ELECTRODE_PROPERTY_X_DOTS:
{
guint new_x_dots = g_value_get_uint (value) ;
if (new_x_dots == rc_electrode->n_x_divisions) break ;
rc_electrode->n_x_divisions = new_x_dots ;
precompute (QCAD_ELECTRODE (object)) ;
g_object_notify (object, "x-dots") ;
break ;
}
case QCAD_RECTANGLE_ELECTRODE_PROPERTY_Y_DOTS:
{
guint new_y_dots = g_value_get_uint (value) ;
if (new_y_dots == rc_electrode->n_y_divisions) break ;
rc_electrode->n_y_divisions = new_y_dots ;
precompute (QCAD_ELECTRODE (object)) ;
g_object_notify (object, "y-dots") ;
break ;
}
case QCAD_RECTANGLE_ELECTRODE_PROPERTY_ANGLE:
{
double new_angle = g_value_get_double (value) ;
if (new_angle == rc_electrode->angle) break ;
rc_electrode->angle = new_angle ;
precompute (QCAD_ELECTRODE (object)) ;
g_object_notify (object, "angle") ;
break ;
}
}
}
