//------------------------------
// Hauptfunktion des Programmes
//------------------------------
int main(int argc, char *argv[]) {
int i, *fld;
int count, seed;
printf("QuickSort.c\n");
if(argc > 1)
count = atoi(argv[1]);
else
count = 10000;
if(argc > 2)
seed = atoi(argv[2]);
else
seed = 123456;
my_srand(seed);
fld = (void*) malloc(sizeof(*fld) * count);
for(i = 0; i < count; ++i)
fld[i] = my_rand();
printf("Sorting %d random numbers (seed %d)\n",
count, seed);
// Sortieren
quicksort(fld, 0, count-1);
// Ausgabe
#ifdef COUNTACTIONS
printf("Sorted. (needed %d comparisons and %d moves.\n", vergleiche, bewegungen);
#else
printf("Sorted.\n");
#endif
if(verify(fld, count))
printf("Verify succeeded.\n");
else
printf("Verify failed.\n");
return 0;
}
static void* func(void*ptr)
{
struct timeval start, end;
gettimeofday( &start, NULL );
int i;
int err;
printf("child tid:%d\n", gettid());
int max = my_rand(10);
for(i=0; i<max; i++) {
//printf("child ok\n");
sleep(1);
}
gettimeofday( &end, NULL );
printf("tid:%d,max:%d, used-time:%lu.%lu sec\n",\
gettid(),max,end.tv_sec-start.tv_sec, end.tv_usec-start.tv_usec);
pthread_exit((void *)123);
//exit(0);
//return;
}
int audio_put (int a, int c)
{
static short sample16;
int s;
if (g_add_noise) {
if ((byte_count & 1) == 0) {
sample16 = c & 0xff; /* save lower byte. */
byte_count++;
return c;
}
else {
float r;
sample16 |= (c << 8) & 0xff00; /* insert upper byte. */
byte_count++;
s = sample16; // sign extend.
/* Add random noise to the signal. */
/* r should be in range of -1 .. +1. */
/* Use own function instead of rand() from the C library. */
/* Windows and Linux have different results, messing up my self test procedure. */
/* No idea what Mac OSX and BSD might do. */
r = (my_rand() - MY_RAND_MAX/2.0) / (MY_RAND_MAX/2.0);
s += 5 * r * g_noise_level * 32767;
if (s > 32767) s = 32767;
if (s < -32767) s = -32767;
putc(s & 0xff, out_fp);
return (putc((s >> 8) & 0xff, out_fp));
}
}
else {
/**
* \name SimulationHeureEnsoleillement
* \brief Calcule le nombre d'heures d'ensoleillement de la journée
* \param Structure Simulation météo du jour, structures des normales mensuelles
* \return none
*/
void SimulationHeuresEnsoleillement(ST_DonneeMeteo NormalesMensuelles, PTR_ST_SimuMeteo Meteo_Jour)
{
//Création des variables locales
float nombre_aleatoire;
float nb_hnormales;
float r;
r=100;
//Calcul du nombre d'heure d'ensoleillement par jour de non pluie
if(Meteo_Jour->date.Mois%2==0)
{
if(Meteo_Jour->date.Mois==2)
nb_hnormales=(float)NormalesMensuelles.nb_soleil/28;
else
nb_hnormales=(float)NormalesMensuelles.nb_soleil/30;
}
else
nb_hnormales=(float)NormalesMensuelles.nb_soleil/31;
//Génération de nombres aléatoires
nombre_aleatoire=my_rand();
//Calcul du nombre d'heure d'ensoleillement
if(Meteo_Jour->condition==0)
{
Meteo_Jour->h_soleil = nombre_aleatoire*2*nb_hnormales;
//printf("0-%2.2f-%2.2f\n",nombre_aleatoire,Meteo_Jour->h_soleil);
}
if(Meteo_Jour->condition==1)
{
Meteo_Jour->h_soleil = nombre_aleatoire*1.2*nb_hnormales;
//printf("1-%2.2f-%2.2f\n",nombre_aleatoire,Meteo_Jour->h_soleil);
}
if(Meteo_Jour->condition==4)
Meteo_Jour->h_soleil = 1*nombre_aleatoire*nb_hnormales;
else
Meteo_Jour->h_soleil = 0.8*nombre_aleatoire*nb_hnormales;
}
/**
* Ein einfaches Beispielprogramm. Alle Argumente des Programms müssen
* Zahlen sein.
* Bsp:<pre>
* java Heapsort 6 13 17 42 9 3 5
* array={6,13,17,42,9,3,5}
* sorted array={3,5,6,9,13,17,42}
* </pre>
*/
int main (int argc, char *argv[]) {
// Umwandeln der Argumente in Zahlen
int *b;
int i, count, seed;
printf("Heap.c\n");
if(argc > 1)
count = atoi(argv[1]);
else
count = 10000;
if(argc > 2)
seed = atoi(argv[2]);
else
seed = 123456;
my_srand(seed);
b = (void*) malloc(sizeof(b[0]) * count);
for(i = 0; i < count; ++i)
b[i] = my_rand();
printf("Sorting %d random numbers (seed %d)\n",
count, seed);
// Sortieren
b = heapsort_(b, count);
printf("Sorted.\n");
if(verify(b, count))
printf("Verify succeeded.\n");
else
printf("Verify failed.\n");
return 0;
}
/*-----------------------------------------------------------------*/
void* Thread_work(void* rank) {
long my_rank = (long) rank;
int i, val;
double which_op;
unsigned seed = my_rank + 1;
int my_member=0, my_insert=0, my_delete=0;
int ops_per_thread = total_ops/thread_count;
for (i = 0; i < ops_per_thread; i++) {
which_op = my_drand(&seed);
val = my_rand(&seed) % MAX_KEY;
if (which_op < search_percent) {
pthread_mutex_lock(&mutex);
Member(val);
pthread_mutex_unlock(&mutex);
my_member++;
} else if (which_op < search_percent + insert_percent) {
pthread_mutex_lock(&mutex);
Insert(val);
pthread_mutex_unlock(&mutex);
my_insert++;
} else { /* delete */
pthread_mutex_lock(&mutex);
Delete(val);
pthread_mutex_unlock(&mutex);
my_delete++;
}
} /* for */
pthread_mutex_lock(&count_mutex);
member_total += my_member;
insert_total += my_insert;
delete_total += my_delete;
pthread_mutex_unlock(&count_mutex);
return NULL;
} /* Thread_work */
void
account_set_password(struct account *account, const char *pw)
{
char salt[13] = "$6$........$";
int idx;
for (idx = 3; idx < 12; idx++) {
salt[idx] = my_rand() & 63;
if (salt[idx] < 10)
salt[idx] += '0';
else if (salt[idx] < 36)
salt[idx] = salt[idx] - 10 + 'A';
else if (salt[idx] < 62)
salt[idx] = salt[idx] - 36 + 'a';
else if (salt[idx] == 63)
salt[idx] = '.';
else
salt[idx] = '/';
}
free(account->password);
account->password = strdup(crypt(pw, salt));
sql_exec("update accounts set password='******' where idnum=%d",
tmp_sqlescape(account->password), account->id);
}
//---------------------------------------------------------------------------
void t_mep_chromosome::uniform_crossover(const t_mep_chromosome &parent2, t_mep_chromosome &offspring1, t_mep_chromosome &offspring2, t_mep_parameters *parameters)
{
offspring1.code_length = code_length;
offspring2.code_length = code_length;
offspring1.num_total_variables = num_total_variables;
offspring2.num_total_variables = num_total_variables;
for (int i = 0; i < code_length; i++)
if (my_rand() % 2) {
offspring1.prg[i] = prg[i];
offspring2.prg[i] = parent2.prg[i];
}
else {
offspring1.prg[i] = parent2.prg[i];
offspring2.prg[i] = prg[i];
}
if (parameters->constants.constants_can_evolve && parameters->constants.constants_type == AUTOMATIC_CONSTANTS)
for (int c = 0; c < num_constants; c++) {
offspring1.constants_double[c] = constants_double[c];
offspring2.constants_double[c] = parent2.constants_double[c];
}
}
void readswrites( PDTV pDisk )
{
int i, j;
int xfer, num_xfer; /*to access buffer correct # times*/
long xfer_amt; /*amount to transfer to/from buffer*/
int fsize_index; /*file size index (0..8)*/
int rnum; /*rand. num to choose read or write*/
int rep1, rep2; /*indices to loop through each file*/
/*set twice, and all sets three times*/
for( rep1 = 0; rep1 < 3; rep1++ )
{ /*in order to achieve locality which*/
for( i = 0; i < NSETS; i++ )
{ /*is consistent with buffer cache data*/
for( rep2 = 0; rep2 < 2; rep2++ )
{ /*of Ousterhout et al (1985)*/
for( j = 0; j < SET_SIZE; j++ )
{
if( ( pDisk->fd = open( pDisk->files[ i ][ j ], 2)) < 0 )
{
printf( "readswrites: cannot open file\n" );
EndItAll( 1, pDisk );
}
fsize_index = *( pDisk->files[ i ][ j ] ) - '0'; /*max xfer_amt = BUFFERSIZE*/
if( pDisk->bsize[ fsize_index ] >= BUFFERSIZE )
{
num_xfer = pDisk->bsize[ fsize_index ] / BUFFERSIZE;
xfer_amt = BUFFERSIZE;
}
else
{
num_xfer = 1;
xfer_amt = pDisk->bsize[ fsize_index ];
}
rnum = my_rand( 3 );
if( rnum < 2 )
{ /*read:write = 2:1*/
lseek( pDisk->fd, 0L, 0 );
for( xfer = 0; xfer < num_xfer; xfer++ )
{
if( ( pDisk->nbytes = read( pDisk->fd, pDisk->buffer, xfer_amt)) < 0 )
{
printf( "readswrites %d: read error\n", pDisk->ulTask );
EndItAll( 1, pDisk );
}
}
}
else
{
lseek( pDisk->fd, 0L, 0 );
for( xfer = 0; xfer < num_xfer; xfer++ )
{
if( ( pDisk->nbytes = write( pDisk->fd, pDisk->buffer, xfer_amt)) < 0 )
{
printf( "readswrites %d: write error\n", pDisk->ulTask );
EndItAll( 1, pDisk );
}
}
}
close( pDisk->fd );
}
}
}
}
}
void init( PDTV pDisk )
{
int this_set; /*mark the file set (0..NSETS-1)*/
int bcount; /*counter to track #spacer files*/
int fcount; /*a counter to tell where to create*/
int i, j, k; /*files to flush buffer cache and*/
/*spread other files across disk*/
pDisk->bsize[ 0 ] = 256; pDisk->bfreq[ 0 ] = 128;
pDisk->bsize[ 1 ] = 512; pDisk->bfreq[ 1 ] = 64;
pDisk->bsize[ 2 ] = 1024; pDisk->bfreq[ 2 ] = 64;
pDisk->bsize[ 3 ] = 2048; pDisk->bfreq[ 3 ] = 64;
pDisk->bsize[ 4 ] = 4096; pDisk->bfreq[ 4 ] = 32; /*set file block sizes and*/
pDisk->bsize[ 5 ] = 8192; pDisk->bfreq[ 5 ] = 32; /*access frequencies*/
pDisk->bsize[ 6 ] = 16384; pDisk->bfreq[ 6 ] = 8;
pDisk->bsize[ 7 ] = 32768; pDisk->bfreq[ 7 ] = 2;
pDisk->bsize[ 8 ] = 65536; pDisk->bfreq[ 8 ] = 2;
k = 0; /*set up files*/
bcount = 0;
fcount = 0;
for( i = 0; i < NBLOCKSIZES; i++ )
{
for( j = 0; j < pDisk->bfreq[ i ]; j++ )
{
if( i < NBLOCKSIZES - 1 )
this_set = j % NSETS;
else
this_set = ( j + 2 ) % NSETS;
sprintf( pDisk->tmp, "%0d_%0d", i, j ); /*create filename*/
pDisk->files[ this_set ][ k ] = malloc( 1 + strlen( pDisk->tmp ));
if( ! pDisk->files[ this_set ][ k ] )
{
printf( "Could not allocate string for filename\n" );
EndItAll( 1, pDisk );
}
strcpy( pDisk->files[ this_set ][ k ], pDisk->tmp );
initfile( pDisk->tmp, pDisk->bsize[ i ], pDisk );
if( i < NBLOCKSIZES - 1 && this_set == NSETS - 1 )
k++;
if( bcount < NBFLUSH_FILES && fcount % 44 == 0 )
{
sprintf( pDisk->tmp, "%bf_%0d", bcount ); /*create spacer file*/
pDisk->buf_flush_files[ bcount ] = malloc( 1 + strlen( pDisk->tmp ));
if( ! pDisk->buf_flush_files[ bcount ] )
{
printf( "Could not allocate string for filename\n" );
EndItAll( 1, pDisk );
}
strcpy( pDisk->buf_flush_files[ bcount ], pDisk->tmp );
initfile( pDisk->tmp, BFLUSH_FILE_SIZE, pDisk );
bcount++;
}
fcount++;
}
}
for( i = 0; i < NBFLUSH_FILES; i++ )
{ /*read spacer files to flush buffers*/
if( ( pDisk->fd = open( pDisk->buf_flush_files[ i ], 2)) < 0 )
{
printf( "error opening buffer flush file\n" );
EndItAll( 1, pDisk );
}
lseek( pDisk->fd, 0L, 0 );
k = BFLUSH_FILE_SIZE / BUFFERSIZE;
for( j = 0; j < k; j++ )
{
if( ( pDisk->nbytes = read( pDisk->fd, pDisk->buffer, BUFFERSIZE )) < 0 )
{
printf( "Error reading buffer flush file\n" );
EndItAll( 1, pDisk );
}
}
close( pDisk->fd );
}
srand( SEED ); /*initialize random number generator*/
for( i = 0; i < NSETS; i++ )
{ /*permutation for reading/writing*/
for( j = SET_SIZE; j > 0; j-- )
{
k = my_rand( j );
strcpy( pDisk->tmp, pDisk->files[ i ][ j - 1 ] );
strcpy( pDisk->files[ i ][ j - 1 ], pDisk->files[ i ][ k ] );
strcpy( pDisk->files[ i ][ k ], pDisk->tmp );
}
}
}
int main(int argc, char**argv)
{
int err;
int i;
FmmvHandle _FMMV;
FmmvHandle *FMMV = &_FMMV;
void (*GEN_M)(FmmvHandle *FMMV, Box *box);
void (*GEN_L)(FmmvHandle *FMMV, Box *target, Box *source);
void (*EVAL_L)(FmmvHandle *FMMV, Box *box);
void (*EVAL_DIRECT)(FmmvHandle *FMMV, Box *target, Box *source) = FMMV->eval_direct;
_FLOAT_ X1[8*FMM_S_EXP_MAX];
_FLOAT_ X2[8*FMM_S_EXP_MAX];
_FLOAT_ X[FMM_S_EXP_MAX];
_FLOAT_ D[FMM_S_EXP_MAX];
Box _box_A;
Box _box_B;
Box _parent_A;
Box _parent_B;
int which_child_A = SWD;
int which_child_B = SWD;
Box *box_A = &_box_A;
Box *box_B = &_box_B;
Box *parent_A = &_parent_A;
Box *parent_B = &_parent_B;
int NParticles = 100;
int NTargets = 100;
_FLOAT_ (*particles)[3];
_FLOAT_ (*targets)[3] = NULL;
_FLOAT_ *charges;
_FLOAT_ x, y, z;
_FLOAT_ x_B, y_B, z_B;
_FLOAT_ x_A, y_A, z_A;
_FLOAT_ *potX;
_FLOAT_ *potL;
_FLOAT_ *exPot;
_FLOAT_ errL2;
double beta = 0.0;
int pM = 8;
int pL = 8;
int s = 8;
int *perm;
int *permTargets;
int printResult=0;
int level = 2;
_FLOAT_ size;
_FLOAT_ dx = 1;
_FLOAT_ dy = 1;
_FLOAT_ dz = 2;
feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW );
FMMV->dataKind = FMM_ST_STANDARD;
GEN_M = gen_M_ST_standard;
GEN_L = gen_L_ST_standard;
EVAL_L = eval_L_ST_standard;
#if (FMM_PRECISION==0)
EVAL_DIRECT = eval_direct_ST_standard_acc1;
#else
EVAL_DIRECT = eval_direct_ST_standard_acc2;
#endif
set_from_command_line_double(argc, argv, "beta", &beta);
set_from_command_line_bool(argc, argv, "printResult", &printResult);
set_from_command_line_int(argc, argv, "NParticles", &NParticles);
set_from_command_line_int(argc, argv, "NTargets", &NTargets);
set_from_command_line_int(argc, argv, "pM", &pM);
set_from_command_line_int(argc, argv, "pL", &pL);
set_from_command_line_int(argc, argv, "s", &s);
set_from_command_line_int(argc, argv, "level", &level);
size = ldexp(1.0, -level);
particles = (_FLOAT_ (*)[3]) calloc(NParticles, 3*sizeof(_FLOAT_));
charges = (_FLOAT_ *) calloc(NParticles, sizeof(_FLOAT_));
perm = (int *) calloc(NParticles, sizeof(int));
permTargets = (int *) calloc(NTargets, sizeof(int));
targets = (_FLOAT_ (*)[3]) calloc(NTargets, 3*sizeof(_FLOAT_));
potX = (_FLOAT_ *) calloc(NTargets, sizeof(_FLOAT_));
potL = (_FLOAT_ *) calloc(NTargets, sizeof(_FLOAT_));
exPot = (_FLOAT_ *) calloc(NTargets, sizeof(_FLOAT_));
FMMV->beta = beta;
FMMV->pM = pM;
FMMV->pL = pL;
FMMV->s_eps = s;
FMMV->particles = particles;
FMMV->charges = charges;
FMMV->perm = perm;
FMMV->NParticles = NParticles;
FMMV->targets = targets;
FMMV->permTargets = permTargets;
FMMV->NTargets = NTargets;
FMMV->scale = 1.0;
FMMV->lambda = 0;
my_srand(1481765933);
x_A = 0.5*size;
y_A = 0.5*size;
z_A = 0.5*size;
box_A->firstParticle = 0;
box_A->noOfParticles = NParticles;
parent_A->firstParticle = 0;
parent_A->noOfParticles = NParticles;
box_A->x = x_A;
box_A->y = y_A;
box_A->z = z_A;
box_A->level = level;
parent_A->level = level-1;
box_A->M = 0;
x_B = x_A + size*dx;
y_B = y_A + size*dy;
z_B = z_A + size*dz;
box_B->firstTarget = 0;
box_B->noOfTargets = NTargets;
parent_B->firstTarget = 0;
parent_B->noOfTargets = NTargets;
box_B->x = x_B;
box_B->y = y_B;
box_B->z = z_B;
box_B->level = level;
parent_B->level = level-1;
box_B->L = 0;
for (i=0; i<8; i++) {
parent_A->child[i] = 0;
parent_B->child[i] = 0;
}
parent_A->child[which_child_A] = box_A;
parent_B->child[which_child_B] = box_B;
for (i=0;i<NParticles;i++) {
x = x_A + size*(my_rand() / (_FLOAT_) MY_RAND_MAX - 0.5);
y = y_A + size*(my_rand() / (_FLOAT_) MY_RAND_MAX - 0.5);
z = z_A + size*(my_rand() / (_FLOAT_) MY_RAND_MAX - 0.5);
particles[i][0] = x;
particles[i][1] = y;
particles[i][2] = z;
}
for (i=0;i<NParticles;i++) {
perm[i] = i;
charges[i] = 1.0;
}
for (i=0;i<NTargets;i++) {
x = x_B + size*(my_rand() / (_FLOAT_) MY_RAND_MAX - 0.5);
y = y_B + size*(my_rand() / (_FLOAT_) MY_RAND_MAX - 0.5);
z = z_B + size*(my_rand() / (_FLOAT_) MY_RAND_MAX - 0.5);
targets[i][0] = x;
targets[i][1] = y;
targets[i][2] = z;
}
for (i=0;i<NTargets;i++) {
permTargets[i] = i;
}
init_all(FMMV);
err = ida_allocate(FMMV);
copy_particles(FMMV);
copy_charges(FMMV);
zero_pot(FMMV);
EVAL_DIRECT(FMMV, box_B, box_A);
FMMV->potentials = exPot;
backcopy_pot(FMMV);
GEN_M(FMMV, box_A);
GEN_L(FMMV, box_B, box_A);
zero_pot(FMMV);
EVAL_L(FMMV, box_B);
FMMV->potentials = potL;
backcopy_pot(FMMV);
/**********************************************/
for (i=0;i<6;i++) {
box_B->X[i] = 0;
}
box_B->X[XU] = X;
for (i=0;i<pL*(pL+1);i++) {
box_B->L[i] = 0.0;
}
init_M2L(FMMV, -1);
init_M2L(FMMV, level);
M2X(FMMV, 0, parent_A, X1, X2);
gen_diag_X2X(ldexp(beta,-level), FMMV->lambda, FMMV->M, FMMV->s_eps, FMMV->s_exp, dx, dy, dz, D);
VEC_MUL_C(FMMV->s_exp/2, D, X1+FMMV->s_exp*which_child_A, box_B->X[XU]);
X2L(FMMV, 0, parent_B, 0);
finish_M2L(FMMV);
zero_pot(FMMV);
EVAL_L(FMMV, box_B);
FMMV->potentials = potX;
backcopy_pot(FMMV);
/**********************************************/
ida_free(FMMV);
relL2Err(0, 0, 0);
if (printResult) {
printf("\n Pot(L) Pot(exact) rel.err.\n");
printf("============================================\n");
}
for (i=0; i<NTargets; i++) {
relL2Err(1, potL[i], exPot[i]); /* accumulate */
if (printResult) {
printf("%3i %12.4e %12.4e %12.4e\n", i, (double) potL[i], (double) exPot[i], (double) relErr(potL[i], exPot[i]));
}
}
errL2 = relL2Err(2, 0, 0); /*finalize*/
printf ("\nerr_L2(potL) = %.4e\n", errL2);
relL2Err(0, 0, 0);
if (printResult) {
printf("\n Pot(X) Pot(exact) rel.err.\n");
printf("============================================\n");
}
for (i=0; i<NTargets; i++) {
relL2Err(1, potX[i], exPot[i]); /* accumulate */
if (printResult) {
printf("%3i %12.4e %12.4e %12.4e\n", i, (double) potX[i], (double) exPot[i], (double) relErr(potX[i], exPot[i]));
}
}
errL2 = relL2Err(2, 0, 0); /*finalize*/
printf ("\nerr_L2(potX) = %.4e\n", errL2);
// TODO: deallocate...
finish_all(FMMV);
return 0;
}
int main()
{
#ifdef DEBUG
logfile_create("test.log", 3);
//logfile_create("stdout", 4);
#endif
HashTable* ht;
char key[64];
int valuesize = 8;
char val[64];
unsigned int attrformat[3] = {4, 3, 1};
unsigned int attrarray[3][3] = { {8, 3, 1}, { 7, 2,1}, {6, 2, 1} };
int num = 100;
int attrnum = 3;
int ret;
int i = 0;
char *conffile;
char *name = "test";
conffile = "memlink.conf";
DINFO("config file: %s\n", conffile);
myconfig_create(conffile);
my_runtime_create_common("memlink");
ht = g_runtime->ht;
hashtable_create_table(ht, name, valuesize, attrformat, attrnum, MEMLINK_LIST, 0);
Table *tb = hashtable_find_table(ht, name);
///////////begin test;
//test1 : hashtable_add_info_attr - create key
for (i = 0; i < num; i++) {
sprintf(key, "heihei%03d", i);
table_create_node(tb, key);
}
for (i = 0; i < num; i++) {
sprintf(key, "heihei%03d", i);
HashNode* pNode = table_find(tb, key);
if (NULL == pNode) {
DERROR("hashtable_add_info_attr error. can not find %s\n", key);
return -1;
}
}
///////test : hashtable_add_attr insert num value
HashNode *node = NULL;
DataBlock *dbk = NULL;
char *item = NULL;
int pos = 0;
for (i = 0; i < num; i++) {
sprintf(val, "value%03d", i);
pos = i;
ret = hashtable_insert(ht, name, key, val, attrarray[i%3], attrnum, pos);
if (ret < 0) {
DERROR("add value err: %d, key:%s, value:%s, pos:%d\n", ret, key, val, pos);
return ret;
}
ret = table_find_value(tb, key, val, &node, &dbk, &item);
if (ret < 0) {
DERROR("not found value: %d, %s\n", ret, key);
return ret;
}
}
DINFO("insert %d values ok!\n", num);
//////////test 4 :tag
for (i = 0; i < num; i++) {
HashNode *node = NULL;
DataBlock *dbk = NULL;
char *item = NULL;
int v = my_rand(num);
sprintf(val, "value%03d", v);
int tag = my_rand(2);
//printf("val:%s, tag:%d \n", val, tag);
//hashtable_find_value(ht, key, val, &node, &dbk, &item);
int ret = hashtable_tag(ht, name, key, val, tag);
if (MEMLINK_OK != ret) {
DERROR("err hashtable_tag val:%s, tag:%d\n", val, tag);
return ret;
}
ret = table_find_value(tb, key, val, &node, &dbk, &item);
if (ret < 0) {
DERROR("not found value: %d, %s\n", ret, key);
return ret;
}
char attr[HASHTABLE_ATTR_MAX_ITEM * HASHTABLE_ATTR_MAX_BYTE] = {0};
char *mdata = item + tb->valuesize;
memcpy(attr, mdata, tb->attrsize);
char flag = *(attr + 0) & 0x02;
flag = flag >> 1;
//printf("flag:%d, tag:%d \n", flag, tag);
if (flag != tag) {
DERROR("tag err val:%s, flag:%d, tag:%d!\n", val, flag, tag);
break;
}
}
DINFO("hashtable_tag test end!\n");
return 0;
}
void PlummerSphere::DumpModel()
{
double tm = 1.0;
double pmas = tm/nall;
double conv = 3.0*M_PI/16.0;
std::cout << "pmas = " << pmas << "\n";
uint64 i = 0;
while(i < nall) {
double X1 = my_rand();
double X2 = my_rand();
double X3 = my_rand();
double R = 1.0/sqrt( (pow(X1,-2.0/3.0) - 1.0) );
if(R < 100.0) {
double Z = (1.0 - 2.0*X2)*R;
double X = sqrt(R*R - Z*Z) * cos(2.0*M_PI*X3);
double Y = sqrt(R*R - Z*Z) * sin(2.0*M_PI*X3);
double Ve = sqrt(2.0)*pow( (1.0 + R*R), -0.25 );
double X4 = 0.0;
double X5 = 0.0;
while( 0.1*X5 >= X4*X4*pow( (1.0-X4*X4), 3.5) ) {
X4 = my_rand(); X5 = my_rand();
}
double V = Ve*X4;
double X6 = my_rand();
double X7 = my_rand();
double Vz = (1.0 - 2.0*X6)*V;
double Vx = sqrt(V*V - Vz*Vz) * cos(2.0*M_PI*X7);
double Vy = sqrt(V*V - Vz*Vz) * sin(2.0*M_PI*X7);
X *= conv;
Y *= conv;
Z *= conv;
Vx /= sqrt(conv);
Vy /= sqrt(conv);
Vz /= sqrt(conv);
ms[i] = pmas;
px[i] = X;
py[i] = Y;
pz[i] = Z;
vx[i] = Vx;
vy[i] = Vy;
vz[i] = Vz;
i++;
} /* if(r < 100.0) */
} /* while(i < N) */
std::stringstream new_file;
new_file << "model_" << nall/1024 << ".cdf";
WriteCDF(new_file.str().c_str());
}
int main()
{
int array_size = 20;
// int cycle_length = 128/8;
int cycle_length = 2;
TYPE array[array_size];
TYPE array_check[array_size];
int i = 0;
int j = 0;
int k = 0;
TYPE tmp = NULL;
TYPE tmp_bak = NULL;
int count = 20;
printf("-----------------------------\n");
while(count--)
{
for(i = 0; i < array_size; i++)
array[i] = &array[i];
for (i = 0; i < array_size; i++)
printf("0x%lx ", (long)array[i]);
printf("\n");
for(i = 0; i < array_size; i++)
array_check[i] = NULL;
for (i = array_size-1; i > cycle_length; i--)
{
j = my_rand(i/cycle_length) * cycle_length + (i%cycle_length);
// j = rand()%(i/cycle_length) * cycle_length + (i%cycle_length);
// j = rand()%i;
tmp = array[i];
array[i] = array[j];
array[j] = tmp;
}
for (i = 0; i < array_size; i++)
printf("0x%lx ", (long)array[i]);
printf("\n");
for(k = 0; k < cycle_length; k++)
{
array_subscript = k;
i = cycle_length + k;
tmp = array[k];
array_check[k] = tmp;
while(i < (array_size-cycle_length+k)) // check no loop in the array[]
{
tmp_bak = tmp;
tmp = (void*)*(long*)tmp;
for(j = k; j < i; j = (j+cycle_length))
{
/* test whether have a round in the pointer chasing array, if it does have, pick up one element which not in array_check[], to exchange which array[tmp_bak] */
if(array_check[j] == tmp)
{
printf("?????????????????????????????????????????\n");
exchange_element(array,find_one_noloop_element(array, array_check, cycle_length, array_size, i, k),tmp_bak);
tmp = (void*)*(long*)tmp_bak;
}
}
array_check[i] = tmp;
i = i + cycle_length;
}
}
for(i = 0; i < array_size; i++)
printf("0x%lx ", (long)array[i]);
printf("\n");
for (i = 0; i < array_size; i++)
printf("0x%lx ", (long)array_check[i]);
printf("\n");
printf("-----------------------------\n");
}
return 0;
}
unsigned int sad(int test_blockx, int test_blocky, int *best_block_x, int *best_block_y, int iterations)
{
unsigned char b[256][256];
unsigned char a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15;
unsigned char b0, b1, b2, b3, b4, b5, b6, b7, b8, b9, b10, b11, b12, b13, b14, b15;
int i, x, y, blocky;
unsigned tmp_diff, min_diff = 0xFFFFFFFF; // MAX_UINT
// Fill in some random values to compare
for(x = 0; x < 256; x++)
for(y = 0; y < 256; y++)
b[y][x] = (unsigned char) my_rand() % 255;
// Execute Block matching 100 times
for(i = 0; i < iterations; i++)
{
// Iterate over whole frame, x,y=coords of current block
for(x = 1; x < 256 - 16; x++)
for(y = 0; y < 256 - 16; y++)
{
tmp_diff = 0;
// Compare current Block with reference block
for(blocky = 0; blocky < 16; blocky++)
{
// Vektor Loads
a0 = b[blocky][0];
a1 = b[blocky][1];
a2 = b[blocky][2];
a3 = b[blocky][3];
a4 = b[blocky][4];
a5 = b[blocky][5];
a6 = b[blocky][6];
a7 = b[blocky][7];
a8 = b[blocky][8];
a9 = b[blocky][9];
a10 = b[blocky][10];
a11 = b[blocky][11];
a12 = b[blocky][12];
a13 = b[blocky][13];
a14 = b[blocky][14];
a15 = b[blocky][15];
b0 = b[blocky + y][x + 0];
b1 = b[blocky + y][x + 1];
b2 = b[blocky + y][x + 2];
b3 = b[blocky + y][x + 3];
b4 = b[blocky + y][x + 4];
b5 = b[blocky + y][x + 5];
b6 = b[blocky + y][x + 6];
b7 = b[blocky + y][x + 7];
b8 = b[blocky + y][x + 8];
b9 = b[blocky + y][x + 9];
b10 = b[blocky + y][x + 10];
b11 = b[blocky + y][x + 11];
b12 = b[blocky + y][x + 12];
b13 = b[blocky + y][x + 13];
b14 = b[blocky + y][x + 14];
b15 = b[blocky + y][x + 15];
// psadpw, would be nice if this could be done by loop unrolling
tmp_diff += ((a0 > b0) ? (a0 - b0) : (b0 - a0)) +
((a1 > b1) ? (a1 - b1) : (b1 - a1)) +
((a2 > b2) ? (a2 - b2) : (b2 - a2)) +
((a3 > b3) ? (a3 - b3) : (b3 - a3)) +
((a4 > b4) ? (a4 - b4) : (b4 - a4)) +
((a5 > b5) ? (a5 - b5) : (b5 - a5)) +
((a6 > b6) ? (a6 - b6) : (b6 - a6)) +
((a7 > b7) ? (a7 - b7) : (b7 - a7)) +
((a8 > b8) ? (a8 - b8) : (b8 - a8)) +
((a9 > b9) ? (a9 - b9) : (b9 - a9)) +
((a10 > b10) ? (a10 - b10) : (b10 - a10)) +
((a11 > b11) ? (a11 - b11) : (b11 - a11)) +
((a12 > b12) ? (a12 - b12) : (b12 - a12)) +
((a13 > b13) ? (a13 - b13) : (b13 - a13)) +
((a14 > b14) ? (a14 - b14) : (b14 - a14)) +
((a15 > b15) ? (a15 - b15) : (b15 - a15));
}
// Check if the current block is least different
if(min_diff > tmp_diff)
{
min_diff = tmp_diff;
*best_block_x = x;
*best_block_y = y;
}
}
}
return(min_diff);
}
inline int my_rangeRand(int min, int max)
{
return ( min + ( my_rand() / D_RAND_MAX * (max - min) ) );
}
int main(int argc, char *argv[])
{
if(argc == 2)
{
N = atoi(argv[1]);
}
else
{
printf("usage: ''gen-plum.exe 16'' (16KB particle) \n\n");
printf("Warning!!! using the default number of stars: 16384 (16KB) \n");
N = 16;
// exit(argc);
}
N = N*KB;
/* VIR = 2*EK + EG ~ 0 => ETOT = EK + EG = -EK = EG/2 */
/* G = M = R = 1 => E_tot = -3*Pi/64 */
// conv = 1.0;
// EK_teor = 3.0*Pi/64.0;
/* G = M = 1; R = 3*Pi/16 => E_tot = -0.25 */
// conv = 3.0*Pi/16.0;
// EK_teor = 0.25;
/* G = M = 1; R = 3*Pi/16 => E_tot = -0.25 */ // DOM STUPID STUFF
conv = 0.05;
EK_teor = 0.25;
/* INIT the rand() !!! */
srand(19640916); /* it is just my birthday :-) */
/* srand(time(NULL)); */
i = 0;
while(i < N)
{
X1 = my_rand();
X2 = my_rand();
X3 = my_rand();
R = 1.0/sqrt( (pow(X1,-2.0/3.0) - 1.0) );
if(R < 100.0)
{
Z = (1.0 - 2.0*X2)*R;
X = sqrt(R*R - Z*Z) * cos(2.0*M_PI*X3);
Y = sqrt(R*R - Z*Z) * sin(2.0*M_PI*X3);
Ve = sqrt(2.0)*pow( (1.0 + R*R), -0.25 );
X4 = 0.0;
X5 = 0.0;
while( 0.1*X5 >= X4*X4*pow( (1.0-X4*X4), 3.5) )
{
X4 = my_rand();
X5 = my_rand();
}
V = Ve*X4;
X6 = my_rand();
X7 = my_rand();
Vz = (1.0 - 2.0*X6)*V;
Vx = sqrt(V*V - Vz*Vz) * cos(2.0*M_PI*X7);
Vy = sqrt(V*V - Vz*Vz) * sin(2.0*M_PI*X7);
X *= conv;
Y *= conv;
Z *= conv;
Vx /= sqrt(conv);
Vy /= sqrt(conv);
Vz /= sqrt(conv);
m[i] = M/N;
x[i][0] = X;
x[i][1] = Y;
x[i][2] = Z;
v[i][0] = Vx;
v[i][1] = Vy;
v[i][2] = Vz;
/*
tmp_i = ldiv(i, 256);
if(tmp_i.rem == 0) printf("i = %d \n", i);
*/
tmp_i = ldiv(i, N/64);
if(tmp_i.rem == 0)
{
printf(".");
fflush(stdout);
}
i++;
} /* if(r < 100.0) */
} /* while(i < N) */
if(CMCORR == 1)
{
mcm = 0.0;
for(k=0; k<3; k++)
{
xcm[k] = 0.0;
vcm[k] = 0.0;
} /* k */
for(i=0; i<N; i++)
{
mcm += m[i];
for(k=0; k<3; k++)
{
xcm[k] += m[i] * x[i][k];
vcm[k] += m[i] * v[i][k];
} /* k */
} /* i */
for(k=0; k<3; k++)
{
xcm[k] /= mcm;
vcm[k] /= mcm;
} /* k */
for(i=0; i<N; i++)
{
for(k=0; k<3; k++)
{
x[i][k] -= xcm[k];
v[i][k] -= vcm[k];
} /* k */
} /* i */
} /* if(CMCORR == 1) */
out = fopen("data.inp","w");
fprintf(out,"%04d \n", 0);
fprintf(out,"%06d \n", N);
fprintf(out,"%.16E \n", 0.0);
for(i=0; i<N; i++)
{
fprintf(out,"%06d %.16E % .16E % .16E % .16E % .16E % .16E % .16E \n",
i, m[i], x[i][0], x[i][1], x[i][2], v[i][0], v[i][1], v[i][2]);
EK += 0.5*m[i] * (v[i][0]*v[i][0] + v[i][1]*v[i][1] + v[i][2]*v[i][2]);
}
printf("\n");
printf("N = %d EK = % .6E EK_teor = % .6E DE/EK = % .6E \n",
N, EK, EK_teor, (EK-EK_teor)/EK_teor);
fclose(out);
return(0);
}
//done
static void inc_c(cpu *pcpu) {
pcpu->cx++;
if (CPU_falla())
pcpu->cx-=my_rand(-1,1);
pcpu->ip++;
}
//done
static void sub_ac(cpu *pcpu) {
pcpu->ax = pcpu->ax - pcpu->cx;
if (CPU_falla())
pcpu->ax-=my_rand(-1,1);
pcpu->ip++;
}
//done
static void dec_c(cpu *pcpu) {
pcpu->cx--;
if (CPU_falla())
pcpu->cx+=my_rand(-1,1);
pcpu->ip++;
}
gboolean play_game(gpointer data)
{
int i;
if (playing == FALSE) { //如果游戏还没开始，初始化游戏并开始
init_game();
set_label();
playing = TRUE;
return TRUE;
}
snake_run();
switch (snake.direction) {
case UP:
snake.body[0].y = snake.body[0].y - 1;
//判断是否有向自己身体走的情况，如果有就改变方向
//头部[0]和身体[2]的坐标(x或y)相同，就需要向反方向改变
if (snake.body[0].y == snake.body[2].y) {
snake.direction = DOWN;
snake.body[0].y = snake.body[0].y + 2;
}
break;
case DOWN:
snake.body[0].y = snake.body[0].y + 1;
if (snake.body[0].y == snake.body[2].y) {
snake.direction = UP;
snake.body[0].y = snake.body[0].y - 2;
}
break;
case LEFT:
snake.body[0].x = snake.body[0].x - 1;
if (snake.body[0].x == snake.body[2].x) {
snake.direction = RIGHT;
snake.body[0].x = snake.body[0].x + 2;
}
break;
case RIGHT:
snake.body[0].x = snake.body[0].x + 1;
if (snake.body[0].x == snake.body[2].x) {
snake.direction = LEFT;
snake.body[0].x = snake.body[0].x - 2;
}
break;
default:
break;
}
//判断蛇的头部是否碰到了自己的身体，如果碰到了就去死！
for (i = 4; i <= snake.length; i++)
if (snake.body[0].x == snake.body[i].x
&& snake.body[0].y == snake.body[i].y)
snake.live = FALSE;
//判断蛇是否碰到边界，如果碰到了就去死！
if (snake.body[0].x < 0 || snake.body[0].y < 0
|| snake.body[0].x > 40 || snake.body[0].y > 40) {
snake.live = FALSE;
}
//判断蛇是否死了
if (she.live == FALSE) {
live = live - 1;
if (live == 0) { //没命就GAME OVER
speed = 200;
level = 1;
foods = 20;
live = 3;
game_stop();
gtk_label_set_text(GTK_LABEL(label), " - Game Over -");
return FALSE;
}
//还有命就继续
set_label();
init_game();
}
//判断蛇是否吃到了蛋，如果吃到了就变长！
if (snake.body[0].x == food.x && snake.body[0].y == food.y) {
snake.length = snake.length + 1;
snake.body[snake.length].x = snake.body[snake.length - 1].x;
snake.body[snake.length].y = snake.body[snake.length - 1].y;
//重新生成一个蛋
food.x = my_rand(0, 20);
food.y = food.x;
foods = foods - 1; //减少一个蛋
if (foods == 0) { //如果吃完全部的蛋，进入下一局，速度加快
level = level + 1;
foods = 20;
if (speed > 30)
speed = speed - 20;
game_stop();
game_start();
}
set_label();
}
draw();
return TRUE;
}
int main(int argc, char**argv)
{
int err;
int i;
double t0, t1;
FmmvHandle _FMMV;
FmmvHandle *FMMV = &_FMMV;
void (*GEN_M)(FmmvHandle *FMMV, Box *box);
void (*EVAL_M)(FmmvHandle *FMMV, Box *target, Box *source);
void (*EVAL_L)(FmmvHandle *FMMV, Box *box);
void (*GEN_L)(FmmvHandle *FMMV, Box *target, Box *source);
void (*GEN_L_EVAL_M)(FmmvHandle *FMMV, Box *target, Box *source);
void (*EVAL_DIRECT)(FmmvHandle *FMMV, Box *target, Box *source) = FMMV->eval_direct;
Box _box_A;
Box _box_B;
Box *box_A = &_box_A;
Box *box_B = &_box_B;
Box _child_A[4];
Box _child_B[4];
int NParticles = 100;
int NTargets = 100;
_FLOAT_ (*particles)[2];
_FLOAT_ (*targets)[2] = NULL;
_FLOAT_ *charges;
_FLOAT_ (*dipoleMoments)[2] = NULL;
_FLOAT_ x, y;
_FLOAT_ *potM;
_FLOAT_ *potL;
_FLOAT_ (*gradM)[2] = NULL;
_FLOAT_ (*gradL)[2] = NULL;
_FLOAT_ *exPot;
_FLOAT_ (*exGrad)[2] = NULL;
_FLOAT_ errL2, errL2grad;
double beta = 0.0;
int pM = 8;
int pL = 8;
int s = 8;
int *perm;
int *permTargets;
int with_dipoleSources=0;
int with_gradients=0;
int LM_combined=0;
int with_M2M=0;
int with_L2L=0;
int printResult=0;
#ifdef USE_SINGLE_PRECISION
int exAcc=1;
#else
int exAcc=2;
#endif
//int exAcc=0;
_FLOAT_ x_A = .125;
_FLOAT_ y_A = .125;
double size_A = .0625;
int level_A = 2;
_FLOAT_ x_B = .875;
_FLOAT_ y_B = .875;
double size_B = .0625;
int level_B = 2;
feenableexcept(FE_DIVBYZERO | FE_INVALID | FE_OVERFLOW );
set_from_command_line_double(argc, argv, "beta", &beta);
set_from_command_line_bool(argc, argv, "dipoleSources", &with_dipoleSources);
set_from_command_line_bool(argc, argv, "gradients", &with_gradients);
set_from_command_line_bool(argc, argv, "printResult", &printResult);
set_from_command_line_bool(argc, argv, "LM_combined", &LM_combined);
set_from_command_line_bool(argc, argv, "M2M", &with_M2M);
set_from_command_line_bool(argc, argv, "L2L", &with_L2L);
set_from_command_line_int(argc, argv, "directEvalAccuracy", &exAcc);
if (with_dipoleSources) {
if (with_gradients) {
FMMV->dataKind = FMM_ST_DIPOLE_GRAD;
GEN_M = gen_M_ST_dipole_grad;
EVAL_M = eval_M_ST_dipole_grad;
GEN_L = gen_L_ST_dipole_grad;
EVAL_L = eval_L_ST_dipole_grad;
GEN_L_EVAL_M = gen_L_eval_M_dipole_grad;
switch (exAcc) {
case 0: EVAL_DIRECT = eval_direct_ST_dipole_grad_acc0; break;
case 1: EVAL_DIRECT = eval_direct_ST_dipole_grad_acc1; break;
#if FMM_PRECISION==1
case 2: EVAL_DIRECT = eval_direct_ST_dipole_grad_acc2; break;
#endif
}
}
else {
FMMV->dataKind = FMM_ST_DIPOLE;
GEN_M = gen_M_ST_dipole;
EVAL_M = eval_M_ST_dipole;
GEN_L = gen_L_ST_dipole;
EVAL_L = eval_L_ST_dipole;
GEN_L_EVAL_M = gen_L_eval_M_dipole;
switch (exAcc) {
case 0: EVAL_DIRECT = eval_direct_ST_dipole_acc0; break;
case 1: EVAL_DIRECT = eval_direct_ST_dipole_acc1; break;
#if FMM_PRECISION==1
case 2: EVAL_DIRECT = eval_direct_ST_dipole_acc2; break;
#endif
}
}
}
else {
if (with_gradients) {
FMMV->dataKind = FMM_ST_GRAD;
GEN_M = gen_M_ST_grad;
EVAL_M = eval_M_ST_grad;
GEN_L = gen_L_ST_grad;
EVAL_L = eval_L_ST_grad;
GEN_L_EVAL_M = gen_L_eval_M_grad;
switch (exAcc) {
case 0: EVAL_DIRECT = eval_direct_ST_grad_acc0; break;
case 1: EVAL_DIRECT = eval_direct_ST_grad_acc1; break;
#if FMM_PRECISION==1
case 2: EVAL_DIRECT = eval_direct_ST_grad_acc2; break;
#endif
}
}
else {
FMMV->dataKind = FMM_ST_STANDARD;
GEN_M = gen_M_ST_standard;
EVAL_M = eval_M_ST_standard;
GEN_L = gen_L_ST_standard;
EVAL_L = eval_L_ST_standard;
GEN_L_EVAL_M = gen_L_eval_M_standard;
switch (exAcc) {
case 0: EVAL_DIRECT = eval_direct_ST_standard_acc0; break;
case 1: EVAL_DIRECT = eval_direct_ST_standard_acc1; break;
#if FMM_PRECISION==1
case 2: EVAL_DIRECT = eval_direct_ST_standard_acc2; break;
#endif
}
}
}
set_from_command_line_int(argc, argv, "NParticles", &NParticles);
set_from_command_line_int(argc, argv, "NTargets", &NTargets);
set_from_command_line_int(argc, argv, "pM", &pM);
set_from_command_line_int(argc, argv, "pL", &pL);
set_from_command_line_int(argc, argv, "s", &s);
set_from_command_line_int(argc, argv, "level_A", &level_A);
set_from_command_line_int(argc, argv, "level_B", &level_B);
// set_from_command_line_double(argc, argv, "size_A", &size_A);
// set_from_command_line_double(argc, argv, "size_B", &size_B);
size_A = ldexp(1.0, -level_A);
size_B = ldexp(1.0, -level_B);
particles = (_FLOAT_ (*)[2]) calloc(NParticles, 2*sizeof(_FLOAT_));
charges = (_FLOAT_ *) calloc(NParticles, sizeof(_FLOAT_));
perm = (int *) calloc(NParticles, sizeof(int));
permTargets = (int *) calloc(NTargets, sizeof(int));
targets = (_FLOAT_ (*)[2]) calloc(NTargets, 2*sizeof(_FLOAT_));
potM = (_FLOAT_ *) calloc(NTargets, sizeof(_FLOAT_));
potL = (_FLOAT_ *) calloc(NTargets, sizeof(_FLOAT_));
exPot = (_FLOAT_ *) calloc(NTargets, sizeof(_FLOAT_));
if (with_gradients) {
gradM = (_FLOAT_ (*)[2]) calloc(NTargets, 2*sizeof(_FLOAT_));
gradL = (_FLOAT_ (*)[2]) calloc(NTargets, 2*sizeof(_FLOAT_));
exGrad = (_FLOAT_ (*)[2]) calloc(NTargets, 2*sizeof(_FLOAT_));
}
if (with_dipoleSources) {
dipoleMoments = (_FLOAT_ (*)[2]) calloc(NParticles, 2*sizeof(_FLOAT_));
}
FMMV->beta = beta;
FMMV->pM = pM;
FMMV->pL = pL;
FMMV->s_eps = s;
FMMV->particles = particles;
FMMV->charges = charges;
FMMV->dipoleMoments = dipoleMoments;
FMMV->perm = perm;
FMMV->NParticles = NParticles;
FMMV->targets = targets;
FMMV->permTargets = permTargets;
FMMV->NTargets = NTargets;
FMMV->scale = 1.0;
FMMV->lambda = 0;
my_srand(1481765933);
box_A->firstParticle = 0;
box_A->noOfParticles = NParticles;
box_A->x = x_A;
box_A->y = y_A;
box_A->level = level_A;
box_A->M = 0;
/* if (with_M2M) */ {
int m = NParticles/4;
double d = 0.25*size_A;
int c;
for (c=0; c<4; c++) {
box_A->child[c] = &_child_A[c];
box_A->child[c]->level = level_A + 1;
box_A->child[c]->M = 0;
box_A->child[c]->firstParticle = c*m;
box_A->child[c]->noOfParticles = m;
}
box_A->child[3]->noOfParticles = NParticles - box_A->child[3]->firstParticle;
box_A->child[SW]->x = x_A - d;
box_A->child[SW]->y = y_A - d;
box_A->child[NW]->x = x_A - d;
box_A->child[NW]->y = y_A + d;
box_A->child[SE]->x = x_A + d;
box_A->child[SE]->y = y_A - d;
box_A->child[NE]->x = x_A + d;
box_A->child[NE]->y = y_A + d;
for (c=0; c<4; c++) {
for (i = box_A->child[c]->firstParticle; i < box_A->child[c]->firstParticle+box_A->child[c]->noOfParticles; i++) {
x = box_A->child[c]->x + 2.0*d*(my_rand() / (_FLOAT_) MY_RAND_MAX) - d;
y = box_A->child[c]->y + 2.0*d*(my_rand() / (_FLOAT_) MY_RAND_MAX) - d;
particles[i][0] = x;
particles[i][1] = y;
}
}
}
/* else {
double d = size_A/2.0;
for (i=0;i<NParticles;i++) {
x = x_A + size_A*(my_rand() / (_FLOAT_) MY_RAND_MAX) - d;
y = y_A + size_A*(my_rand() / (_FLOAT_) MY_RAND_MAX) - d;
particles[i][0] = x;
particles[i][1] = y;
}
}*/
for (i=0;i<NParticles;i++) {
perm[i] = i;
charges[i] = 1.0;
}
if (with_dipoleSources) {
for (i=0;i<NParticles;i++) {
x = (my_rand() / (_FLOAT_) MY_RAND_MAX) - 0.5;
y = (my_rand() / (_FLOAT_) MY_RAND_MAX) - 0.5;
dipoleMoments[i][0] = x;
dipoleMoments[i][1] = y;
}
}
box_B->firstTarget = 0;
box_B->noOfTargets = NTargets;
box_B->x = x_B;
box_B->y = y_B;
box_B->level = level_B;
box_B->L = 0;
/* if (with_L2L) */ {
int m = NTargets/4;
double d = 0.25*size_B;
int c;
for (c=0; c<4; c++) {
box_B->child[c] = &_child_B[c];
box_B->child[c]->level = level_B + 1;
box_B->child[c]->L = 0;
box_B->child[c]->firstTarget = c*m;
box_B->child[c]->noOfTargets = m;
}
box_B->child[3]->noOfTargets = NTargets - box_B->child[3]->firstTarget;
box_B->child[SW]->x = x_B - d;
box_B->child[SW]->y = y_B - d;
box_B->child[NW]->x = x_B - d;
box_B->child[NW]->y = y_B + d;
box_B->child[SE]->x = x_B + d;
box_B->child[SE]->y = y_B - d;
box_B->child[NE]->x = x_B + d;
box_B->child[NE]->y = y_B + d;
for (c=0; c<4; c++) {
for (i = box_B->child[c]->firstTarget; i < box_B->child[c]->firstTarget+box_B->child[c]->noOfTargets; i++) {
x = box_B->child[c]->x + 2.0*d*(my_rand() / (_FLOAT_) MY_RAND_MAX) - d;
y = box_B->child[c]->y + 2.0*d*(my_rand() / (_FLOAT_) MY_RAND_MAX) - d;
targets[i][0] = x;
targets[i][1] = y;
}
}
}
/* else {
double d = size_B/2.0;
for (i=0;i<NTargets;i++) {
x = x_B + size_B*(my_rand() / (_FLOAT_) MY_RAND_MAX) - d;
y = y_B + size_B*(my_rand() / (_FLOAT_) MY_RAND_MAX) - d;
targets[i][0] = x;
targets[i][1] = y;
}
} */
for (i=0;i<NTargets;i++) {
permTargets[i] = i;
}
init_all(FMMV);
err = ida_allocate(FMMV);
copy_particles(FMMV);
copy_charges(FMMV);
zero_pot(FMMV);
t0 = (double) clock()/CLOCKS_PER_SEC;
EVAL_DIRECT(FMMV, box_B, box_A);
t1 = (double) clock()/CLOCKS_PER_SEC - t0;
printf("time (eval_direct) : %7.4f\n", t1);
FMMV->potentials = exPot;
FMMV->gradients = exGrad;
backcopy_pot(FMMV);
if (with_M2M||with_L2L) { // in init_M2M is initialisation als necessary for L2L
init_M2M(FMMV, -1);
}
if (with_M2M) {
int c;
t0 = (double) clock()/CLOCKS_PER_SEC;
for (c=0; c<4; c++) {
GEN_M(FMMV, box_A->child[c]);
}
t1 = (double) clock()/CLOCKS_PER_SEC - t0;
printf("time (GEN_M) : %7.4f\n", t1);
//init_M2M(FMMV, -1);
init_M2M(FMMV, level_A);
t0 = (double) clock()/CLOCKS_PER_SEC;
M2M(FMMV, box_A);
t1 = (double) clock()/CLOCKS_PER_SEC - t0;
printf("time (M2M) : %7.4f\n", t1);
}
else {
t0 = (double) clock()/CLOCKS_PER_SEC;
GEN_M(FMMV, box_A);
t1 = (double) clock()/CLOCKS_PER_SEC - t0;
printf("time (GEN_M) : %7.4f\n", t1);
}
/*
printf("M:\n");
for (i=0;i<=pM;i++) {
printf("%3i %24.16e %24.16e\n", i, box_A->M[2*i], box_A->M[2*i+1]);
}
*/
zero_pot(FMMV);
t0 = (double) clock()/CLOCKS_PER_SEC;
EVAL_M(FMMV, box_B, box_A);
t1 = (double) clock()/CLOCKS_PER_SEC - t0;
printf("time (EVAL_M) : %7.4f\n", t1);
FMMV->potentials = potM;
FMMV->gradients = gradM;
backcopy_pot(FMMV);
t0 = (double) clock()/CLOCKS_PER_SEC;
GEN_L(FMMV, box_B, box_A);
t1 = (double) clock()/CLOCKS_PER_SEC - t0;
printf("time (GEN_L) : %7.4f\n", t1);
zero_pot(FMMV);
if (with_L2L) {
int c;
init_L2L(FMMV, -1);
init_L2L(FMMV, level_B);
t0 = (double) clock()/CLOCKS_PER_SEC;
L2L(FMMV, box_B);
t1 = (double) clock()/CLOCKS_PER_SEC - t0;
printf("time (L2L) : %7.4f\n", t1);
t0 = (double) clock()/CLOCKS_PER_SEC;
for (c=0; c<4; c++) {
EVAL_L(FMMV, box_B->child[c]);
}
t1 = (double) clock()/CLOCKS_PER_SEC - t0;
printf("time (EVAL_L) : %7.4f\n", t1);
printf("L:\n");
for (i=0;i<=pL;i++) {
printf("%3i %24.16e %24.16e\n", i, box_B->child[3]->L[2*i], box_B->child[3]->L[2*i+1]);
}
}
else {
t0 = (double) clock()/CLOCKS_PER_SEC;
EVAL_L(FMMV, box_B);
t1 = (double) clock()/CLOCKS_PER_SEC - t0;
printf("time (EVAL_L) : %7.4f\n", t1);
printf("L:\n");
for (i=0;i<=pL;i++) {
printf("%3i %24.16e %24.16e\n", i, box_B->L[2*i], box_B->L[2*i+1]);
}
}
FMMV->potentials = potL;
FMMV->gradients = gradL;
backcopy_pot(FMMV);
ida_free(FMMV);
if (with_gradients) {
relL2Err(0, 0, 0); /* init */
relL2Err2(0, NULL, NULL); /* init */
if (printResult) {
printf("\n Pot(M) Pot(exact) rel.err. rel.err.(grad)\n");
printf("============================================================\n");
}
for (i=0; i<NTargets; i++) {
relL2Err(1, potM[i], exPot[i]); /* accumulate */
relL2Err2(1, gradM[i], exGrad[i]); /* accumulate */
if (printResult) {
printf("%3i %12.4e %12.4e %12.4e %12.4e\n", i, (double) potM[i], (double) exPot[i], (double) relErr(potM[i], exPot[i]),(_FLOAT_) relErr2(gradM[i], exGrad[i]));
}
}
errL2 = relL2Err(2, 0, 0); /*finalize*/
errL2grad = relL2Err2(2, NULL, NULL); /*finalize*/
printf ("\nerr_L2(potM) = %.4e err_L2(gradM) = %.4e\n", errL2, errL2grad);
printf("%24.16e %24.16e\n", exGrad[0][0], exGrad[0][1]);
printf("%24.16e %24.16e\n", gradM[0][0], gradM[0][1]);
relL2Err(0, 0, 0); /* init */
relL2Err2(0, NULL, NULL); /* init */
if (printResult) {
printf("\n Pot(L) Pot(exact) rel.err. rel.err.(grad)\n");
printf("============================================================\n");
}
for (i=0; i<NTargets; i++) {
relL2Err(1, potL[i], exPot[i]); /* accumulate */
relL2Err2(1, gradL[i], exGrad[i]); /* accumulate */
if (printResult) {
printf("%3i %12.4e %12.4e %12.4e %12.4e\n", i, (double) potL[i], (double) exPot[i], (double) relErr(potL[i], exPot[i]),(_FLOAT_) relErr2(gradL[i], exGrad[i]));
}
}
errL2 = relL2Err(2, 0, 0); /*finalize*/
errL2grad = relL2Err2(2, NULL, NULL); /*finalize*/
printf ("\nerr_L2(potL) = %.4e err_L2(gradL) = %.4e\n", errL2, errL2grad);
printf("%24.16e %24.16e\n", exGrad[0][0], exGrad[0][1]);
printf("%24.16e %24.16e\n", gradL[0][0], gradL[0][1]);
}
else {
relL2Err(0, 0, 0);
if (printResult) {
printf("\n Pot(M) Pot(exact) rel.err.\n");
printf("============================================\n");
}
for (i=0; i<NTargets; i++) {
relL2Err(1, potM[i], exPot[i]); /* accumulate */
if (printResult) {
printf("%3i %12.4e %12.4e %12.4e\n", i, (double) potM[i], (double) exPot[i], (double) relErr(potM[i], exPot[i]));
}
}
errL2 = relL2Err(2, 0, 0); /*finalize*/
printf ("\nerr_L2(potM) = %.4e\n", errL2);
relL2Err(0, 0, 0);
if (printResult) {
printf("\n Pot(L) Pot(exact) rel.err.\n");
printf("============================================\n");
}
for (i=0; i<NTargets; i++) {
relL2Err(1, potL[i], exPot[i]); /* accumulate */
if (printResult) {
printf("%3i %12.4e %12.4e %12.4e\n", i, (double) potL[i], (double) exPot[i], (double) relErr(potL[i], exPot[i]));
}
}
errL2 = relL2Err(2, 0, 0); /*finalize*/
printf ("\nerr_L2(potL) = %.4e\n", errL2);
}
// TODO: deallocate...
finish_all(FMMV);
return 0;
}
int main()
{
printf ("%d\n", my_rand());
};
//---------------------------------------------------------------------------
void t_mep_chromosome::generate_random(t_mep_parameters *parameters, int *actual_operators, int num_actual_operators, int *actual_variables, int num_actual_variables) // randomly initializes the individuals
{
// I have to generate the constants for this individuals
if (parameters->constants_probability > 1E-6) {
if (parameters->constants.constants_type == USER_DEFINED_CONSTANTS) {
for (int c = 0; c < num_constants; c++)
constants_double[c] = parameters->constants.constants_double[c];
}
else {// automatic constants
for (int c = 0; c < num_constants; c++)
constants_double[c] = my_rand() / double(RAND_MAX) * (parameters->constants.max_constants_interval_double - parameters->constants.min_constants_interval_double) + parameters->constants.min_constants_interval_double;
}
}
double sum = parameters->variables_probability + parameters->constants_probability;
double p = my_rand() / (double)RAND_MAX * sum;
if (p <= parameters->variables_probability)
prg[0].op = actual_variables[my_rand() % num_actual_variables];
else
prg[0].op = num_total_variables + my_rand() % num_constants;
for (int i = 1; i < parameters->code_length; i++) {
double p = my_rand() / (double)RAND_MAX;
if (p <= parameters->operators_probability)
prg[i].op = actual_operators[my_rand() % num_actual_operators];
else if (p <= parameters->operators_probability + parameters->variables_probability)
prg[i].op = actual_variables[my_rand() % num_actual_variables];
else
prg[i].op = num_total_variables + my_rand() % num_constants;
prg[i].adr1 = my_rand() % i;
prg[i].adr2 = my_rand() % i;
prg[i].adr3 = my_rand() % i;
prg[i].adr4 = my_rand() % i;
}
}
void camdtest (cholmod_sparse *A)
{
double Control [CAMD_CONTROL], Info [CAMD_INFO], alpha ;
Int *P, *Cp, *Ci, *Sp, *Si, *Bp, *Bi, *Ep, *Ei, *Fp, *Fi,
*Len, *Nv, *Next, *Head, *Elen, *Deg, *Wi, *W, *Flag, *BucketSet,
*Constraint ;
cholmod_sparse *C, *B, *S, *E, *F ;
Int i, j, n, nrow, ncol, ok, cnz, bnz, p, trial, sorted ;
/* ---------------------------------------------------------------------- */
/* get inputs */
/* ---------------------------------------------------------------------- */
printf ("\nCAMD test\n") ;
if (A == NULL)
{
return ;
}
if (A->stype)
{
B = CHOLMOD(copy) (A, 0, 0, cm) ;
}
else
{
B = CHOLMOD(aat) (A, NULL, 0, 0, cm) ;
}
if (A->nrow != A->ncol)
{
F = CHOLMOD(copy_sparse) (B, cm) ;
OK (F->nrow == F->ncol) ;
CHOLMOD(sort) (F, cm) ;
}
else
{
/* A is square and unsymmetric, and may have entries in A+A' that
* are not in A */
F = CHOLMOD(copy_sparse) (A, cm) ;
CHOLMOD(sort) (F, cm) ;
}
C = CHOLMOD(copy_sparse) (B, cm) ;
nrow = C->nrow ;
ncol = C->ncol ;
n = nrow ;
OK (nrow == ncol) ;
Cp = C->p ;
Ci = C->i ;
Bp = B->p ;
Bi = B->i ;
/* ---------------------------------------------------------------------- */
/* S = sorted form of B, using CAMD_preprocess */
/* ---------------------------------------------------------------------- */
cnz = CHOLMOD(nnz) (C, cm) ;
S = CHOLMOD(allocate_sparse) (n, n, cnz, TRUE, TRUE, 0, CHOLMOD_PATTERN,
cm);
Sp = S->p ;
Si = S->i ;
W = CHOLMOD(malloc) (n, sizeof (Int), cm) ;
Flag = CHOLMOD(malloc) (n, sizeof (Int), cm) ;
CAMD_preprocess (n, Bp, Bi, Sp, Si, W, Flag) ;
/* ---------------------------------------------------------------------- */
/* allocate workspace for camd */
/* ---------------------------------------------------------------------- */
P = CHOLMOD(malloc) (n+1, sizeof (Int), cm) ;
Constraint = CHOLMOD(malloc) (n, sizeof (Int), cm) ;
for (i = 0 ; i < n ; i++)
{
Constraint [i] = my_rand () % (MIN (n,6)) ;
}
ok = CAMD_cvalid (n, Constraint) ; OK (ok) ;
if (n > 0)
{
Constraint [0] = -1 ;
ok = CAMD_cvalid (n, Constraint) ; OK (!ok) ;
Constraint [0] = 0 ;
}
ok = CAMD_cvalid (n, Constraint) ; OK (ok) ;
ok = CAMD_cvalid (n, NULL) ; OK (ok) ;
Len = CHOLMOD(malloc) (n, sizeof (Int), cm) ;
Nv = CHOLMOD(malloc) (n, sizeof (Int), cm) ;
Next = CHOLMOD(malloc) (n, sizeof (Int), cm) ;
Head = CHOLMOD(malloc) (n+1, sizeof (Int), cm) ;
Elen = CHOLMOD(malloc) (n, sizeof (Int), cm) ;
Deg = CHOLMOD(malloc) (n, sizeof (Int), cm) ;
Wi = CHOLMOD(malloc) (n+1, sizeof (Int), cm) ;
BucketSet = CHOLMOD(malloc) (n, sizeof (Int), cm) ;
/* ---------------------------------------------------------------------- */
for (sorted = 0 ; sorted <= 1 ; sorted++)
{
if (sorted) CHOLMOD(sort) (C, cm) ;
Cp = C->p ;
Ci = C->i ;
/* ------------------------------------------------------------------ */
/* order C with CAMD_order */
/* ------------------------------------------------------------------ */
CAMD_defaults (Control) ;
CAMD_defaults (NULL) ;
CAMD_control (Control) ;
CAMD_control (NULL) ;
CAMD_info (NULL) ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, Constraint) ;
printf ("camd return value: "ID"\n", ok) ;
CAMD_info (Info) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
OK (CHOLMOD(print_perm) (P, n, n, "CAMD permutation", cm)) ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
printf ("camd return value: "ID"\n", ok) ;
CAMD_info (Info) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
OK (CHOLMOD(print_perm) (P, n, n, "CAMD permutation", cm)) ;
/* no dense rows/cols */
alpha = Control [CAMD_DENSE] ;
Control [CAMD_DENSE] = -1 ;
CAMD_control (Control) ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
printf ("camd return value: "ID"\n", ok) ;
CAMD_info (Info) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
OK (CHOLMOD(print_perm) (P, n, n, "CAMD permutation (alpha=-1)", cm)) ;
/* many dense rows/cols */
Control [CAMD_DENSE] = 0 ;
CAMD_control (Control) ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
printf ("camd return value: "ID"\n", ok) ;
CAMD_info (Info) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
OK (CHOLMOD(print_perm) (P, n, n, "CAMD permutation (alpha=0)", cm)) ;
Control [CAMD_DENSE] = alpha ;
/* no aggressive absorption */
Control [CAMD_AGGRESSIVE] = FALSE ;
CAMD_control (Control) ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
printf ("camd return value: "ID"\n", ok) ;
CAMD_info (Info) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
OK (CHOLMOD(print_perm) (P, n, n, "CAMD permutation (no agg) ", cm)) ;
Control [CAMD_AGGRESSIVE] = TRUE ;
/* ------------------------------------------------------------------ */
/* order F with CAMD_order */
/* ------------------------------------------------------------------ */
Fp = F->p ;
Fi = F->i ;
ok = CAMD_order (n, Fp, Fi, P, Control, Info, NULL) ;
printf ("camd return value: "ID"\n", ok) ;
CAMD_info (Info) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
OK (CHOLMOD(print_perm) (P, n, n, "F: CAMD permutation", cm)) ;
/* ------------------------------------------------------------------ */
/* order S with CAMD_order */
/* ------------------------------------------------------------------ */
ok = CAMD_order (n, Sp, Si, P, Control, Info, NULL) ;
printf ("camd return value: "ID"\n", ok) ;
CAMD_info (Info) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
OK (CHOLMOD(print_perm) (P, n, n, "CAMD permutation", cm)) ;
/* ------------------------------------------------------------------ */
/* order E with CAMD_2, which destroys its contents */
/* ------------------------------------------------------------------ */
E = CHOLMOD(copy) (B, 0, -1, cm) ; /* remove diagonal entries */
bnz = CHOLMOD(nnz) (E, cm) ;
/* add the bare minimum extra space to E */
ok = CHOLMOD(reallocate_sparse) (bnz + n, E, cm) ;
OK (ok) ;
Ep = E->p ;
Ei = E->i ;
for (j = 0 ; j < n ; j++)
{
Len [j] = Ep [j+1] - Ep [j] ;
}
printf ("calling CAMD_2:\n") ;
if (n > 0)
{
CAMD_2 (n, Ep, Ei, Len, E->nzmax, Ep [n], Nv, Next, P, Head, Elen,
Deg, Wi, NULL, Info, NULL, BucketSet) ;
CAMD_info (Info) ;
OK (CHOLMOD(print_perm) (P, n, n, "CAMD2 permutation", cm)) ;
}
/* ------------------------------------------------------------------ */
/* error tests */
/* ------------------------------------------------------------------ */
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
ok = CAMD_order (-1, Cp, Ci, P, Control, Info, NULL) ;
OK (ok == CAMD_INVALID);
ok = CAMD_order (0, Cp, Ci, P, Control, Info, NULL) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
ok = CAMD_order (n, NULL, Ci, P, Control, Info, NULL) ;
OK (ok == CAMD_INVALID);
ok = CAMD_order (n, Cp, NULL, P, Control, Info, NULL) ;
OK (ok == CAMD_INVALID);
ok = CAMD_order (n, Cp, Ci, NULL, Control, Info, NULL) ;
OK (ok == CAMD_INVALID);
if (n > 0)
{
printf ("CAMD error tests:\n") ;
p = Cp [n] ;
Cp [n] = -1 ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
OK (ok == CAMD_INVALID) ;
if (Size_max/2 == Int_max)
{
Cp [n] = Int_max ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
printf ("CAMD status is %d\n", ok) ;
OK (ok == CAMD_OUT_OF_MEMORY) ;
}
Cp [n] = p ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
if (Cp [n] > 0)
{
printf ("Mangle column zero:\n") ;
i = Ci [0] ;
Ci [0] = -1 ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
CAMD_info (Info) ;
OK (ok == CAMD_INVALID) ;
Ci [0] = i ;
}
}
ok = CAMD_valid (n, n, Sp, Si) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
ok = CAMD_valid (-1, n, Sp, Si) ; OK (ok == CAMD_INVALID) ;
ok = CAMD_valid (n, -1, Sp, Si) ; OK (ok == CAMD_INVALID) ;
ok = CAMD_valid (n, n, NULL, Si) ; OK (ok == CAMD_INVALID) ;
ok = CAMD_valid (n, n, Sp, NULL) ; OK (ok == CAMD_INVALID) ;
if (n > 0 && Sp [n] > 0)
{
p = Sp [n] ;
Sp [n] = -1 ;
ok = CAMD_valid (n, n, Sp, Si) ; OK (ok == CAMD_INVALID) ;
Sp [n] = p ;
p = Sp [0] ;
Sp [0] = -1 ;
ok = CAMD_valid (n, n, Sp, Si) ; OK (ok == CAMD_INVALID) ;
Sp [0] = p ;
p = Sp [1] ;
Sp [1] = -1 ;
ok = CAMD_valid (n, n, Sp, Si) ; OK (ok == CAMD_INVALID) ;
Sp [1] = p ;
i = Si [0] ;
Si [0] = -1 ;
ok = CAMD_valid (n, n, Sp, Si) ; OK (ok == CAMD_INVALID) ;
Si [0] = i ;
}
ok = CAMD_valid (n, n, Sp, Si) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
CAMD_preprocess (n, Bp, Bi, Sp, Si, W, Flag) ;
ok = CAMD_valid (n, n, Sp, Si) ;
OK (ok == CAMD_OK) ;
if (n > 0 && Bp [n] > 0)
{
p = Bp [n] ;
Bp [n] = -1 ;
ok = CAMD_valid (n, n, Bp, Bi) ; OK (ok == CAMD_INVALID) ;
Bp [n] = p ;
p = Bp [1] ;
Bp [1] = -1 ;
ok = CAMD_valid (n, n, Bp, Bi) ; OK (ok == CAMD_INVALID) ;
Bp [1] = p ;
i = Bi [0] ;
Bi [0] = -1 ;
ok = CAMD_valid (n, n, Bp, Bi) ; OK (ok == CAMD_INVALID) ;
Bi [0] = i ;
}
CAMD_preprocess (n, Bp, Bi, Sp, Si, W, Flag) ;
Info [CAMD_STATUS] = 777 ;
CAMD_info (Info) ;
/* ------------------------------------------------------------------ */
/* memory tests */
/* ------------------------------------------------------------------ */
if (n > 0)
{
camd_malloc = cm->malloc_memory ;
camd_free = cm->free_memory ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
OK (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK)) ;
test_memory_handler ( ) ;
camd_malloc = cm->malloc_memory ;
camd_free = cm->free_memory ;
for (trial = 0 ; trial < 6 ; trial++)
{
my_tries = trial ;
printf ("CAMD memory trial "ID"\n", trial) ;
ok = CAMD_order (n, Cp, Ci, P, Control, Info, NULL) ;
CAMD_info (Info) ;
OK (ok == CAMD_OUT_OF_MEMORY
|| (sorted ? (ok == CAMD_OK) : (ok >= CAMD_OK))) ;
}
normal_memory_handler ( ) ;
OK (CHOLMOD(print_perm) (P, n, n, "CAMD2 permutation", cm)) ;
camd_malloc = cm->malloc_memory ;
camd_free = cm->free_memory ;
}
CHOLMOD(free_sparse) (&E, cm) ;
}
/* ---------------------------------------------------------------------- */
/* free everything */
/* ---------------------------------------------------------------------- */
CHOLMOD(free) (n, sizeof (Int), Len, cm) ;
CHOLMOD(free) (n, sizeof (Int), Nv, cm) ;
CHOLMOD(free) (n, sizeof (Int), Next, cm) ;
CHOLMOD(free) (n+1, sizeof (Int), Head, cm) ;
CHOLMOD(free) (n, sizeof (Int), Elen, cm) ;
CHOLMOD(free) (n, sizeof (Int), Deg, cm) ;
CHOLMOD(free) (n+1, sizeof (Int), Wi, cm) ;
CHOLMOD(free) (n, sizeof (Int), BucketSet, cm) ;
CHOLMOD(free) (n+1, sizeof (Int), P, cm) ;
CHOLMOD(free) (n, sizeof (Int), Constraint, cm) ;
CHOLMOD(free) (n, sizeof (Int), W, cm) ;
CHOLMOD(free) (n, sizeof (Int), Flag, cm) ;
CHOLMOD(free_sparse) (&S, cm) ;
CHOLMOD(free_sparse) (&B, cm) ;
CHOLMOD(free_sparse) (&C, cm) ;
CHOLMOD(free_sparse) (&F, cm) ;
}
bool resource_request(int customer) {
/*Add Easy Test to see if what you need is DONE!*/
/* if((need[customer][0] <= 0 ) &&
(need[customer][1] <= 0 ) &&
(need[customer][2] <= 0 )) {
printf("DONE?");
//return -1; //can I do this??
}*/
/*Randomize the request of three resource types*/
int req_a, req_b, req_c;
req_a = my_rand(need[customer][0]);
req_b = my_rand(need[customer][1]);
req_c = my_rand(need[customer][2]);
/*If request is more than ANY max limit, exit program as there is an error*/
if (req_a > max[customer][0] ||
req_b > max[customer][1] ||
req_c > max[customer][2]) {
printf("ERROR! Exceeding max claim:\n");
printf("Res_A: %d <= %d\n", req_a, max[customer][0]);
printf("Res_B: %d <= %d\n", req_b, max[customer][1]);
printf("Res_C: %d <= %d\n", req_c, max[customer][2]);
//exit(1);
return false;
}
/*Lock teller*/
pthread_mutex_lock(&teller);
/*Start buffer printout*/
printf("At time %d Customer %d requesting <%d,%d,%d> Available = <%d,%d,%d>\n",
currenttime, customer,
req_a, req_b, req_c,
available[0], available[1], available[2]);
/*See if what your requesting is available*/
if (req_a <= available[0] &&
req_b <= available[1] &&
req_c <= available[2]) {
/*Create backup array, incase this array wont work*/
int backup_available[RESOURCES];
int backup_max[CUSTOMERS][RESOURCES];
int backup_allocation[CUSTOMERS][RESOURCES];
int backup_need[CUSTOMERS][RESOURCES];
/*Create backupstate, to revert to if the state is NOT safe*/
copy_array(available, backup_available);
copy_array((int *) max, (int *)backup_max);
copy_array((int *) allocation, (int *) backup_allocation);
copy_array((int *) need, (int *) backup_need);
/*Now update actual main state, to use is_safe*/
int i;
int temparr[3] = {req_a, req_b, req_c}; //put requests in an array
/*Iterate through three resource types*/
for(i=0;i<3;i++){
available[i] = available[i] - temparr[i];
allocation[customer][i] = allocation[customer][i] + temparr[i];
need[customer][i] = need[customer][i] - temparr[i];
}
/*Now check if backup state is safe*/
if(is_safe()) {
/*Second Buffer Printout*/
printf(">>>Customer %d is granted resources<<<<\n",customer);
printf("Available = <%d,%d,%d> Allocated = <%d,%d,%d>\n\n",
available[0],available[1],available[2],
allocation[customer][0],allocation[customer][1],allocation[customer][2]);
} else {
printf("!!!Customer %d is denied resources!!!\n\n",customer);
copy_array(backup_available, available);
copy_array((int *) backup_max, (int *)max);
copy_array((int *) backup_allocation, (int *) allocation);
copy_array((int *) backup_need, (int *) need);
/*End Critical Section*/
pthread_mutex_unlock(&teller);
return false;
}
/*End Critical Section*/
pthread_mutex_unlock(&teller);
return true;
}else { //not enough resources
printf("===Not Enough Resources===\n");
pthread_mutex_unlock(&teller);
return false;
}
}
inline float my_rangeRand(float min, float max)
{
return ( min + ( (float)my_rand() / D_RAND_MAX * (max - min) ) );
}
//---------------------------------------------------------------------------
void t_mep_chromosome::mutation(t_mep_parameters *parameters, int *actual_operators, int num_actual_operators, int *actual_variables, int num_actual_variables) // mutate the individual
{
// mutate each symbol with the same pm probability
double p = my_rand() / (double)RAND_MAX;
if (p < parameters->mutation_probability) {
double sum = parameters->variables_probability + parameters->constants_probability;
double q = my_rand() / (double)RAND_MAX * sum;
if (q <= parameters->variables_probability)
prg[0].op = actual_variables[my_rand() % num_actual_variables];
else
prg[0].op = num_total_variables + my_rand() % num_constants;
}
for (int i = 1; i < code_length; i++) {
p = my_rand() / (double)RAND_MAX; // mutate the operator
if (p < parameters->mutation_probability) {
double q = my_rand() / (double)RAND_MAX;
if (q <= parameters->operators_probability)
prg[i].op = actual_operators[my_rand() % num_actual_operators];
else if (q <= parameters->operators_probability + parameters->variables_probability)
prg[i].op = actual_variables[my_rand() % num_actual_variables];
else
prg[i].op = num_total_variables + my_rand() % num_constants;
}
p = my_rand() / (double)RAND_MAX; // mutate the first address (adr1)
if (p < parameters->mutation_probability)
prg[i].adr1 = my_rand() % i;
p = my_rand() / (double)RAND_MAX; // mutate the second address (adr2)
if (p < parameters->mutation_probability)
prg[i].adr2 = my_rand() % i;
p = my_rand() / (double)RAND_MAX; // mutate the second address (adr2)
if (p < parameters->mutation_probability)
prg[i].adr3 = my_rand() % i;
p = my_rand() / (double)RAND_MAX; // mutate the second address (adr2)
if (p < parameters->mutation_probability)
prg[i].adr4 = my_rand() % i;
}
// lets see if I can evolve constants
if (parameters->constants.constants_can_evolve && parameters->constants.constants_type == AUTOMATIC_CONSTANTS)
for (int c = 0; c < num_constants; c++) {
p = my_rand() / (double)RAND_MAX; // mutate the operator
double tmp_cst_d = my_rand() / double(RAND_MAX) * parameters->constants.constants_mutation_max_deviation;
if (p < parameters->mutation_probability) {
if (my_rand() % 2) {// coin
if (constants_double[c] + tmp_cst_d <= parameters->constants.max_constants_interval_double)
constants_double[c] += tmp_cst_d;
}
else if (constants_double[c] - tmp_cst_d >= parameters->constants.min_constants_interval_double)
constants_double[c] -= tmp_cst_d;
break;
}
}
}
int main(int argc, char *argv[])
{
bert_state_t tx_bert;
bert_state_t rx_bert;
bert_state_t bert;
bert_results_t bert_results;
int i;
int bit;
int zeros;
int max_zeros;
int failed;
bert_init(&tx_bert, 0, BERT_PATTERN_ZEROS, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_ZEROS, 300, 20);
for (i = 0; i < 511*2; i++)
{
bit = bert_get_bit(&tx_bert);
bert_put_bit(&rx_bert, bit);
}
bert_result(&rx_bert, &bert_results);
printf("Zeros: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
if (bert_results.bad_bits || bert_results.total_bits != 950)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_ONES, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_ONES, 300, 20);
for (i = 0; i < 511*2; i++)
{
bit = bert_get_bit(&tx_bert);
bert_put_bit(&rx_bert, bit);
}
bert_result(&rx_bert, &bert_results);
printf("Ones: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
if (bert_results.bad_bits || bert_results.total_bits != 950)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_1_TO_7, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_1_TO_7, 300, 20);
for (i = 0; i < 511*2; i++)
{
bit = bert_get_bit(&tx_bert);
bert_put_bit(&rx_bert, bit);
}
bert_result(&rx_bert, &bert_results);
printf("1 to 7: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
if (bert_results.bad_bits || bert_results.total_bits != 950)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_1_TO_3, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_1_TO_3, 300, 20);
for (i = 0; i < 511*2; i++)
{
bit = bert_get_bit(&tx_bert);
bert_put_bit(&rx_bert, bit);
}
bert_result(&rx_bert, &bert_results);
printf("1 to 3: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
if (bert_results.bad_bits || bert_results.total_bits != 950)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_1_TO_1, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_1_TO_1, 300, 20);
for (i = 0; i < 511*2; i++)
{
bit = bert_get_bit(&tx_bert);
bert_put_bit(&rx_bert, bit);
}
bert_result(&rx_bert, &bert_results);
printf("1 to 1: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
if (bert_results.bad_bits || bert_results.total_bits != 950)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_3_TO_1, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_3_TO_1, 300, 20);
for (i = 0; i < 511*2; i++)
{
bit = bert_get_bit(&tx_bert);
bert_put_bit(&rx_bert, bit);
}
bert_result(&rx_bert, &bert_results);
printf("3 to 1: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
if (bert_results.bad_bits || bert_results.total_bits != 950)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_7_TO_1, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_7_TO_1, 300, 20);
for (i = 0; i < 511*2; i++)
{
bit = bert_get_bit(&tx_bert);
bert_put_bit(&rx_bert, bit);
}
bert_result(&rx_bert, &bert_results);
printf("7 to 1: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
if (bert_results.bad_bits || bert_results.total_bits != 950)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O153_9, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O153_9, 300, 20);
for (i = 0; i < 0x200; i++)
test[i] = 0;
max_zeros = 0;
zeros = 0;
for (i = 0; i < 511*2; i++)
{
bit = bert_get_bit(&tx_bert);
if (bit)
{
if (zeros > max_zeros)
max_zeros = zeros;
zeros = 0;
}
else
{
zeros++;
}
bert_put_bit(&rx_bert, bit);
test[tx_bert.tx_reg]++;
}
failed = FALSE;
if (test[0] != 0)
{
printf("XXX %d %d\n", 0, test[0]);
failed = TRUE;
}
for (i = 1; i < 0x200; i++)
{
if (test[i] != 2)
{
printf("XXX %d %d\n", i, test[i]);
failed = TRUE;
}
}
bert_result(&rx_bert, &bert_results);
printf("O.153(9): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
if (bert_results.bad_bits || bert_results.total_bits != 986 || failed)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O152_11, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O152_11, 300, 20);
for (i = 0; i < 0x800; i++)
test[i] = 0;
max_zeros = 0;
zeros = 0;
for (i = 0; i < 2047*2; i++)
{
bit = bert_get_bit(&tx_bert);
if (bit)
{
if (zeros > max_zeros)
max_zeros = zeros;
zeros = 0;
}
else
{
zeros++;
}
bert_put_bit(&rx_bert, bit);
test[tx_bert.tx_reg]++;
}
failed = FALSE;
if (test[0] != 0)
{
printf("XXX %d %d\n", 0, test[0]);
failed = TRUE;
}
for (i = 1; i < 0x800; i++)
{
if (test[i] != 2)
{
printf("XXX %d %d\n", i, test[i]);
failed = TRUE;
}
}
bert_result(&rx_bert, &bert_results);
printf("O.152(11): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
if (bert_results.bad_bits || bert_results.total_bits != 4052 || failed)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O151_15, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O151_15, 300, 20);
for (i = 0; i < 0x8000; i++)
test[i] = 0;
max_zeros = 0;
zeros = 0;
for (i = 0; i < 32767*2; i++)
{
bit = bert_get_bit(&tx_bert);
if (bit)
{
if (zeros > max_zeros)
max_zeros = zeros;
zeros = 0;
}
else
{
zeros++;
}
bert_put_bit(&rx_bert, bit);
test[tx_bert.tx_reg]++;
}
failed = FALSE;
if (test[0] != 0)
{
printf("XXX %d %d\n", 0, test[0]);
failed = TRUE;
}
for (i = 1; i < 0x8000; i++)
{
if (test[i] != 2)
{
printf("XXX %d %d\n", i, test[i]);
failed = TRUE;
}
}
bert_result(&rx_bert, &bert_results);
printf("O.151(15): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
if (bert_results.bad_bits || bert_results.total_bits != 65480 || failed)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O151_20, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O151_20, 300, 20);
for (i = 0; i < 0x100000; i++)
test[i] = 0;
max_zeros = 0;
zeros = 0;
for (i = 0; i < 1048575*2; i++)
{
bit = bert_get_bit(&tx_bert);
if (bit)
{
if (zeros > max_zeros)
max_zeros = zeros;
zeros = 0;
}
else
{
zeros++;
}
bert_put_bit(&rx_bert, bit);
test[tx_bert.tx_reg]++;
}
failed = FALSE;
if (test[0] != 0)
{
printf("XXX %d %d\n", 0, test[0]);
failed = TRUE;
}
for (i = 1; i < 0x100000; i++)
{
if (test[i] != 2)
printf("XXX %d %d\n", i, test[i]);
}
bert_result(&rx_bert, &bert_results);
printf("O.151(20): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
if (bert_results.bad_bits || bert_results.total_bits != 2097066 || failed)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_ITU_O151_23, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_ITU_O151_23, 300, 20);
for (i = 0; i < 0x800000; i++)
test[i] = 0;
max_zeros = 0;
zeros = 0;
for (i = 0; i < 8388607*2; i++)
{
bit = bert_get_bit(&tx_bert);
if (bit)
{
if (zeros > max_zeros)
max_zeros = zeros;
zeros = 0;
}
else
{
zeros++;
}
bert_put_bit(&rx_bert, bit);
test[tx_bert.tx_reg]++;
}
failed = FALSE;
if (test[0] != 0)
{
printf("XXX %d %d\n", 0, test[0]);
failed = TRUE;
}
for (i = 1; i < 0x800000; i++)
{
if (test[i] != 2)
printf("XXX %d %d\n", i, test[i]);
}
bert_result(&rx_bert, &bert_results);
printf("O.151(23): Bad bits %d/%d, max zeros %d\n", bert_results.bad_bits, bert_results.total_bits, max_zeros);
if (bert_results.bad_bits || bert_results.total_bits != 16777136 || failed)
{
printf("Test failed.\n");
exit(2);
}
bert_init(&tx_bert, 0, BERT_PATTERN_QBF, 300, 20);
bert_init(&rx_bert, 0, BERT_PATTERN_QBF, 300, 20);
for (i = 0; i < 100000; i++)
{
bit = bert_get_bit(&tx_bert);
bert_put_bit(&rx_bert, bit);
}
bert_result(&rx_bert, &bert_results);
printf("QBF: Bad bits %d/%d\n", bert_results.bad_bits, bert_results.total_bits);
if (bert_results.bad_bits || bert_results.total_bits != 100000)
{
printf("Test failed.\n");
exit(2);
}
/* Test the mechanism for categorising the error rate into <10^x bands */
/* TODO: The result of this test is not checked automatically */
bert_init(&bert, 15000000, BERT_PATTERN_ITU_O152_11, 300, 20);
bert_set_report(&bert, 100000, reporter, (intptr_t) 0);
for (;;)
{
if ((bit = bert_get_bit(&bert)) == PUTBIT_END_OF_DATA)
{
bert_result(&bert, &bert_results);
printf("Rate test: %d bits, %d bad bits, %d resyncs\n", bert_results.total_bits, bert_results.bad_bits, bert_results.resyncs);
if (bert_results.total_bits != 15000000 - 42
||
bert_results.bad_bits != 58
||
bert_results.resyncs != 0)
{
printf("Tests failed\n");
exit(2);
}
break;
//bert_init(&bert, 15000000, BERT_PATTERN_ITU_O152_11, 300, 20);
//bert_set_report(&bert, 100000, reporter, (intptr_t) 0);
//continue;
}
if ((my_rand() & 0x3FFFF) == 0)
bit ^= 1;
//if ((my_rand() & 0xFFF) == 0)
// bert_put_bit(&bert, bit);
bert_put_bit(&bert, bit);
}
printf("Tests passed.\n");
return 0;
}
double my_drand(unsigned* seed_p)
{
unsigned x = my_rand(seed_p);
double y = x/MR_DIVISOR;
return y;
}
