Beispiel #1
0
void DESolver::Setup( double *min, double *max, int deStrategy, double diffScale, 
					double crossoverProb, double ftol, unsigned long rngSeed )
{
  int i;

  strategy = deStrategy;
  scale = diffScale;
  probability = crossoverProb;
  tolerance = ftol;
  
  // PE: seed the (Mersenne Twister) RNG
  if (rngSeed > 0)
    init_genrand(rngSeed);
  else
    init_genrand((unsigned long)time((time_t *)NULL));
  
  CopyVector(minBounds, min);
  CopyVector(maxBounds, max);
  
  for (i = 0; i < nPop; i++) {
    for (int j = 0; j < nDim; j++)
      Element(population,i,j) = RandomUniform(min[j], max[j]);

    popEnergy[i] = 1.0E20;
  }

  for (i = 0; i < nDim; i++)
    bestSolution[i] = 0.0;
}
Beispiel #2
0
int main ( int argc, char * const argv[] )
{
	printf( "Testing output and speed of inventors' Mersenne Twister program\n" );
	printf( "\nTest of random integer generation:\n" );
	
	unsigned long oneSeed = 4357UL;
	unsigned long bigSeed[4] = { 0x123UL, 0x234UL, 0x345UL, 0x456UL };
	
	printf( "\nTest of random integer generation:\n" );
	init_by_array( bigSeed, 4 );
	unsigned long i;
	for( i = 0; i < 1000UL; ++i )
	{
		printf( "%10lu ", genrand_int32() );
		if( i % 5 == 4 ) printf("\n");
	}
	
	printf( "\nTest of random real number [0,1) generation:\n" );
	for( i = 0; i < 1000UL; ++i )
	{
		printf( "%10.8f ", genrand_real2() );
		if( i % 5 == 4 ) printf("\n");
	}
	
	printf( "\nTest of random real number [0,1] generation:\n" );
	init_genrand( oneSeed );
	for( i = 0; i < 2000UL; ++i )
	{
		printf( "%10.8f ", genrand_real1() );
		if( i % 5 == 4 ) printf("\n");
	}
	
	printf( "\nTest of time to generate one billion random integers:\n" );
	init_genrand( oneSeed );
	unsigned long junk = 0;
	clock_t start = clock();
	for( i = 0; i < 1000000000UL; ++i )
	{
		junk ^= genrand_int32();
	}
	clock_t stop = clock();
	if( junk == 0 ) printf( "jinx\n" );
	printf( "Time elapsed = " );
	printf( "%8.3f", double( stop - start ) / CLOCKS_PER_SEC );
	printf( " s\n" );
		
	return 0;
}
Beispiel #3
0
void ndice()
{
  char* buffer;

  int a[6];
  int i = 0;
  int m = 0;
  int n = 0;
  int t = 0;

  buffer = open_minibuffer("Number of dice: ");

  m = atoi(buffer);

  for(i = 0; i < 6; ++i) a[i] = 0;

  init_genrand((unsigned)time(NULL));

  for(i = 0; i < m; ++i)
    {
      t = (int)(genrand_real1() * 6);
      a[t]++;
      n += t + 1;
    }

  for(i = 0; i < COLS; ++i) mvaddch(LINES - 1, i, ' ');
  for(i = 0; i < 6; ++i) mvprintw(LINES - 1, i * 6, "%d:% 3d", i + 1, a[i]);
  mvprintw(LINES - 1, 0, "%d: %d    %d: %d    %d: %d    %d: %d    %d: %d    "
           "%d: %d    Total: %d",
           1, a[0], 2, a[1], 3, a[2], 4, a[3], 5, a[4], 6, a[5], n);
}
Beispiel #4
0
inline void InitRand(unsigned long seed) {
#ifdef STANDARD_RAND
    srand(seed);
#else
    init_genrand(seed);
#endif
}
int main(int argc, char *argv[]) {
	init_genrand(0);
	hls::stream<uint32_t> uniform_rns;
	hls::stream<float> gaussian_rns;

	const int N = 1000;

	uint32_t arn[N];
	for (int i = 0; i < N; ++i) {
		uint32_t rn = genrand_int32();
		arn[i] = rn;
		uniform_rns.write(rn);
	}

	for (int i = 0; i < N; ++i)
		icdf(uniform_rns, gaussian_rns);

	int i = 0;
	while (gaussian_rns.size() > 0) {
		float acc_res = gaussian_rns.read();
		std::cout << i << ": " <<  acc_res << std::endl;
		++i;
	}

	std::cout << "done." << std::endl;

	return 0;
}
Beispiel #6
0
/********************************************************
                         MAIN
*********************************************************/
int main(void)
{
	int map[XMAX][YMAX], bmap[XMAX][YMAX][2];
	SPLAYER player;
	LPTCB task;
	
	floor_cnt = 1;
	init_genrand((unsigned long)time(NULL)); // 必ずmainに入れること
	init_task();
	init_monster();
	
	task = create_task(title_load, NULL, PRIO_00);
	task->p[0] = &player;
	task->p[1] = &floor_cnt;
	
	task = create_task(game_start, NULL, PRIO_00);
	task->p[0] = map;
	task->p[1] = &player;
	task->p[2] = bmap;
	
	loop_task();
	
//	printf("taskcnt =%d\n", count_task());
	
	return 0;
}
Beispiel #7
0
// Zipf分布によるランダムなCommonData名前決定
uint16_t GlobalNodeData::return_MsgName() {
  double target;
  uint32_t top, bottom, mid;

  static BOOL INIT_RAND = false;
  if(!INIT_RAND) {
    init_genrand((unsigned)time(NULL));
    INIT_RAND = true;
  }
  target = genrand_real1();
  top = file_size;

  while(bottom < top) {
    mid = (bottom + top) / 2;
    if(this->Zipf[(uint16_t)mid] == target) {
      break;
    } else if(this->Zipf[(uint16_t)mid] < target) {
      bottom  = mid + 1;
    } else { 
      top = mid - 1;
    }
    if(mid == 0) break;
    if(mid == file_size) break;
  }

  // 動画コンテンツ名前と重複する場合、ずらす
  if(mid == 10000) mid++;

  return (uint32_t)mid;
}
Beispiel #8
0
void kmain(multiboot_info_t* mbd, unsigned int magic){
	// kernel entry point.
	//unsigned char* videoram = (unsigned char*) 0xb8000;
	//videoram[0] = 65;
	//videoram[1] = 0x07;
	//setMode(0x13);
	setMode(320, 200, 8); // HOLY SHIT THIS WORKS
	clrscr();
	gdt_install();
	idt_install();
	isrs_install();
	irq_install();
	timer_install();
	start_paging(mbd);
	keyboard_install();
	init_genrand(get_timer_ticks());
	__asm__ __volatile__ ("sti");
	kprint("Hello, We have booted successfully!\n\tTip: type help for command info\n");
		
	while(1){
		if(todo != NULL){
			void(*function)() = todo;
			function(todoCP);
			todo = NULL;
		}
	}
	
}
int main(int argc, char *argv[]) {

	// generate seeds
	uint32_t seeds[624];
	init_genrand(0);
	generate_numbers();
	get_mt_state(seeds);

	// get hardware random numbers
	hls::stream<uint32_t> random_numbers;
	mersenne_twister(seeds, random_numbers);

	// compare with software model
	for (int i = 0; i < 1000 - 396 - 1; ++i) {
		uint32_t rn_sw = genrand_int32();
		uint32_t rn_hw = random_numbers.read();
		if (rn_sw != rn_hw) {
			std::cout << i << ": " << rn_sw << " != " << rn_hw << std::endl;
			return -1;
		}
	}

	std::cout << "test passed." << std::endl;

	return 0;
}
Beispiel #10
0
static void test_generalized_dimension (struct test_solver_info *ts_info)
{
    if (ts_info->length <= 0 || ts_info->dim < 1) return;

    int box_num, *box_count;
    MALLOC(box_count, ts_info->length);

    init_genrand(5747L);
    for (int n = 0; n < ts_info->length; n++) {
        ts_info->data[n][0] = genrand_real1();
    }

    int dnum = 10;
    double dimension[dnum];
    for (int q = 0; q < dnum; q++) {
        dimension[q] = generalized_dimension(
                (const double* const*)ts_info->data, ts_info->length,
                1, 1e-2, q, &box_num);
    }
    for (int q = 1; q < dnum; q++) {
        mu_assert(dimension[q-1] >= dimension[q]);
    }

    FREE(box_count);
}
Beispiel #11
0
static int Lnew(lua_State *L)			/** new([seed]) */
{
 long seed=luaL_optlong(L,1,SEED);
 MT *c=Pnew(L);
 init_genrand(c,seed);
 return 1;
}
Beispiel #12
0
int main(int argc, char **argv)
{
	if(sizeof(int) != 4) {
		fprintf(stderr, "Your machine's ints are not 4 bytes.  "
				"You need to adjust generate_data() and check_data().\n");
		exit(2);
	}

	process_args(argc, argv);
	init_genrand(opt_seed);

	if(opt_check) {
		check_data(0, opt_size);
	} else {
		generate_data(1, opt_size);
	}

	/*
	int i;
	printf("1000 outputs of genrand_int32()\n");
	for (i=0; i<1000; i++) {
		printf("%10lu ", genrand_int32());
		if (i%5==4) printf("\n");
	}
	*/

	return 0;
}
Beispiel #13
0
double RunQILGP()
{
	unsigned int i;
	//srand((unsigned int)time(NULL));
	// 0 to 4,294,967,295 (4294967295)
	//srand(3221225472); 
	init_genrand((unsigned long)time(NULL));
	//init_genrand(0); //0//1073741824//2147483648//3221225472//-//536870912//1610612736//2684354560//3758096384

	writeFreq = nGenerations / 100;
	indivLen = (headerLen + qIndivLen * mCodeDim + footerLen);
	InitSintaticTable();
	InitIndiv();

	accumFit = malloc(nGenerations / writeFreq * sizeof(double));
	accumValFit = malloc(nGenerations / writeFreq * sizeof(double));
	accumLen = malloc(nGenerations / writeFreq * sizeof(double));
	for (i = 0; i < (nGenerations / writeFreq); i++)
	{
		accumFit[i] = 0;
		accumValFit[i] = 0;
		accumLen[i] = 0;
	}
	nEvaluations = 0;

	bestTkIndiv.error = HUGE_VAL;
	bestTkIndiv.fitness = HUGE_VAL;
	bestTkIndiv.validFitness = HUGE_VAL;
	bestTkIndiv.genome = malloc(qIndivLen * sizeof(int) * 2);

	return RunMultiQILGP();
}
Beispiel #14
0
int *generate_random_sol(tm_topology_t *topology,int N,int level,int seed)
{
  hash_t *hash_tab = NULL;
  int *sol = NULL;
  int *nodes_id= NULL;
  int i;

  nodes_id = topology->node_id[level];

  hash_tab = (hash_t*)MALLOC(sizeof(hash_t)*N);
  sol = (int*)MALLOC(sizeof(int)*N);

  init_genrand(seed);

  for( i = 0 ; i < N ; i++ ){
    hash_tab[i].val = nodes_id[i];
    hash_tab[i].key = genrand_int32();
  }

  qsort(hash_tab,N,sizeof(hash_t),hash_asc);
  for( i = 0 ; i < N ; i++ )
    sol[i] = hash_tab[i].val;

  FREE(hash_tab);
  return sol;
}
static int Lseed(lua_State *L)			/** seed(c,[seed]) */
{
 MT *c=Pget(L,1);
 init_genrand(c,luaL_optnumber(L,2,SEED));
 lua_settop(L,1);
 return 1;
}
Beispiel #16
0
int main(int argc, char *argv[])
{
    int size, j, p;
    init_genrand(0UL);
    for (p = 512; p >= 500; p--) {
	size = p;
	double *A = new double[size * size];
	double *U = new double[size * size];
	double *VT = new double[size * size];
	double *S = new double[size];
	if (A == NULL) {
	    printf("Out of Memory!!\n");
	    exit(1);
	}
	for (j = 0; j < size * size; j++) A[j] = genrand_real1();
	for (j = 0; j < size * size; j++) U[j] = genrand_real1();
	for (j = 0; j < size * size; j++) VT[j] = genrand_real1();
	for (j = 0; j < size; j++) S[j] = genrand_real1();
	bench_gesdd(size, A, U, VT, S);
	delete[]S;
	delete[]VT;
	delete[]U;
	delete[]A;
    }
    return 0;
}
int main(){
  int nset=NSETS;
  int ndata=ARRAY_LENGTH;
  int hash_size=HASH_SIZE;
  /* double* data; */
  double** data2d;
  char *sdata = "hoge";

  /* unsigned long hash,hash2,hash3,hash4; */

  unsigned long* hash;
  unsigned long* hash2;
  unsigned long* hash3;
  unsigned long* hash4;


  
  int i,j;

  data2d=(double**) malloc(sizeof(double*)*nset);
  hash=(unsigned long*) malloc(sizeof(unsigned long)*nset);
  hash2=(unsigned long*) malloc(sizeof(unsigned long)*nset);
  hash3=(unsigned long*) malloc(sizeof(unsigned long)*nset);
  hash4=(unsigned long*) malloc(sizeof(unsigned long)*nset);

  for(i=0;i<nset;i++){
    data2d[i]=(double*) malloc(sizeof(double)*ndata);
  }
  /*data=(double*) malloc(sizeof(double)*ndata);*/


  init_genrand(194743097);

  for(j=0;j<nset;j++){
    for(i=0;i<ndata;i++){
      /* data[i]=genrand_res53(); */
      data2d[j][i]=genrand_res53();
    }
    /* hash=adhf_1(data,ndata,hash_size); */
    /* hash2=adhf_2(data,ndata,hash_size); */
    /* hash3=adhf_3(data,ndata,hash_size); */
    /* hash4=adhf_4(data,ndata,hash_size); */
    /* printf("%d %d %d %d\n",hash,hash2,hash3,hash4); */

  }
/*omp parallel start*/
#pragma omp parallel for
  for(j=0;j<nset;j++){
    hash[j]=adhf_1(data2d[j],ndata,hash_size);
    hash2[j]=adhf_2(data2d[j],ndata,hash_size);
    hash3[j]=adhf_3(data2d[j],ndata,hash_size);
    hash4[j]=adhf_4(data2d[j],ndata,hash_size);
  }

/*omp parallel end*/
  for(j=0;j<nset;j++){
    printf("%d %d %d %d\n",hash[j],hash2[j],hash3[j],hash4[j]);
  }
}
int main(int argc, char *argv[])
{

    if (argc < 8) {
        fprintf(stderr, "usage:\t%s <size A> <len A> <size B> <len B> "
                "<seed> <P> <size I>\n",
                argv[0]);
        return 1;
    }

    unsigned int size_A = atoi(argv[1]);
    unsigned int len_A = atoi(argv[2]);
    unsigned int size_B = atoi(argv[3]);
    unsigned int len_B = atoi(argv[4]);
    unsigned int seed = atoi(argv[5]);
    unsigned int P = atoi(argv[6]);
    unsigned int size_I = atoi(argv[7]);
    unsigned int size_T = size_I;

    if (size_I > size_B) {
        fprintf(stderr, "Index larger than DB.\n");
        return 1;
    }

    struct interval *A = (struct interval *)
                         malloc(size_A * sizeof(struct interval));
    struct interval *B = (struct interval *)
                         malloc(size_B * sizeof(struct interval));

    unsigned int *R = (unsigned int *)
                      malloc(size_A * sizeof(unsigned int));


    init_genrand(seed);
    generate_interval_sets(A, size_A, len_A, B, size_B, len_B, P);

    start();
    unsigned int O = per_interval_count_intersections_bsearch_seq(
                         A, size_A, B, size_B, R);


    stop();
    unsigned long bsearch_time = report();

    /*
    start();
    unsigned int OB = count_intersections_brute_force_seq(A, size_A, B, size_B);
    stop();
    unsigned long brute_force_time = report();
    */

    int i;
    for (i = 0; i < size_A; i++)
        if (R[i] != 0)
            printf("%d\t%u\n", i, R[i]);
    printf("b:%u,%lu\n",
           O, bsearch_time);
}
Beispiel #19
0
int main(int argc, char **argv)
{
    int i;

    struct details details;
    struct gges_population *pop;
    struct gges_parameters *params;
    struct gges_bnf_grammar *G;
    char bufvar[255];

    struct timeval t;
    gettimeofday(&t, NULL);
    init_genrand(t.tv_usec);

    details.b = atoi(argv[2]);
    details.n = 1 << details.b;
    details.data = generate_data(details.b);

    params = gges_default_parameters();
    params->rnd = genrand_real2;
    i = 3; while (i < argc) {
        if (strncmp(argv[i], "-p", 2) == 0) {
            process_parameter(argv[i + 1], params);
            i += 2;
        } else {
            parse_parameters(argv[i++], params);
        }
    }

    G = gges_load_bnf(argv[1]);
    /* add the features to the grammar, starting from the second
     * variable. The current implementation requires us to
     * "completely" specify the grammar in the source file, meaning
     * that no non-terminals can be left incomplete, therefore, we
     * have to include the first variable in the source file, and then
     * start from the second one */
    if (gges_grammar_has_non_terminal(G, "<bit>")) {
        for (i = 1; i < details.b; ++i) {
            sprintf(bufvar, "<bit> ::= b%d", i);
            gges_extend_grammar(G, bufvar, true);
        }
    } else {
        for (i = 1; i < details.b; ++i) {
            sprintf(bufvar, "<B> ::= b%d", i);
            gges_extend_grammar(G, bufvar, true);
        }
    }

    pop = gges_run_system(params, G, eval, NULL, report, &details);

    gges_release_population(pop);
    free(params);
    gges_release_grammar(G);

    free_data(details.data);

    return EXIT_SUCCESS;
}
Beispiel #20
0
int main(int argc, char *argv[]) {
	init_genrand(time(NULL));

	lab *laboratory = new lab();

	get_parameters(argc, argv, laboratory);

	return 0;
}
Beispiel #21
0
void Random_Seed(unsigned long int seed)
{
#if EXTLIB_EXIST(GSL)
  gsl_rng_init();
  gsl_rng_set(Random_Generator, seed);
#else
  init_genrand(seed);
#endif
}
Beispiel #22
0
int main(void)
{
	unsigned long oneSeed = 4357UL;
	unsigned long bigSeed[4] = { 0x123, 0x234, 0x345, 0x456 };
	
	printf( "Testing output and speed of mt19937ar-c*k.c\n" );
	printf( "\nTest of random integer generation:\n" );
	init_by_array( bigSeed, 4 );
	for( i = 0; i < 1000; ++i )
	{
		printf( "%10lu ", genrand_int32() );
		if( i % 5 == 4 ) printf("\n");
	}
	
	printf( "\nTest of random real number [0,1) generation:\n" );
	for( i = 0; i < 1000; ++i )
	{
		printf( "%10.8f ", genrand_real2() );
		if( i % 5 == 4 ) printf("\n");
	}
	
	printf( "\nTest of random real number [0,1] generation:\n" );
	init_genrand( oneSeed );
	for( i = 0; i < 1000; ++i )
	{
		printf( "%10.8f ", genrand_real1() );
		if( i % 5 == 4 ) printf("\n");
	}
	
	
	printf( "\nTest of time to generate 300 million random integers:\n" );
	init_genrand( oneSeed );
	start = clock();
	for( i = 0; i < 300000000; ++i )
	{
		junk = genrand_int32();
	}
	stop = clock();
	printf( "Time elapsed = " );
	printf( "%8.3f", (double)( stop - start ) / CLOCKS_PER_SEC );
	printf( " s\n" );
	
	return 0;
}
Beispiel #23
0
static int l_random_seed(lua_State *L)
{
	MT *m = l_checkRandom(L, 1);

	init_genrand(m, luaL_optnumber(L, 2, time(NULL)));

	lua_settop(L, 1);

	return 1;
}
Beispiel #24
0
void test_rnn_runner (void)
{
    struct test_rnn_runner_data t_data[4];

    init_genrand(391919L);

    mu_run_test(test_new_rnn_runner);

    mu_run_test_with_args(test_init_rnn_runner, t_data, 1, 10, 1, 1,
            STANDARD_TYPE, 2, (int[]){50,100});
Beispiel #25
0
static int seed_rng (lua_State *L) {
  nl_RNG *r = getrng(L);
  if (lua_isnoneornil(L, 1))
    init_genrand(r, RNG_SEED);
  else if (lua_isnumber(L, 1)) /* seed? */
    init_genrand(r, lua_tointeger(L, 1));
  else { /* vector */
    unsigned long initkey[RNG_MAXSTATES];
    int i, k;
    lua_Number *e;
    nl_Matrix *m = nl_checkmatrix(L, 1);
    checkrvector(L, m, 1);
    for (i = 0, e = m->data; i < m->size; i++, e += m->stride) {
      lua_number2int(k, *e);
      initkey[i] = (unsigned long) k;
    }
    init_by_array(r, initkey, m->size);
  }
  return 0;
}
Beispiel #26
0
void RunSpeedSimulation
(
__global int* intStream,
  int* pCharPos,
  int cSimulations,
  int seed
)
{
  //These are needed for FastRandom function calls
  unsigned long mt[N];
  int mti=N+1;

  SimulationResults results;
  Board board;
      
  double averageResult = 0.0;

  double blackWinPercentage = 0;
  int x;

  SetupBoard(&board);

  init_genrand(seed, mt, &mti);

  results.blackPlays = 0;
  results.whitePlays = 0;

  for(x = 0; x < cSimulations; x++)
  {
    MonteCarloSimulate(&board, genrand_int32(mt, &mti), &results, mt, &mti);
    averageResult += results.scoreInFavourOfBlack;

    if(results.scoreInFavourOfBlack > 0)
      blackWinPercentage++;
  }
  

  WriteStringToIntStream(intStream, pCharPos, "(");
  WriteFloatToIntStream(intStream, pCharPos, (float)averageResult / cSimulations, 5);
  WriteStringToIntStream(intStream, pCharPos, ") <average result> with ");

  WriteStringToIntStream(intStream, pCharPos, "(");
  WriteFloatToIntStream(intStream, pCharPos, (float)blackWinPercentage / cSimulations, 5);
  WriteStringToIntStream(intStream, pCharPos, ") <average black win percentage>\n");

  WriteStringToIntStream(intStream, pCharPos, "(");
  WriteFloatToIntStream(intStream, pCharPos, (float)results.blackPlays / cSimulations, 5);
  WriteStringToIntStream(intStream, pCharPos, ") <average black plays>\n");

  WriteStringToIntStream(intStream, pCharPos, "(");
  WriteFloatToIntStream(intStream, pCharPos, (float)results.whitePlays / cSimulations, 5);
  WriteStringToIntStream(intStream, pCharPos, ") <average white plays>\n");

}
Beispiel #27
0
void init_world() {
	lcdMainOnBottom();

#ifndef NATIVE
	// TODO: replace with gettimeofday() or similar
	init_genrand(genrand_int32() ^ (IPC->time.rtc.seconds +
				IPC->time.rtc.minutes*60 + IPC->time.rtc.hours*60*60 +
				IPC->time.rtc.weekday*7*24*60*60));
#else
	{
		struct timeval tv;
		gettimeofday(&tv,NULL);
		init_genrand(tv.tv_usec+tv.tv_sec*1000000);
	}
#endif

	new_game();

	torch.run(handler);
}
void _decrypt(char * pBuffer, size_t size, size_t seed )
{
	s_mersenne_twister_status mt;
	size_t i;
	unsigned long rseed = (seed << 7) ^ 0xA9C36DE1;
	init_genrand(&mt, rseed);
	for (i = 0; i < size;i++)
	{
		pBuffer[i] = (char)(pBuffer[i]  ^ genrand_int32(&mt));
	}
}
Beispiel #29
0
/* =============================================================================
 * random_alloc
 * -- Returns NULL if failure
 * =============================================================================
 */
random_t*
random_alloc (void)
{
    random_t* randomPtr = (random_t*)SEQ_MALLOC(sizeof(random_t));
    if (randomPtr != NULL) {
        randomPtr->mti = N;
        init_genrand(randomPtr->mt, &(randomPtr->mti), RANDOM_DEFAULT_SEED);
    }

    return randomPtr;
}
void optimum_reparam(double *C1, double *C2, int n, int d, double w,
                     bool onlyDP, bool rotated, bool isclosed, int skipm, int autoselectC,
                     double *opt, bool swap, double *fopts, double *comtime)
{
    /* dimensions of input matrices */
    /* opt size is n + d*d +1 */
    /* fopts and comtime are 5 x 1*/
    integer n1, d1;
    n1 = static_cast<integer> (n);
    d1 = static_cast<integer> (d);
    bool swapi;

    std::string methodname = "";
    if (!onlyDP)
        methodname = "RBFGS";

    init_genrand(0);

    CheckMemoryDeleted = new std::map<integer *, integer>;

    integer numofmanis = 3;
    integer numofmani1 = 1;
    integer numofmani2 = 1;
    integer numofmani3 = 1;
    L2SphereVariable FNSV(n);
    OrthGroupVariable OGV(d);
    EucVariable EucV(1);
    ProductElement *Xopt = new ProductElement(numofmanis, &FNSV, numofmani1, &OGV, numofmani2, &EucV, numofmani3);

    integer ns, lms;

    DriverElasticCurvesRO(C1, C2, d1, n1, w, rotated, isclosed, onlyDP, skipm, methodname,
                          autoselectC, Xopt, swapi, fopts, comtime, ns, lms);

    swap = swapi;

    /* get output data */
    integer sizex = n1 + d1 * d1 + 1;
    const double *Xoptptr = Xopt->ObtainReadData();
    integer inc = 1;
    dcopy_(&sizex, const_cast<double *> (Xoptptr), &inc, opt, &inc);

    delete Xopt;

    std::map<integer *, integer>::iterator iter = CheckMemoryDeleted->begin();
    for (iter = CheckMemoryDeleted->begin(); iter != CheckMemoryDeleted->end(); iter++)
    {
        if (iter->second != 1)
            std::cout << "Global address:" << iter->first << ", sharedtimes:" << iter->second << std::endl;
    }
    delete CheckMemoryDeleted;
    return;
}