/**
* 実際に圧縮ファイルを作る関数
*
**/
void compress(const Node *root, const char *infile)
{
FILE *ifp;
FILE *ofp;
char *p;
char *outfile;
SYMBOL c;
char writeBits = 0;
int nbit = 0;
int flag = 0;
// 出力ファイル名の作成
outfile = change_extention(infile, ".cmpd");
if ((ifp = fopen(infile, "rb")) == NULL
|| (ofp = fopen(outfile, "wb")) == NULL)
{
fprintf(stderr, "error: cannot open %s\n", infile);
exit(1);
}
free(outfile);
// 読みだして変換
while (1)
{
int i;
if ((flag = fread(&c, sizeof(c), 1, ifp)) == 1)
p = search_tree(c, root); // シンボルに対応する符号語を抽出
else
p = search_tree(NSYMBOLS - 1, root); // EOFに対応する符号語を抽出
for (i = 0; p[i] != '\0'; i++)
{
writeBits = (writeBits << 1) + (p[i] - '0');
if (++nbit == 8)
{
fwrite(&writeBits, sizeof(char), 1, ofp);
nbit = writeBits = 0;
}
}
// EOFを書き込んだら抜ける
if (!flag)
break;
}
// 1byteに満たないなら書き込んでしまう
if (nbit != 0)
{
while (nbit != 8)
{
writeBits = writeBits << 1; // 0を詰める
nbit++;
}
fwrite(&writeBits, sizeof(char), 1, ofp);
}
fclose(ifp);
fclose(ofp);
}
int main() {
int i;
int RES;
int L, T, O;
int A, B, C;
char str[5];
scanf("%d%d%d", &L, &T, &O);
build_tree(1, L, 1);
while(O--) {
scanf("%s", str);
if(str[0] == 'C') {
scanf("%d%d%d", &A, &B, &C);
if (A <= B)
change_tree(A, B, 1, L, C, 1);
else
change_tree(B, A, 1, L, C, 1);
}
else {
scanf("%d%d", &A, &B);
RES = num = 0;
if (A <= B)
search_tree(A, B, 1, L, 1);
else
search_tree(B, A, 1, L, 1);
for(i = 0; i < T; i++) {
if(num & 1)
RES++;
num >>= 1;
}
printf("%d\n", RES);
}
}
return 0;
}
binary_tree_t *search_tree(binary_tree_t *tree, int value, int level) {
binary_tree_t *found = NULL;
if (tree) {
if (tree->value == value) {
found = tree;
}
else {
#pragma omp task shared(found) if(level < 10)
{
binary_tree_t *found_left = NULL;
found_left = search_tree(tree->left, value, level + 1);
if (found_left) {
#pragma omp atomic write
found = found_left;
#pragma omp cancel taskgroup
}
}
#pragma omp task shared(found) if(level < 10)
{
binary_tree_t *found_right = NULL;
found_right = search_tree(tree->right, value, level + 1);
if (found_right) {
#pragma omp atomic write
found = found_right;
#pragma omp cancel taskgroup
}
}
#pragma omp taskwait
}
}
return found;
}
Node* Red_Black_Tree::search_tree(Node* x, int k) {
if (x == _NIL || x == 0 || x->val == k)
return x;
if (k <= x->val)
return search_tree(x->left, k);
else
return search_tree(x->right, k);
}
tree *search_tree(tree *l, int x)
{
if (l == NULL) return (NULL);
if (l->item == x) return(l);
if (x < l->item)
return (search_tree(l->left, x));
else
return (search_tree(l->right, x));
}
int search_tree(int x, struct node *p)
{
if (p == NULL)
return 0;
if (p->data == x)
return 1;
else if (p->data > x)
return search_tree(x, p->left);
else
return search_tree(x, p->right);
}
tree *search_tree(tree *t, item_type x)
{
if (t == NULL)
return NULL;
if (t->item == x)
return t;
if (t->item > x)
return search_tree(t->left, x);
else
return search_tree(t->right, x);
}
bool search_tree (int value, struct node*node) {
if (node == null) {
return false;
}
if (node-> value == value)
return true;
if (node->value < value) {
return (search_tree (value, node->left));
} else {
return (search_tree(value, node->right));
}
}
const tree* search_tree(const tree* t, const void* key,
int (*compare_keys)(const void* key1, const void* key2)) {
if(t == NULL)
return NULL;
int cmp = compare_keys(key, t->key);
if(cmp == 0)
return t;
if(cmp < 0)
return search_tree(t->left, key, compare_keys);
else
return search_tree(t->right, key, compare_keys);
}
int main(int argc, char *argv[]){
int i, start_i, end_i;
unsigned max_length = 1, length_difference = 0;
int max_end_i = 0, max_start_i = 0;
unsigned long prime_sum_difference = 0;
initialize_prime_lists();
printf("Enter upper limit for search: ");
scanf("%lu", &max);
find_all_primes_upto(max);
printf("Highest prime so far: %lu\n", prime_list[prime_list_top]);
printf("Highest prime sum so far: %lu\n", prime_sum_list[prime_list_top]);
/* print_primes(); */
printf("Max is %lu", max);
for(end_i = prime_list_top; end_i > 0; end_i--){
for(start_i = 0;(end_i - start_i + 1) > max_length; start_i++){
length_difference = end_i - start_i + 1;
prime_sum_difference = (prime_sum_list[end_i] - prime_sum_list[start_i]) + prime_list[start_i];
if(length_difference > max_length && prime_sum_difference < max && search_tree(prime_sum_difference)){
/* printf("\ns:%u e:%u len_diff:%u prime_sum_diff:%lu",start_i, end_i, length_difference, prime_sum_difference); */
if(max_length < length_difference){
max_length = length_difference; max_end_i = end_i; max_start_i = start_i;
}
}
}
}
printf("\nMAX::start:%u, length:%u, sum_diff:%lu", max_start_i, max_end_i - max_start_i + 1, prime_sum_list[max_end_i] - prime_sum_list[max_start_i] + prime_list[max_start_i]);
printf("\n");
return 0;
}
// determine the best action by searching ahead using MCTS
extern action_t search(Agent &agent, timelimit_t timelimit) {
//save agent's state
ModelUndo undo = ModelUndo(agent);
SearchNode search_tree(false, agent.numActions());
//sample
for(visits_t i = 0; i < timelimit; ++i){
search_tree.sample(agent, agent.horizon());
agent.modelRevert(undo);
}
// Choose the action that has the highest expected reward.
// We assume timelimit is large enough so that every action was sampled.
// This is asserted in main::mainLoop().
double best_reward = search_tree.child(0)->expectation();
unsigned int best_action = 0;
for (unsigned int i = 1; i < agent.numActions(); ++i) {
if (search_tree.child(i)->expectation() > best_reward) {
best_reward = search_tree.child(i)->expectation();
best_action = i;
}
}
return best_action;
}
void search_tree(int search_item, struct Node *tree){
//printf("Searching for %d\n", search_item);
if (tree != NULL){
if (search_item == tree->key){
printf("Item found.\n");
}
else if (search_item < tree->key){
search_tree(search_item, tree->left);
}
else {
search_tree(search_item, tree->right);
}
}
else printf("Item not found.\n");
}
void evaluate_game(GAME *game, int *vector, int to_depth)
{
int window[MAX_PLAYERS];
memset(window, 0, sizeof(window));
search_tree(game, vector, to_depth, window, game->current_player);
}
static int search_tree(int id, int node, int max_children, int width,
int *parent_id, int *next_max_children, int *depth)
{
int current, next, next_children;
int i;
*depth = *depth + 1;
current = node + 1;
next_children = (max_children / width) - 1;
if (id == current) {
*parent_id = node;
*next_max_children = next_children;
return 1;
}
for (i = 1; i <= width; i++) {
next = current + next_children + 1;
if (id == next) {
*parent_id = node;
*next_max_children = next_children;
return 1;
}
if (id > current && id < next) {
return search_tree(id, current, next_children, width,
parent_id, next_max_children,
depth);
}
current = next;
}
*parent_id = -1;
*next_max_children = -1;
return 0;
}
MOVE choose_move(GAME *game, int *best_vector, int to_depth)
{
int window[MAX_PLAYERS];
memset(window, 0, sizeof(window));
return search_tree(game, best_vector, to_depth, window, game->current_player);
}
void evaluate_move(GAME *game, MOVE move, int *vector, int to_depth)
{
GAME *game2 = clone_game(game);
int window[MAX_PLAYERS];
memset(window, 0, sizeof(window));
apply_move(game2, move);
search_tree(game2, vector, to_depth, window, game2->current_player);
stack_pop(&game_stack, game2);
}
void search_tree(int left, int right, int tleft, int tright, int i) {
if(left == tleft && right == tright) {
num = num | result[i][0];
return ;
}
if(result[i][1]) {
result[i << 1][1] = result[i << 1 | 1][1] = result[i][1];
result[i << 1][0] = result[i][0];
result[i << 1 | 1][0] = result[i][0];
result[i][1] = 0;
}
int mid = (tleft + tright) >> 1;
if(right <= mid)
search_tree(left, right, tleft, mid, i << 1);
else if(left >= mid + 1)
search_tree(left, right, mid + 1, tright, i << 1 | 1);
else {
search_tree(left, mid, tleft, mid, i << 1);
search_tree(mid + 1, right, mid + 1, tright, i << 1 | 1);
}
}
binary_tree_t *search_tree_parallel(binary_tree_t *tree, int value) {
binary_tree_t *found = NULL;
#pragma omp parallel shared(found, tree, value)
{
#pragma omp master
{
#pragma omp taskgroup
{
found = search_tree(tree, value, 0);
}
}
}
return found;
}
int main (int argc, char **argv){
struct timeval start, end;
long mtime, seconds, useconds;
init ();
int count, array_size = 1000*25, read_array_size;
int array[array_size];
srand(time(NULL));
for (count = 0; count < array_size; count++){
array[count] = rand();
}
struct node *root = create_tree (array_size, 2, array);
if (argc > 1)
read_array_size = atoi (argv[1]);
else
read_array_size = array_size;
int read_array[read_array_size];
int num_iterations = 25;
long sum_time = 0, ave_time, max_time = 0, min_time;
int current_iteration = 0;
while (current_iteration < num_iterations){
for (count = 0; count < read_array_size; count++){
read_array [count] = rand();
}
gettimeofday(&start, NULL);
for (count = 0; count < read_array_size; count++){
search_tree (array[count % array_size], root);// read_array[count]);
}
gettimeofday(&end, NULL);
seconds = end.tv_sec - start.tv_sec;
useconds = end.tv_usec - start.tv_usec;
mtime = ((seconds) * 1000 + useconds/1000.0);
if (current_iteration == 0){
min_time = mtime;
}
if (mtime > max_time){
max_time = mtime;
}
if (mtime < min_time){
min_time = mtime;
}
sum_time = sum_time + mtime;
current_iteration++;
}
ave_time = sum_time / num_iterations;
printf("%ld,%ld,%ld\n", ave_time, min_time, max_time);
return 0;
}
static void
tree_do_search (WTree * tree, int key)
{
size_t l;
l = strlen (tree->search_buffer);
if ((l != 0) && (key == KEY_BACKSPACE))
tree->search_buffer[--l] = '\0';
else if (key && l < sizeof (tree->search_buffer))
{
tree->search_buffer[l] = key;
tree->search_buffer[++l] = '\0';
}
if (!search_tree (tree, tree->search_buffer))
tree->search_buffer[--l] = 0;
show_tree (tree);
maybe_chdir (tree);
}
int main(int argc, char *argv[])
{
FILE *fp;
int i, x;
struct node *root;
if (argc != 2) {
printf("missing file argument\n");
return 1;
}
fp = fopen(argv[1], "r");
if (fp == NULL) {
printf("can't open %s\n", argv[1]);
return 1;
}
root = NULL;
for (i = 0; i < 20; i++) {
fscanf(fp, "%d", &x);
root = insert_data(x, root);
}
print_tree(root);
while(1) {
scanf("%d", &x);
if (x <= 0)
break;
if (search_tree(x, root) == 1)
printf("%d: Found\n", x);
else
printf("%d: Not found\n", x);
}
fclose(fp);
return 0;
}
NearestNeighborOperator<DeviceType>::NearestNeighborOperator(
MPI_Comm comm, Kokkos::View<Coordinate const **, DeviceType> source_points,
Kokkos::View<Coordinate const **, DeviceType> target_points )
: _comm( comm )
, _indices( "indices" )
, _ranks( "ranks" )
, _size( source_points.extent_int( 0 ) )
{
// NOTE: instead of checking the pre-condition that there is at least one
// source point passed to one of the rank, we let the tree handle the
// communication and just check that the tree is not empty.
// Build distributed search tree over the source points.
DistributedSearchTree<DeviceType> search_tree( _comm, source_points );
// Tree must have at least one leaf, otherwise it makes little sense to
// perform the search for nearest neighbors.
DTK_CHECK( !search_tree.empty() );
// Query nearest neighbor for all target points.
auto nearest_queries = Details::NearestNeighborOperatorImpl<
DeviceType>::makeNearestNeighborQueries( target_points );
// Perform the actual search.
Kokkos::View<int *, DeviceType> indices( "indices" );
Kokkos::View<int *, DeviceType> offset( "offset" );
Kokkos::View<int *, DeviceType> ranks( "ranks" );
search_tree.query( nearest_queries, indices, offset, ranks );
// Check post-condition that we did find a nearest neighbor to all target
// points.
DTK_ENSURE( lastElement( offset ) == target_points.extent_int( 0 ) );
// Save results.
// NOTE: we don't bother keeping `offset` around since it is just `[0, 1, 2,
// ..., n_target_poins]`
_indices = indices;
_ranks = ranks;
}
int main()
{
//入力
printf("start...\n");
char data[MAX];
int i = 0;
int n = 0;
char c;
while ((c = getchar()) != EOF) {
if (c == ' ' || c == '\n') continue;
data[i] = c;
i++;
n++;
}
const int N = n;
Node* origin = (Node*)calloc(sizeof(Node), 1);
printf("making tree starts ...\n");
for (i = 0; i < N; i++) origin = make_tree(origin, data+i, N-i);
char ans[SIZE];
printf("searching tree starts...\n");
int max_len = search_tree(origin, ans);
for (i = 1; i <= max_len; i++) {
printf("%c", ans[i]);
}
printf("\n");
return 0;
}
void
reverse_tree_info(int rank, int num_nodes, int width,
int *parent, int *num_children,
int *depth, int *max_depth)
{
int max_children;
int p, c;
/* sanity check */
if (rank >= num_nodes) {
*parent = -1;
*num_children = -1;
*depth = -1;
*max_depth = -1;
return;
}
*max_depth = dep(num_nodes, width);
if (rank == 0) {
*parent = -1;
*num_children = num_nodes - 1;
*depth = 0;
return;
}
max_children = geometric_series(width, *max_depth);
*depth = 0;
search_tree(rank, 0, max_children, width, &p, &c, depth);
if ((rank + c) >= num_nodes)
c = num_nodes - rank - 1;
*parent = p;
*num_children = c;
return;
}
void search_tree(const char *root, const char *path_from_root, file_enum_t callback, void *userptr)
{
DIR *dp = opendir(root);
if (dp)
{
while (dirent *ep = readdir(dp))
{
std::string rel_name = std::string(path_from_root) + "/" + ep->d_name;
std::string full_name = std::string(root) + "/" + ep->d_name;
if (!strcmp(ep->d_name, ".") || !strcmp(ep->d_name, "..")) {
continue;
}
if (ep->d_type & DT_DIR) {
search_tree(full_name.c_str(), rel_name.c_str(), callback, userptr);
}
else{
callback(full_name.c_str(), rel_name.substr(1).c_str(), userptr);
}
}
closedir(dp);
}
}
/* ---------------------------------------------------------------------------
.CSD: dget
.NAM:
.SHD:
.DSC: Realisierung suchen und Parameter lesen
- der Inhalt der Parameterstruktur wird bis auf die Komponenten
xt und lxt grundsaetzlich geloescht,
- alle fuer die gesuchte Realisierung nicht spezifizierten
Felder (Zeiger darauf) enthalten den NULL-Poiter!
- wurde die gesuchte Realisierung nicht gefunden, sind in parms
bis auf xt/lxt ebenfalls alle anderen Komponenten geloescht!
.RES:
.REM:
.SAL:
.EXF:
.END.
---------------------------------------------------------------------------
*/
short dget( DNORM_DCB * stream, short knr, short rnr, DPARA * parms )
{
RVB rvb;
VRVB vrvb;
char * buffer; /* Puffer fuer Daten des var.Rea.vorblocks */
char * pt;
KR_NODE * node;
char * m_xt, * m_vdt;
short m_lxt, m_lvdt;
char m_dtype[2];
double m_dres1, m_dres2, m_dres3, m_dres4, m_dres5;
long read_bytes;
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
union
{
struct
{
char l;
char h;
} b;
short s;
} val;
#endif
/* ---------- Pruefung des Argumentstreams ----------
*/
if ( stream == NULL || stream->fp == NULL ) /* garnicht offen! */
{
derrno = DNERR_CLSTREAM;
return( EOF );
}
if ( stream->fopen_mode == 'w' ||
stream->fopen_mode == 'a' ) /* nicht fuer mich! */
{
derrno = stream->err = DNERR_NOREADSTREAM;
return( EOF );
}
/* ---------- sind ueberhaupt Realisierungen im Baum? ----------
*/
if ( !stream->tree || !stream->objects )
{
derrno = stream->err = DNERR_NOREADOBJS;
return( EOF );
}
/* ---------- aktuell in parms gesetzte Parameter merken
(nur die dateiglobalen) ----------
*/
m_xt = parms->xt;
m_lxt = parms->lxt;
m_vdt = parms->vdt;
m_lvdt = parms->lvdt;
m_dtype[0] = parms->dtype[0];
m_dtype[1] = parms->dtype[1];
m_dres1 = parms->dres1;
m_dres2 = parms->dres2;
m_dres3 = parms->dres3;
m_dres4 = parms->dres4;
m_dres5 = parms->dres5;
/* ---------- aktuell in parms gesetzte realis.spezif. Parameter
loeschen ----------
*/
if ( parms->rb && parms->lrb )
dn_free( parms->rb ); /* geloescht! und der Speich*/
if ( parms->rt && parms->lrt )
dn_free( parms->rt ); /* fuer alte rb/rt/dt... */
if ( parms->dt && parms->ldt )
dn_free( parms->dt ); /* geloescht */
if ( parms->ht && parms->lht )
dn_free( parms->ht );
if ( parms->vrt && parms->lvrt )
dn_free( parms->vrt );
memset( parms, '\0', sizeof( DPARA ) ); /* */
/* ---------- gemerkte dateiglob.Parms zuruecksetzen ----------
*/
parms->xt = m_xt; /* und nun wieder xt-Angaben*/
parms->lxt = m_lxt; /* zurueckspeichern */
parms->vdt = m_vdt; /* auch property desrciption*/
parms->lvdt = m_lvdt; /* zurueckspeichern */
parms->dtype[0] = m_dtype[0];
parms->dtype[1] = m_dtype[1];
parms->dres1 = m_dres1;
parms->dres2 = m_dres2;
parms->dres3 = m_dres3;
parms->dres4 = m_dres4;
parms->dres5 = m_dres5;
/* ---------- Suche der spez. Realisierung im Realis.baum
folgende Suchvarianten werden unterstuetzt:
Fall 1: 1.knr/1.rnr der Datei (FIRST/FIRST)
Fall 2.1: naechste knr/rnr der Datei (NEXT/NEXT)
bei erstem Zugriff auf Datei (identisch
mit (FIRST/FIRST)
Fall 2.2: naechste knr/rnr der Datei (NEXT/NEXT)
bei Folgezugriff auf Datei.
Fall 3: erste rnr bei konstanter knr (knr/FIRST)
(nicht implementiert)
Fall 4: naechste rnr bei erster knr (FIRST/NEXT)
(nicht implementiert)
Fall 5: naechste rnr bei konstanter knr (knr/NEXT)
(nicht implementiert)
Fall 6: erste knr bei konstanter rnr (FIRST/rnr)
(nicht implementiert)
Fall 7: naechste knr bei erster rnr (NEXT/FIRST)
(nicht implementiert)
Fall 8: naechste knr bei konstanter rnr (NEXT/rnr)
(nicht implementiert)
Fall 9: bestimmte knr und bestimmte rnr (knr/rnr)
*/
/* ---------- Fall 1: ----------
*/
if ( knr == FIRST && rnr == FIRST ) /* erste Kl/Real. */
{
if ( node = search_tree( stream->tree,
stream->knr, stream->rnr,
SEARCH_FIRST ), /* erste Realis. */
node == NULL || node->rba == EOF ) /* Realisierung su.*/
{
derrno = stream->err = DNERR_NOKRN;
return( EOF ); /* nicht gefunden! */
}
}
else if ( knr == NEXT && rnr == NEXT ) /* naechste Kl/Real.*/
{
/* ---------- Fall 2.1: ----------
*/
if ( stream->knr == 0 && stream->rnr == 0 ) /* erster Zugriff */
{
if ( node = search_tree( stream->tree,
stream->knr, stream->rnr,
SEARCH_FIRST ), /* erste Realis. */
node == NULL || node->rba == EOF ) /* Realisierung su.*/
{
derrno = stream->err = DNERR_NOKRN;
return( EOF ); /* nicht gefunden! */
}
}
/* ---------- Fall 2.2: ----------
*/
else
{
if ( node = search_tree( stream->tree,
stream->knr, stream->rnr,
SEARCH_NEXT ), /* naechste Realis. */
node == NULL || node->rba == EOF ) /* Realisierung su.*/
{
derrno = stream->err = DNERR_NOKRN;
return( EOF ); /* nicht gefunden! */
}
}
}
/* ---------- Fall 9: ----------
*/
else /* normal spezifiz. */
{
if ( node = search_tree( stream->tree, knr, /* suchen nach knr/ */
rnr, SEARCH_KRN ), /* rnr */
node == NULL || node->rba == EOF ) /* Realisierung su.*/
{
derrno = stream->err = DNERR_NOKRN;
return( EOF ); /* nicht gefunden! */
}
}
/* ---------- tatsaechliche knr/rnr fuer stream merken ----------
*/
stream->knr = node->knr;
stream->rnr = node->rnr;
/* ---------- konstanten Realisierungsvorblock lesen ----------
*/
stream->rvb_rba = node->rba; /* Beginn des Vorbl. merken */
fseek( stream->fp, node->rba, SEEK_SET ); /* auf RVB positionieren */
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
read_bytes = read_rvb( &rvb, stream->fp );
#else
fread( &rvb, (size_t)sizeof( RVB ),
(size_t)1, stream->fp ); /* ... und RVB einlesen */
read_bytes = sizeof( RVB );
#endif
/* ---------- Rest des Realisierungsvorblocks (variablen
Teil) lesen und in vrvb aufbereiten ----------
*/
pt = buffer = dn_malloc( ((size_t)rvb.vblocks * BL_SIZE) - read_bytes );
if(fread( pt, ((size_t)rvb.vblocks * BL_SIZE) - read_bytes, /* var.Parameter einlesen */
(size_t)1, stream->fp ) != 1) {
derrno = stream->err = DNERR_NOREADSTREAM;
return( EOF );
}
memset( &vrvb, '\0', sizeof( vrvb ) ); /* keine Parameter spezifiz.*/
pt += sizeof( vrvb.rb_sign );
vrvb.lrb = *(short *)pt;
#if defined _SUNGC_
myswab( &vrvb.lrb, sizeof( vrvb.lrb ), 1 );
#endif
pt += sizeof( vrvb.lrb );
if ( vrvb.lrb == 0 ) /* Das keine RB spezifiz.ist*/
{
derrno = stream->err = DNERR_BADRB;
return( EOF ); /* ist nicht zulaessig! */
}
vrvb.rb = (RB *)pt;
pt += vrvb.lrb;
pt += sizeof( vrvb.rt_sign );
vrvb.lrt = *(short *)pt;
#if defined _SUNGC_
myswab( &vrvb.lrt, sizeof( vrvb.lrt ), 1 );
#endif
pt += sizeof( vrvb.lrt );
if ( vrvb.lrt != 0 ) /* nur, wenn rt spezifiziert*/
vrvb.rt = pt; /* sonst bleibt vrvb.rt NULL*/
pt += vrvb.lrt;
pt += sizeof( vrvb.dt_sign );
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
val.b.l = *pt++; val.b.h = *pt++;
vrvb.ldt = val.s;
#else
vrvb.ldt = *(short *)pt;
pt += sizeof( vrvb.ldt );
#endif
#if defined _SUNGC_
myswab( &vrvb.ldt, sizeof( vrvb.ldt ), 1 );
#endif
if ( vrvb.ldt != 0 ) /* nur, wenn dt spezifiziert*/
vrvb.dt = pt;
pt += vrvb.ldt;
pt += sizeof( vrvb.ht_sign );
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
val.b.l = *pt++; val.b.h = *pt++;
vrvb.lht = val.s;
#else
vrvb.lht = *(short *)pt;
pt += sizeof( vrvb.lht );
#endif
#if defined _SUNGC_
myswab( &vrvb.lht, sizeof( vrvb.lht ), 1 );
#endif
if ( vrvb.lht != 0 ) /* nur, wenn ht spezifiziert*/
vrvb.ht = pt;
pt += vrvb.lht;
pt += sizeof( vrvb.vrt_sign );
#if defined _RISCC_ || defined _OSFC_ || defined _GNUC_ || defined _SUNGC_ || defined _MSCWIN_
val.b.l = *pt++; val.b.h = *pt++;
vrvb.lvrt = val.s;
#else
vrvb.lvrt = *(short *)pt;
pt += sizeof( vrvb.lvrt );
#endif
#if defined _SUNGC_
myswab( &vrvb.lvrt, sizeof( vrvb.lvrt ), 1 );
#endif
if ( vrvb.lvrt != 0 ) /* nur,wenn vrt spezifiziert*/
vrvb.vrt = pt;
pt += vrvb.lvrt;
/* ---------- alle gelesenen Realisierungsparameter in
die Parameterstruktur parms eintragen
(wenn spezifiziert) ----------
*/
/* ---------- 1. Parameter des konstanter Parameterteils ----------
*/
parms->knr = stream->knr; /* tatsaechliche Klassennnummer */
parms->rnr = stream->rnr; /* tatsaechliche Realisierungsnr. */
parms->vanz = rvb.vanz; /* Vektoranzahl */
parms->vdim = rvb.vdim; /* Vektordimension */
parms->vsize = rvb.vsize; /* Vektorgroesse in byte */
parms->zf = rvb.zf; /* Zeitfensterfaktor */
parms->fsr = rvb.fsr; /* Fortsetzrate */
parms->ofs = rvb.ofs; /* Offset */
parms->rres1 = rvb.rres1; /* Nutzerspezif. Zellen */
parms->rres2 = rvb.rres2; /* Nutzerspezif. Zellen */
parms->rres3 = rvb.rres3; /* Nutzerspezif. Zellen */
parms->rres4 = rvb.rres4; /* Nutzerspezif. Zellen */
parms->rres5 = rvb.rres5; /* Nutzerspezif. Zellen */
parms->rb = dn_malloc( vrvb.lrb +1 );
/* ---------- lesbare Daten vorhanden? ----------
*/
if ( !parms->vanz || !parms->vdim || !parms->vsize )
{
derrno = stream->err = DNERR_NOREADOBJS;
return( EOF );
}
/* ---------- 2. Parameter variabler Laenge ----------
*/
memmove( parms->rb, vrvb.rb, (size_t)vrvb.lrb );
((char *)parms->rb)[vrvb.lrb] = '\0';
parms->lrb = vrvb.lrb;
if ( vrvb.rt )
{
parms->rt = dn_malloc( vrvb.lrt +1 );
memmove( parms->rt, vrvb.rt, (size_t)vrvb.lrt );
((char *)parms->rt)[vrvb.lrt] = '\0';
parms->lrt = vrvb.lrt;
}
if ( vrvb.dt )
{
parms->dt = dn_malloc( vrvb.ldt +1 );
memmove( parms->dt, vrvb.dt, (size_t)vrvb.ldt );
((char *)parms->dt)[vrvb.ldt] = '\0';
parms->ldt = vrvb.ldt;
}
if ( vrvb.ht )
{
parms->ht = dn_malloc( vrvb.lht +1 );
memmove( parms->ht, vrvb.ht, (size_t)vrvb.lht );
((char *)parms->ht)[vrvb.lht] = '\0';
parms->lht = vrvb.lht;
}
if ( vrvb.vrt )
{
parms->vrt = dn_malloc( vrvb.lvrt +1 );
memmove( parms->vrt, vrvb.vrt, (size_t)vrvb.lvrt );
((char *)parms->vrt)[vrvb.lvrt] = '\0';
parms->lvrt = vrvb.lvrt;
}
/* ---------- aktuelle Realisierungsdatenblockgroessen fuer
stream merken ----------
*/
stream->dat_rba = ftell( stream->fp ); /* Beginn der Daten-blocks */
stream->r_rest = rvb.vsize * rvb.vanz; /* noch zu lesende Datenbyte*/
/* ---------- Speicherfreigaben ----------
*/
dn_free( buffer );
/* ----- Systemfehler bei File-E/A pruefen -----
*/
if ( ferror( stream->fp ) )
{
perror( "dnorm sys error" );
exit( 1 );
}
derrno = stream->err = DNERR_OK;
return( 0 );
} /* end of dget() */
PNode * kmers_rec(PTree * t, PKey current_key, unsigned int size, unsigned int counter, unsigned char * contig)
{
unsigned int i,j;
unsigned int num_bases;
PKey next_key;
PNode * current_node;
PNode * next_node;
size--;
counter++;
// Copia a partir da segunda base sem o caracterer nulo do final
memcpy(next_key.base,&(current_key.base[1]),current_key.size-1);
next_key.size = current_key.size-1;
current_node = search_tree(t,next_key);
next_key.size++;
if(current_node != NULL)
{
next_node=NULL;
num_bases=0;
for(i=0;i<NUM_BASES;i++)
if( current_node->base[i]!=NULL)
if(num_bases++ > 0)
{
//contig = (unsigned char *) realloc(contig,sizeof(unsigned char)*(counter+1));
contig[counter-1]='\0';
return current_node;
}
i=0;
do {
if(current_node->base[i]!=NULL)
{
switch(i){
case 0:
next_key.base[current_key.size-1]='A';
break;
case 1:
next_key.base[current_key.size-1]='C';
break;
case 2:
next_key.base[current_key.size-1]='G';
break;
case 3:
next_key.base[current_key.size-1]='T';
break;
default:
next_key.base[current_key.size-1]='\0';
current_key.size--;
break;
}
contig = (unsigned char *) realloc(contig,sizeof(unsigned char)*(counter+1));
contig[counter]=next_key.base[current_key.size-1];
if(size > 0)
next_node = kmers_rec(t,next_key,size,counter,contig); // Recursão
}
}while( (i++<NUM_BASES) && (next_node == NULL) );
return next_node;
}
contig[counter-1]='\0';
return current_node;
}
/**
* shell_app_system_initial_search:
* @system: A #ShellAppSystem
* @terms: (element-type utf8): List of terms, logical AND
*
* Search through applications for the given search terms.
*
* Returns: (transfer container) (element-type ShellApp): List of applications
*/
GSList *
shell_app_system_initial_search (ShellAppSystem *self,
GSList *terms)
{
return search_tree (self, terms, self->priv->visible_id_to_app);
}
/**
* shell_app_system_search_settings:
* @system: A #ShellAppSystem
* @terms: (element-type utf8): List of terms, logical AND
*
* Search through settings for the given search terms.
*
* Returns: (transfer container) (element-type ShellApp): List of setting applications
*/
GSList *
shell_app_system_search_settings (ShellAppSystem *self,
GSList *terms)
{
return search_tree (self, terms, self->priv->setting_id_to_app);
}
MOVE search_tree(GAME *game, int *best_vector, int to_depth, int *window_vector, int window_player)
{
MOVE moves[MAX_MOVES];
int num_moves;
int i;
MOVE best_move = MOVE_INVALID;
int player;
unsigned int hash;
if (to_depth <= 0 || game_is_over(game))
{
evaluate_game_immediate(game, best_vector);
return best_move;
}
#ifdef USE_TRANSPOSITION_TABLE_SEARCH
hash = hash_game(game) % TRANSPOSITION_TABLE_SIZE;
if (transposition_table[hash][0] != TABLE_UNUSED)
{
memcpy(best_vector, transposition_table[hash], sizeof(int)*MAX_PLAYERS);
hit_count++;
return best_move;
}
#endif
num_moves = generate_valid_moves(game, moves);
player = game->current_player;
for (i = 0; i < num_moves; i++)
{
GAME *game2 = clone_game(game);
int vector[MAX_PLAYERS];
MOVE move;
apply_move(game2, moves[i]);
node_count++;
move = search_tree(game2, vector, to_depth - 1, best_vector, player);
if (move == MOVE_INVALID)
move = moves[i];
if (i == 0 || vector[player] > best_vector[player])
{
memcpy(best_vector, vector, sizeof(vector));
best_move = moves[i];
}
stack_pop(&game_stack, game2);
/* Prune if this move is so good for the current player that
the potential value for the window player is less than
the window. */
if (vector[player] > parameters.total_score - window_vector[window_player])
{
break;
}
}
#ifdef USE_TRANSPOSITION_TABLE_SEARCH
memcpy(transposition_table[hash], best_vector, sizeof(int)*MAX_PLAYERS);
#endif
return best_move;
}
