Example #1
0
int main()
{
    std_setup();
    
    
    int N = 300;
    
    grid2D<> u( N, 0, 1, N, 0, 1 );
    
    
    
    
    plot2D plt( 0,1,0,1, N, N);
    plt = ml_white;
    ml_random rng;
    
    int count = 0;
    
    
    for (int k=0; k<100000; k++)
    {
        cout << k << endl;
        
        plt = ml_white;
        
        double x1 = rng.gen_double();
        double x2 = rng.gen_double();
        double x3 = rng.gen_double();
        double x4 = rng.gen_double();
        double y1 = rng.gen_double();
        double y2 = rng.gen_double();
        double y3 = rng.gen_double();
        double y4 = rng.gen_double();
        
        double x,y;
        
        int res = intersection( x,y, x1, y1, x2, y2, x3, y3, x4, y4 );
        bool straddle = straddle_test( x1,x2,x3,x4,y1,y2,y3,y4 );
        
        plt.ptDot( x,y, 5, ml_green );
        
        if ( ( straddle and res == 1 ) or ( !straddle and res == 0 ) )
        {
            plt.ptLine( x1,y1,x2,y2, ml_black );
            plt.ptLine( x3,y3,x4,y4, ml_black );
            
          // sprintf(fname, "/workspace/output/SDE/project1/test/%04d.png", k );
          // plt.png(fname);
            
            count ++;
        }
        
        
    }
    
    cout << count << endl;
    
    
    std_exit();
}
Example #2
0
int main()
{
	std_setup();
	
	grid2D<> G1;
    grid2D<> G2;
	
	/*sprintf(fname,"/workspace/output/anisotropic_propagate_2d/out_dat/C2.dat" );
	readFile(G,fname);
	sprintf(fname,"/workspace/output/anisotropic_propagate_2d/out_png/C2.png" );
	plotGrid2D_1(G,fname,cmap);*/
	
    
	for( int n = 0; n<9000; n+=1)
	{
		sprintf(fname,"/workspace/output/elastic_propagate_2d/out_dat/u1_%05d.dat" ,n);
        cout << fname << endl;
		if ( readFile(G1,fname) ) break;
		
        sprintf(fname,"/workspace/output/elastic_propagate_2d/out_dat/u2_%05d.dat" ,n);
        cout << fname << endl;
		if ( readFile(G2,fname) ) break;
        
		sprintf(fname,"/workspace/output/elastic_propagate_2d/out_png/%05d.png" ,n);	    
		plot( fname, G1, G2, cmap );
	}	
}
Example #3
0
int main()
{
    std_setup();
    
    if (0)
    {
        plot2D plot(-4.0,4.0,-4.0,4.0, 600,600 );
        plot = c3_creme;
        plot.axes_1(0,0, 1, c3_creme,c3_black,plot2D_stdFormat,c3_black, 10,10,1,10  );
        
        
       // plot.plot( plot_schauder ,c3_blue);
        
        sprintf(fname,"%s/out/out.png",pwd);
        plot.png(fname);    
    }
    
    
    double stop_time = 1.0;
    int j = 3;
    
    for (j=0; j<=7; j++)
    {
        int k_max = stop_time*(1 << j);
        
        int n_steps = 400;
        
        double W[n_steps];
        double t[n_steps];
        
     /*   ml_random rng;
        
        for (int step = 0; step<n_steps; step++)
        {
            t[step] = (stop_time*step)/n_steps;
            
            double sum = 0;
            for (int k=0; k<=k_max; k++)
                sum += N_RV(rng.gen_double())*phi(t[step],k,j);
            
            W[step] = sum;
        }
        */
        
                
        plot2D plot(-0.1,stop_time*1.1,-10,10, 900,600 );
        plot = c3_creme;
        plot.axes_1(0,-7, 1, c3_creme,c3_black,plot2D_stdFormat,c3_black, 0.1,10,1,10  );
        
        //plot.plot<double, double >(&(t[0]),&(W[0]),n_steps ,c3_black);
        
        sprintf(fname,"%s/out/.png",pwd,j);
        plot.png(fname);
        
    }
    
    

}
Example #4
0
int main()
{
    std_setup();
    
    int N = 12;
    double X0 = 10;
    int n1 = 256;
    int n2 = n1;
    
    rgrid2D grid( n1, -X0, X0,  n2, -X0, X0 );
    
    rgrid2D * AN = new rgrid2D [N+1];
    for (int k=0; k<=N; k++ )
        AN[k] = grid;
        
    rgrid2D * NU = new rgrid2D [N+1];
    for (int k=0; k<=N; k++ )
        NU[k] = grid;
    
//    laplacian_2d_fd Del2;
//    Del2.init( grid.n1, grid.n2, grid.b1-grid.a1, grid.b2-grid.a2, 24, 24 );
    
    double gamma = 0.4;
    int m = 12;
    
    laplacian_2d_hdaf Del2;
    Del2.init( grid.n1, grid.n2, grid.b1-grid.a1, grid.b2-grid.a2, m, m,  gamma, gamma );
    
    for (int k=0; k<=N; k++ )
        AN[k] = gauss(k);
    
    NU[0] = AN[0];
    
    for (int k=1; k<=N; k++ )
        Del2.execute( NU[k-1].array, NU[k].array );
    
    double * x = ml_alloc<double> (N);
    double * y = ml_alloc<double> (N);
    
    for (int k=1; k<=N; k++ )
    {
        y[k-1] = log10(l2_error( AN[k].array, NU[k].array, n1, n2 ));
        x[k-1] = k;
        
        if (k >1 ) cout << k << "\t" << y[k-1] << "\t" << y[k-1]-y[k-2] << endl;
        else cout << k << "\t" << y[k-1] << endl;
        
        sprintf(fname, "/workspace/output/temp/numeric_%02d.png", k );
        plotGrid2D_1( NU[k], fname,cmap);
        
        sprintf(fname, "/workspace/output/temp/analytic_%02d.png", k );
        plotGrid2D_1( AN[k], fname,cmap);
    }
    
    double slope, wefqewf;
    ml_slope( x, y, N, slope, wefqewf );
    
    cout << slope << endl;
}
Example #5
0
File: idtest.c Project: 1ack/Impala
int
main( int argc, char **argv )
{
#ifdef HAVE_PSAP_H
	PE	pe;
	PS	psin, psout, pserr;

	/* read the pe from standard in */
	if ( (psin = ps_alloc( std_open )) == NULLPS ) {
		perror( "ps_alloc" );
		exit( EXIT_FAILURE );
	}
	if ( std_setup( psin, stdin ) == NOTOK ) {
		perror( "std_setup" );
		exit( EXIT_FAILURE );
	}
	/* write the pe to standard out */
	if ( (psout = ps_alloc( std_open )) == NULLPS ) {
		perror( "ps_alloc" );
		exit( EXIT_FAILURE );
	}
	if ( std_setup( psout, stdout ) == NOTOK ) {
		perror( "std_setup" );
		exit( EXIT_FAILURE );
	}
	/* pretty print it to standard error */
	if ( (pserr = ps_alloc( std_open )) == NULLPS ) {
		perror( "ps_alloc" );
		exit( EXIT_FAILURE );
	}
	if ( std_setup( pserr, stderr ) == NOTOK ) {
		perror( "std_setup" );
		exit( EXIT_FAILURE );
	}

	while ( (pe = ps2pe( psin )) != NULLPE ) {
		pe2pl( pserr, pe );
		pe2ps( psout, pe );
	}

	exit( EXIT_SUCCESS );
#else
	fprintf(stderr, "requires ISODE X.500 distribution.\n");
	return( EXIT_FAILURE );
#endif
}
Example #6
0
int main()
{
    std_setup();
    
    int n = 256;
    double x0 = ml_pi;
    
    double tf = 1.0;
    double dt = 0.1;
    
    grid2D<double,double,double > grid( n,-x0,x0, n,-x0,x0 ),u,v,C2,damp;
    grid = 0.0;
    
    u = grid;
    v = grid;
    C2 = grid;
    
    C2 = 1.0;
    u = u_0_func();
    
    sprintf(fname,"/workspace/output/acoustic_propagate_2d/out_dat/C2.dat", n);
    writeFile(C2,fname);
    
    linear_propagator P;
    P.init( grid, 1, C2 );
    
    double t = 0.0;
    
    while (t <= tf)
    {
        output(t,u,v);
        
        double t1 = get_real_time();
        
        P( dt, u,v,u,v );
        
        double t2 = get_real_time();        
        cout << t << "\t" << t2-t1 << endl;
        
        t += dt;
    }
       
    output(t,u,v);
}
Example #7
0
int main()
{
	std_setup();
	
	grid2D<> G;
	
	sprintf(fname,"/workspace/output/acoustic_propagate_2d/out_dat/C2.dat" );
	readFile(G,fname);
	sprintf(fname,"/workspace/output/acoustic_propagate_2d/out_dat/C2.png" );
	plotGrid2D_1(G,fname,cmap);
	
	for( int n = 0; n<9000; n+=1)
	{
		sprintf(fname,"/workspace/output/acoustic_propagate_2d/out_dat/u_%05d.dat" ,n);
        cout << fname << endl;
		if ( readFile(G,fname) ) break;
		
		sprintf(fname,"/workspace/output/acoustic_propagate_2d/out_png/%05d.png" ,n);	    
		plotGrid2D_1(G,fname,cmap);
	}	
}
Example #8
0
int main()
{
    std_setup();
    
    ml_random rng;
    
    
    
    {
		// output analytic solution
		
        grid2D<double, double > F1( 500, -10.0, 10.0, 500, -10.0, 10.0 );
        grid2D<double, double > F2( F1 );
        grid2D<double, double > G1( F1 );
        grid2D<double, double > G2( F1 );
        
        F1 = V_1;
        F2 = V_2;
        
        laplacian_2d_hdaf Del2;
        Del2.init( F1.n1, F1.n2, F1.b1-F1.a1, F1.b2-F1.a2, 24, 24, .5, .5 );
        
        Del2.execute( F1.array, G1.array );
        Del2.execute( F2.array, G2.array );
        
        
        plotGrid2D_1( F1,  "/workspace/output/scratch/F1.png", color_map_green );
        plotGrid2D_1( F2,  "/workspace/output/scratch/F2.png", color_map_green );
        plotGrid2D_1( G1,  "/workspace/output/scratch/G1.png", color_map_error );
        plotGrid2D_1( G2,  "/workspace/output/scratch/G2.png", color_map_error );
	}
    
    
    
    
    
    
    std_exit();
}
Example #9
0
int main()
{
    std_setup();
    
    

    double T0;
    int tres=0;
    tres = 1.0/get_time_resolution();
    T0=get_real_time();
    cout << tres << endl;
    
    
    
    
    pthread_t pth;
    
    char args[100];
    *(double*)args =T0;
    *(int*)(args+8)=tres;
    
    
    pthread_create( &pth, NULL, threadFunc, (void*)args );
    
    pthread_join(pth, NULL);
    
    for (int k=0; k<100; k++)
    {
        cout << "m\t" << (get_real_time()-T0)*tres << endl;
    }
    
    
    
	
    
    std_exit();
}
Example #10
0
main()
{
	struct  passwd  *pw_entry ;
	struct  passwd  *getpwuid() ;
	struct	stat	buf ;

	int	i = 1 ;
	int     uid ;
	int	um ;
	char	pass1[LINESIZE] ;
	char	pass2[LINESIZE] ;
	char	Read_in_Stuff[LINESIZE] ;
	char	**vecptr ;
	char 	*tmpdraft ;
	char	home_dir[LINESIZE] ;
	char	*p, *part1, *part2 ;
	char	quipurc_file[100] ;
	char	tailor_file[100] ;
	char	user_name[9] ;
	char	*localptr = Local ;
	char	print_format = EDBOUT ;
	EntryInfo	*ptr ;
	static  CommonArgs ca = default_common_args;
	
	vecptr = (char **) malloc(100) ;
	vecptr[0] = malloc (LINESIZE) ;
	(void) strcpy(vecptr[0], "showentry") ;
	(void) strcpy(pass1, "x") ;
	(void) strcpy(pass2, "y") ;
	tmpdraft = malloc (LINESIZE) ;
	(void) strcpy(tmpdraft, "/tmp/dish-") ;

	if ((opt = ps_alloc (std_open)) == NULLPS)
		fatal (-62, "ps_alloc failed");
	if (std_setup (opt, stderr) == NOTOK)
		fatal (-63, "std_setup failed");
	if ((rps = ps_alloc (std_open)) == NULLPS)
		fatal (-64, "ps_alloc 2 failed");
	if (std_setup (rps, stdout) == NOTOK)
		fatal (-65, "std_setup 2 failed");
	(void) strcpy(filterstring, "userid=") ;

	/* Sort out files, userids etc. */
	uid=getuid() ;
	if ((pw_entry=getpwuid(uid)) == 0)
	{
		ps_printf(rps, "Who are you? (no name for your uid number)\n") ;
		exit(1) ;
	}
	(void) strcpy(user_name, pw_entry->pw_name) ;
	(void) strcat(tmpdraft, user_name) ;

	if (getenv("HOME") == 0) 
	{
		ps_printf(rps, "No home directory?!!") ;
		(void) strcpy(home_dir, pw_entry->pw_dir) ;
	}
	else
	{
		(void) strcpy(home_dir, getenv("HOME")) ;
	}

	(void) strcpy(quipurc_file, home_dir) ;
	(void) strcat(quipurc_file, "/.quipurc") ;

	(void) strcpy(tailor_file, isodefile ("dishinit", 1));

	Manager[0] = 0;
	Password[0] = 0;
	Local[0] = 0;

	(void) stat(tailor_file, &buf) ;
	(void) seteuid(buf.st_uid) ;	/* set effective to enable */
					/* us to read protected file */

	if ((fp_tailor = fopen(tailor_file, "r")) == 0)
	{
		ps_print(rps, "Can't open Tailor File. Abort.\n") ;
		exit(1) ;
	}

	while (fgets (Read_in_Stuff, LINESIZE, fp_tailor) != 0)
	{
		if (!strcmp(Read_in_Stuff, "##Anything after this line is copied into the users ~/.quipurc file\n"))
		{
			break ;
		}

		p = SkipSpace (Read_in_Stuff);
		if (( *p == '#') || (*p == '\0'))
			continue;  		/* ignore comments and blanks */

		part1 = p;
		if ((part2 = index (p,':')) == NULLCP) {
			ps_printf (opt,"Seperator missing '%s'. Ignoring..\n",p);
		}

		*part2++ = '\0';
		part2 = TidyString (part2);

		if (lexequ(part1, "manager") == 0)
		{
			(void) strcpy(Manager, part2) ;
		}
		else
		if (lexequ(part1, "password") == 0)
		{
			(void) strcpy(Password, part2) ;
		}
		else
		if (lexequ(part1, "local") == 0)
		{
			(void) strcpy(Local, part2) ;
		}
		else
		{
			ps_printf(rps, "Error in tailor. What's a %s?\n", part1) ;
		}

	}
	(void) setuid(uid) ;			/* Restore Userid to original user. */

/* create ~/.quipurc file. NB this does eradicate anything in there.
 * 			   (Theoretically nothing.) 
 */

	if (Manager[0] == 0) {
		ps_print(rps, "Can't find out the managers name\n") ;
		exit(1) ;
	}
	if (Password[0] == 0) {
		ps_print(rps, "Can't find out the managers password\n") ;
		exit(1) ;
	}
	if (Local[0] == 0) {
		ps_print(rps, "Can't find out where to search\n") ;
		exit(1) ;
	}

	um = umask(0177) ;
	if ((fp_quipurc = fopen(quipurc_file, "w")) == 0)
	{
		ps_printf(rps, "Can't open ~/.quipurc. Aborting..\n") ;
		exit(1) ;
	}
	(void) umask(um) ;	

	if ((fileps = ps_alloc(std_open)) == NULLPS)
	{
		fatal (-66, "ps_alloc 2 failed");
	}
	if (std_setup (fileps, fp_quipurc) == NOTOK)
	{
		fatal (-67, "std_setup 2 failed");
	}


	/* Sorting out the bind section */
	quipu_syntaxes() ;		/* set up the needed function pointers */
	dsap_init(&i, &vecptr) ;

	(void) strcpy(bindarg.dba_passwd, Password) ;
	bindarg.dba_version = DBA_VERSION_V1988;
	bindarg.dba_passwd_len = strlen(bindarg.dba_passwd) ;

	if ((bindarg.dba_dn = str2dn (Manager)) == NULLDN) 
	{
		ps_printf (opt,"Invalid Manager name %s (???!)\n",Manager) ;
		exit(1) ;
	}

	if (ds_bind (&bindarg, &binderr, &bindresult) != OK)
	{
		ps_printf(rps, "Can't bind as the manager.\n") ;
		exit(1);
	}
	/* Hopefully, should be successfully bound */

/*
 * We now call the search stuff with the right bits, to see if we can get a
 * match of uid='user_name'. Once there, we echo lots of information from
 * their entry out to the .quipurc file.
 * Hopefully there should only be one match. This assumes that ALL dir info
 * up to date, and that SG do not allow multiple users with the same login.
 */

/* set up the appropriate structures and defaults. */

	search_arg.sra_common = ca; /* struct copy */
	search_arg.sra_common.ca_servicecontrol.svc_sizelimit = 2 ;
	search_arg.sra_eis.eis_allattributes = FALSE ;
	search_arg.sra_searchaliases = FALSE;
	search_arg.sra_subset = SRA_ONELEVEL;
	search_arg.sra_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES ;
	search_arg.sra_eis.eis_select = NULLATTR ;
	search_arg.sra_eis.eis_allattributes = TRUE ;
	search_arg.sra_filter = filter_alloc() ;
		/* Default filter. */
		search_arg.sra_filter->flt_next = NULLFILTER;
		search_arg.sra_filter->flt_type = FILTER_ITEM;
		search_arg.sra_filter->FUFILT = NULLFILTER;
		

	if (*localptr == '@')
	{
		localptr++;
	}
	if ((search_arg.sra_baseobject = str2dn(localptr)) == NULLDN)
	{
		ps_printf (opt,"Invalid sequence in username %s.\n", localptr);
		exit(1) ;
	}

	(void) strcat(filterstring, user_name) ;

	search_arg.sra_filter->flt_un.flt_un_item.fi_type = FILTERITEM_EQUALITY ;

	if ((search_arg.sra_filter->flt_un.flt_un_item.fi_un.fi_un_ava.ava_type = AttrT_new ("userid")) == NULLAttrT)
	{
		ps_printf(rps, "Oops, userid is not a valid attr type. ABORT!!\n") ;
		exit(1) ;
	}
	if ((search_arg.sra_filter->flt_un.flt_un_item.fi_un.fi_un_ava.ava_value = str2AttrV (user_name, search_arg.sra_filter->flt_un.flt_un_item.fi_un.fi_un_ava.ava_type->oa_syntax)) == NULLAttrV)
	{
		ps_printf(rps, "%s is not a valid attribute value.\n", user_name) ;
	}

/* call search */
/* We now ought to be in the right place, and with the search stuff set,
 * ready to call search, and receive one (or no) entry back, which then 
 * gets processed accordingly.
 */

	if (ds_search (&search_arg, &search_error, &search_result) != DS_OK)
	{
		ps_printf(rps, "Search failed...\n") ;
		exit (1) ;
		/* This is not the same as coming back with */
		/* message "search failed to find anything. */
	}

/* If the user does not exist in the DIT, print out the limited .quipurc
 * and the warning message, and allow the user to play DISH.
 */

	if (search_result.CSR_entries == NULLENTRYINFO)
	{
		ps_printf(opt, "Unfortunately, you seem to have no entry in\n") ;
		ps_printf(opt, "the directory. Contact '%s' who should be able to help.\n", Manager) ;
		ps_printf(opt, "In the mean time, you can read, but not write.\n") ;
	}
	else
	{
		ptr = search_result.CSR_entries ;
		dn = dn_cpy(ptr->ent_dn) ;	/* Essence of move user_name. */

		/* collect the info and put it into current_entry */

		/* Set up the desired attribute type to be read*/
		/* from read.c */
		if ((at = AttrT_new ("userPassword")) != NULLAttrT) 
		{
			as_flag = as_merge (as_flag, as_comp_new (AttrT_cpy (at), NULLAV, NULLACL_INFO));
		}
		else
		{
			ps_printf(rps, "Oops, Serious error. unknown attribute type 'userPassword'.\n") ;
			exit(1) ;
		}

		if ((current_entry = local_find_entry (dn, FALSE)) == NULLENTRY)
		{	
			read_arg.rda_common = ca; /* struct copy */
			read_arg.rda_object = dn;
			read_arg.rda_eis.eis_infotypes = EIS_ATTRIBUTESANDVALUES;
			read_arg.rda_eis.eis_allattributes = TRUE ;
			read_arg.rda_eis.eis_select = NULLATTR ;

			if (ds_read (&read_arg, &read_error, &read_result) != DS_OK)
			{
				ps_printf(rps, "We even seem to be having problems reading\n" ) ;
				ps_printf(rps, "an entry we searched and found!! HELP!!\n") ;
				exit(1) ;
			}
			if (read_result.rdr_entry.ent_attr == NULLATTR)
			{
				ps_printf(rps, "No attributes present. Even though\n") ;
				ps_printf(rps, "we found you by userid attribute!!! HELP!!\n") ;
				exit (1) ;
			}
			cache_entry (&(read_result.rdr_entry), read_arg.rda_eis.eis_allattributes, TRUE) ;
		}

		if ((current_entry = local_find_entry (dn, FALSE)) == NULLENTRY)
		{
			ps_printf(rps, "We still have nothing.Even after reading? Abort.\n") ;
			exit(1) ;
		}

		ps_printf(fileps, "username: "******"\n") ;

		ps_printf(fileps, "me: ") ;
		dn_print(fileps, dn, EDBOUT) ;
		ps_printf(fileps, "\n") ;

		/* now showattribute -nokey to display it. */

		ps_printf(fileps, "password: "******"You need a password...\n") ;
				(void) strcpy(pass1, getpassword("Enter Password: "******"Re-enter password: "******"\nMismatch - Try again.\n") ;
				}
			}
			ps_printf(fileps, "%s\n", pass1) ;

			um = umask(0177) ;
			if ((fp_draft = fopen(tmpdraft, "w")) == 0)
			{
				ps_print(rps, "Can't open draft file... Abort.\n") ;
				exit(1) ;
			}
			(void) umask(um) ;

			(void) fprintf(fp_draft, "UserPassword = %s\n", pass1) ;
		 	(void) fprintf(fp_draft, "acl = self # write # attributes # acl $ userPassword\n") ;
			(void) fprintf(fp_draft, "acl = others # compare # attributes # acl $ userPassword\n\n") ;
			(void) fclose(fp_draft) ;

			if ((fp_draft = fopen (tmpdraft, "r")) == NULL) {
				ps_printf (opt, "Can't open draft entry %s\n", tmpdraft);
				exit(1) ;
			}

			entry_ptr = get_default_entry (NULLENTRY);
#ifdef TURBO_DISK
			entry_ptr->e_attributes = fget_attributes (fp_draft);
#else
			entry_ptr->e_attributes = get_attributes (fp_draft);
#endif

			(void) fclose (fp_draft);

			mod_arg.mea_common = ca; /* struct copy */
			mod_arg.mea_object = dn;
			for (moddn = dn ; moddn->dn_parent != NULLDN; moddn=moddn->dn_parent)
				;
			entry_ptr->e_name = rdn_cpy (moddn->dn_rdn);
	
			/* add rdn as attribute */
			avst = avs_comp_new (AttrV_cpy (&entry_ptr->e_name->rdn_av));
			temp = as_comp_new (AttrT_cpy (entry_ptr->e_name->rdn_at), avst, NULLACL_INFO);
			entry_ptr->e_attributes = as_merge (entry_ptr->e_attributes, temp);

			for (as = entry_ptr->e_attributes; as != NULLATTR; as = as->attr_link)
			{
				emnew = NULLMOD;
				trail = as->attr_link;
				as->attr_link = NULLATTR;
				temp = current_entry->e_attributes;
				for (; temp != NULLATTR; temp = temp->attr_link) 
					if (AttrT_cmp (as->attr_type, temp->attr_type) == 0)
					{
						/* found it - does it need changing ? */
						if (avs_cmp (as->attr_value, temp->attr_value) != 0) 
							emnew = modify_avs (as->attr_value, temp->attr_value,as->attr_type);
						break;
					}

				if (temp == NULLATTR) 
				{
					emnew = em_alloc ();
					emnew->em_type = EM_ADDATTRIBUTE;
					emnew->em_what = as_cpy(as);
					emnew->em_next = NULLMOD;
				}
				if (emnew != NULLMOD)
				{
					mod_arg.mea_changes = ems_append (mod_arg.mea_changes,emnew);
				}
				as->attr_link = trail;
			}

			while (ds_modifyentry (&mod_arg, &mod_error) != DS_OK)
			{
				if (dish_error (opt, &mod_error) == 0)
				{
					ps_printf(rps,"We have a dish error. Bye.\n") ;
					entry_free (entry_ptr);
					exit(1) ;
				}
				mod_arg.mea_object = mod_error.ERR_REFERRAL.DSE_ref_candidates->cr_name;
			}
			ps_print (rps, "Modified ");
			dn_print (rps, dn, EDBOUT);
			ps_print (rps, "\n");
			delete_cache (dn);	/* re-cache when next read */

			entry_free (entry_ptr);
			ems_part_free (mod_arg.mea_changes);
		}
	}

	while(fgets(Read_in_Stuff, LINESIZE, fp_tailor) != 0)
	{
		fputs(Read_in_Stuff, fp_quipurc) ;
	}
		
	(void) fclose(fp_quipurc) ;	
	(void) fclose(fp_tailor) ;

/*	(void) fprintf(fp_quipurc, "dsap: local_dit \"%s\"\n", Local) ;
	(void) fprintf(fp_quipurc, "notype: acl\n") ;
	(void) fprintf(fp_quipurc, "notype: treestructure\n") ;
	(void) fprintf(fp_quipurc, "notype: masterdsa\n") ;
	(void) fprintf(fp_quipurc, "notype: slavedsa\n") ;
	(void) fprintf(fp_quipurc, "notype: objectclass\n") ;
	(void) fprintf(fp_quipurc, "cache_time: 30\n") ;
	(void) fprintf(fp_quipurc, "connect_time: 2\n") ;
 */
	(void) ds_unbind() ;
	(void) unlink(tmpdraft) ;
}
Example #11
0
int main()
{
    std_setup();
    
    int n_runs = 1E5;
    int n_steps = 30;
    int **M=0;
    
    walk_test(M,n_steps,n_runs);
    
    for ( int k=1; k<n_steps; k++ )
        cout << k << "\t" << M[k][0]  << "\t" << M[k][n_runs-1] << endl;
        
    
    for ( int k=1; k<n_steps; k++ )
    {        
        int max_ = max(M[k], n_runs );
        int min_ = min(M[k], n_runs );
        int n = abs(max_) + abs(min_) + 1;
        
        if ( max_>1 && min_<-1 )
        {
            int * c_ = ml_alloc<int > ( n );
            int *c = &c_[ -min_ ];
            
            for (int j=min_; j<=max_; j++)
                c[j] = 0;
            
            for (int j=0; j<n_runs; j++)
                c[ M[k][j] ] ++;
            
            float * p_ = ml_alloc<float > ( n );            
            float * p = &p_[ -min_ ];
            
            for (int j=min_; j<=max_; j++)
                p[j] = ((float)c[j])/n_runs;
            
            float mu = 0;
            
            for (int j=min_; j<=max_; j++)
                mu += p[k]*j;
            
            float sig2 = 0;
           
            for (int j=min_; j<=max_; j++)
                sig2 += p[k]*j*j;
            
            sig2 -= mu*mu;
            
            float sig = sqrt(sig2);
            
            clean_print(k); cout << "\t";
            clean_print(mu); cout << "\t";
            clean_print(sig); cout << "\t";
            clean_print(sig2); cout << endl;
            
            
            sprintf(fname, "/workspace/output/out_%d", k);
            output( p_ , n, fname );
            
            p=0;
            ml_free(p_);
            ml_free(c_);
        }
    }    
    
    
    
    
    std_exit();
}
Example #12
0
int main()
{
	std_setup();
    
    
    // setup:
    
    int n_steps = 500;
    int n_runs = 10000;
    
    double X0 = 0.0;
    double stop_time = 2.0;
    
    double dt = stop_time/n_steps;
    
    double * time = ml_alloc<double > ( n_steps );
    for (int k=0; k<n_steps; k++ )
        time[k] = dt*k;
    
    
    
    double **W=0, *X_true=0;
    double **X = ml_alloc<double> ( n_runs, n_steps );
    double * X_mean = ml_alloc<double> (n_steps);
    double **M = ml_alloc<double> ( n_runs, n_steps );
    
    
    
    // generate the BMs:
    
    gen_BM( dt, n_steps, W, n_runs, BM_mode_2 );
    
    
    // integrate the SDE
    
    for ( int run=0; run<n_runs; run++ )
    {
        X[run][0] = X0;
			
        for ( int j=1; j<n_steps; j++ )
        {
			X[run][j] = X[run][j-1] + ( drift(dt*j) + drift(dt*(j-1)) )*dt/2 + volatility(X[run][j-1], dt*(j-1))*(W[run][j]-W[run][j-1]);
        }
    }
    
    // compute the Girsanov change of measure at every t
    
    for ( int run=0; run<n_runs; run++ )
    for ( int k=0; k<n_steps-1; k++ )
    {
        double sum1 = 0;
        for (int j=0; j<=k; j++)
            sum1 += drift(dt*j)*drift(dt*j)*dt;
        
        double sum2 = 0;
        for (int j=0; j<=k; j++)
            sum2 += drift(dt*j)*(W[run][j+1]-W[run][j]);
        
        M[run][k] = exp(-sum2 -0.5*sum1);
    }
    
    // compute expectation of X, output results so far.
    
    for ( int step=0; step<n_steps; step++ )
        X_mean[step] = 0;
    
    for ( int run=0; run<n_runs; run++ )
    for ( int step=0; step<n_steps; step++ )
        X_mean[step] += X[run][step]/n_runs;
    
    output( X, max(n_runs,min(100,n_runs)), n_steps, "/workspace/output/SDE/test/X" );
    output( X_mean, n_steps, "/workspace/output/SDE/test/X_mean" );
    output( time, n_steps, "/workspace/output/SDE/test/time" );
    output( M, max(n_runs,min(100,n_runs)), n_steps, "/workspace/output/SDE/test/M" );
    
    
    // compute expectation of X, with respect to new measure, output results.
    
    for ( int run=0; run<n_runs; run++ )
    for ( int step=0; step<n_steps; step++ )
        X[run][step] *= M[run][step];
    
    for ( int step=0; step<n_steps; step++ )
        X_mean[step] = 0;
    
    for ( int run=0; run<n_runs; run++ )
    for ( int step=0; step<n_steps; step++ )
        X_mean[step] += X[run][step]/n_runs;
    
    
    output( X, max(n_runs,min(100,n_runs)), n_steps, "/workspace/output/SDE/test/XM" );
    output( X_mean, n_steps, "/workspace/output/SDE/test/QX" );
    
    
    
    
    
    
    ml_free( X, n_runs );
    ml_free( X_mean );
    ml_free( W, n_runs );
    ml_free( time );
    ml_free( X_mean );
    
    std_exit();
}
Example #13
0
int main()
{
    std_setup();
    
    int n=6;
    double a=1.0;
    transform_args args( a,n,0 );
    
    {
        double xi_f = 10.0;
        int N = 500;
        double h = xi_f/N;
        
        double *rp = ml_alloc<double> (2*N+1);
        double *ip = ml_alloc<double> (2*N+1);
        double *xi = ml_alloc<double> (2*N+1);
        
        for ( int j=-N; j<=N; j++ )
        {
            args.xi = h*j;
            
            xi[j+N] = args.xi;
            rp[j+N] = integrate_R ( real_part, (void *)(&args) );
            ip[j+N] = integrate_R ( imag_part, (void *)(&args) );
        }
        
        output( xi, rp, ip, 2*N+1, "/workspace/output/temp/FTF" );
    }
    
    //---------------------
    
    {
        double xf = 10.0;
        int N = 500;
        double h = xf/N;
        
        double *F = ml_alloc<double> (2*N+1);
        double *X = ml_alloc<double> (2*N+1);
        
        for ( int j=-N; j<=N; j++ )
        {
            double x = h*j;
            
            X[j+N] = x;
            F[j+N] = exp(-a*x*x)*pow(x,n);
        }
        
        output( X, F, 2*N+1, "/workspace/output/temp/F" );
    }
    
    //-----------------------
    
    {
        double xi_f = 10.0;
        int N = 500;
        double h = xi_f/N;
        
        double *FTR = ml_alloc<double> (2*N+1);
        double *FTI = ml_alloc<double> (2*N+1);
        double *Xi = ml_alloc<double> (2*N+1);
        
        ml_poly<double > P0(n); P0 = 0.0;
        ml_poly<double > P1(n); P1 = 0.0;
        ml_poly<double > P2(n); P2 = 0.0;
        ml_poly<double > P3(n); P3 = 0.0;
        
        for ( int k=0; k<=n; k++ )
        {
            if (k%4 == 0) P0[k] = binom(n,k)*dfact2n_n[n-k]*sqrtpi*pow(a,-n)*pow(2.0,k-2*n);
            if (k%4 == 1) P1[k] = binom(n,k)*dfact2n_n[n-k]*sqrtpi*pow(a,-n)*pow(2.0,k-2*n);
            if (k%4 == 2) P2[k] = binom(n,k)*dfact2n_n[n-k]*sqrtpi*pow(a,-n)*pow(2.0,k-2*n);
            if (k%4 == 3) P3[k] = binom(n,k)*dfact2n_n[n-k]*sqrtpi*pow(a,-n)*pow(2.0,k-2*n);
        }
        
        ml_poly<double > PR(n); P0 = 0.0;
        ml_poly<double > PI(n); P1 = 0.0;
        
        PR = P0; PR -= P2;
        PI = P1; PI-= P3;
        
        
        for ( int j=-N; j<=N; j++ )
        {
            double xi = h*j;
            
            Xi[j+N] = xi;
            
            FTR[j+N] = exp(-xi*xi/(a*4))*PR(xi);
            FTI[j+N] = exp(-xi*xi/(a*4))*PI(xi);
        }
        
        output( Xi, FTR, FTI, 2*N+1, "/workspace/output/temp/test" );
    }
    
    
    
    
    std_exit();
}
Example #14
0
int main()
{
    std_setup();
    
    int n = 256;
    double x0 = 10;
    
    double tf = 10.0;
    double dt = 0.05;
    int expansion_order = 7;
    int hdaf_order = 8;
    
    grid2D<double,double,double > grid( n,-10,10.0, n,-10,10.0 ),u,v,C2,damping;
    grid = 0.0;
    
    u = grid;
    v = grid;
    C2 = grid;
    damping = grid;
    
    u = u_0_func();
    C2 = C2_func();
    damping = damping_func();
    
    sprintf(fname,"/workspace/output/acoustic_propagate_2d/out_dat/C2.dat" );
    writeFile(C2,fname);
    
    
    void * pdata = 0;
    method1_init( &pdata, grid.n1, grid.n2, grid.dx1(), grid.dx2(), C2.array, damping.array, 7, hdaf_order, hdaf_order, 0.8, 0.8 );
    
    //acoustic_propagator P;
    //P.init( grid, 7, C2, damping );
    
    double t = 0.0;
    
    cout << "step: " << t << "\t" << L2norm(u) << endl;
    
    n=0;
    double * b_times = new double [ int(tf/dt+5) ];
    
    while (t <= tf)
    {
    
        output(t,u,v);
        
        double t1 = get_real_time();
        
        method1_execute( pdata, dt, u.array,v.array,u.array,v.array );
        //P( dt, u,v,u,v );
        
        double t2 = get_real_time();
        
        b_times[n] = t2-t1;
        double mean = 0;
        for (int j=0; j<n; j++)
            mean += b_times[j]/n;
        cout << mean << endl;
        n++;
        
        
        double mag = L2norm(u);
        cout << "step: " << t << "\t" << t2-t1 << "\t" << mag << endl;
        
        t += dt;
        
        if ( mag > 1E10 ) break;
    }
       
    output(t,u,v);
}
Example #15
0
int main()
{
    std_setup();
    
    mp::mp_init(100);
    
    int n = pow(2,12);
    double a = 0.0;
    double b = ml_2pi;
    
    int m = 4;
    double gamma = 0.75;
    
    vector<double > frequency;
    vector<double > error;
    vector<double > measured_response;
    vector<double > response;
    vector<double > expected_error;
    
    for (int k=1; k<=n/2; k += max(n/100,1) )
    {
        double K = (ml_2pi/(b-a))*k;
        
        double * signal = ml_alloc<double > (n);
        
        for (int i=0; i<n; i++)
        {
            double x = ((b-a)*i)/n+a;
            signal[i] = cos( x*K );
        }
        
        complex<double > * fft_ker=0;
        hdaf_filter_kernel ( fft_ker, b-a, n, m, (ml_2pi/(b-a))*(gamma*n/2) );
        
        double * signal_filtered=0;
        complex<double > * workspace=0;
        
        fft( signal, workspace, n );
        
        for (int i=0; i<n/2+1; i++)
            workspace[i] *= fft_ker[i];
        
        ifft( workspace, signal_filtered, n );
        
        
        //---------------
        
        cout << K << "\t" << l2_error( signal, signal_filtered, n ) << endl;
        
        hdaf_delta_hat delta( m, sqrt(2*m+1)/( (ml_2pi/(b-a))*(gamma*n/2) ) );
        
        frequency.push_back( K );
        measured_response.push_back( rms(signal_filtered,n)/rms(signal,n ) );
        response.push_back ( delta(K) );
        
        expected_error.push_back ( log10( fabs(delta(K)-1.0)+1E-18 ) );
        error.push_back( log10(fabs(l2_error( signal, signal_filtered, n )) +1E-18) );
        
        ml_free(fft_ker);
        ml_free(signal);
    }
    
    
    sprintf( fname, "/workspace/output/temp/frequency" );
    output ( frequency,  fname );
    sprintf( fname, "/workspace/output/temp/measured_response" );
    output ( measured_response,  fname );
    sprintf( fname, "/workspace/output/temp/error" );
    output ( error,  fname );
    sprintf( fname, "/workspace/output/temp/expected_error" );
    output ( expected_error,  fname );
    sprintf( fname, "/workspace/output/temp/response" );
    output ( response,  fname );
    
    std_exit();
}
Example #16
0
int main()
{
	std_setup();
    
    int n_steps = 500;
    int n_runs = 1000;
    
    double X0 = 0.0;
    double stop_time = 2.0;
    
    double dt = stop_time/n_steps;
    
    double * time = ml_alloc<double > ( n_steps );
    for (int k=0; k<n_steps; k++ )
        time[k] = dt*k;
    
    double **W=0, *X_true=0;
    double **X = ml_alloc<double> ( n_runs, n_steps );
    double * X_mean = ml_alloc<double> (n_steps);
    
    double **M = ml_alloc<double> ( n_runs, n_steps );
    
    gen_BM( dt, n_steps, W, n_runs, BM_mode_2 );
    
    for ( int run=0; run<n_runs; run++ )
    for ( int k=0; k<n_steps-1; k++ )
    {
        double sum1 = 0;
        for (int j=0; j<=k; j++)
            sum1 += drift(dt*j)*drift(dt*j)*dt;
        
        double sum2 = 0;
        for (int j=0; j<=k; j++)
            sum2 += drift(dt*j)*(W[run][j+1]-W[run][j]);
        
        M[run][k] = exp(-sum2 -0.5*sum1);
    }
    
    for ( int run=0; run<n_runs; run++ )
    {
        X[run][0] = X0;
			
        for ( int j=1; j<n_steps; j++ )
        {
			X[run][j] = X[run][j-1] + ( drift(dt*j) + drift(dt*(j-1)) )*dt/2 + volatility(X[run][j-1], dt*(j-1))*(W[run][j]-W[run][j-1]);
        }
    }
    
    for ( int step=0; step<n_steps; step++ )
        X_mean[step] = 0;
    
    for ( int run=0; run<n_runs; run++ )
    for ( int step=0; step<n_steps; step++ )
        X_mean[step] += X[run][step]/n_runs;
    
    output( X, max(n_runs,min(100,n_runs)), n_steps, "/workspace/output/SDE/test/X" );
    output( X_mean, n_steps, "/workspace/output/SDE/test/X_mean" );
    output( time, n_steps, "/workspace/output/SDE/test/time" );
    output( M, max(n_runs,min(100,n_runs)), n_steps, "/workspace/output/SDE/test/M" );
    
    for ( int run=0; run<n_runs; run++ )
    for ( int step=0; step<n_steps; step++ )
        X[run][step] *= M[run][step];
    
    for ( int step=0; step<n_steps; step++ )
        X_mean[step] = 0;
    
    for ( int run=0; run<n_runs; run++ )
    for ( int step=0; step<n_steps; step++ )
        X_mean[step] += X[run][step]/n_runs;
    
    
    output( X, max(n_runs,min(100,n_runs)), n_steps, "/workspace/output/SDE/test/XM" );
    output( X_mean, n_steps, "/workspace/output/SDE/test/QX" );
    
    ml_free( X, n_runs );
    ml_free( X_mean );
    ml_free( W, n_runs );
    ml_free( time );
    ml_free( X_mean );
    
    std_exit();
}
Example #17
0
int main( int argc, char *argv[] )
{
    //for (int k=1; k<argc; k++ )
    //    cout << argv[k] << endl;
    
    
	std_setup();
    
    // setup:
    
    int n_steps = 100;
    int n_runs = 100;
    double X0 = 0.0;
    double stop_time = 2.0;
    double * drift=0;
    char dir[] = "/workspace/output/SDE/test";
    
    {
        
        // n_runs 
        
        if(argc>=2)
        try {
            n_runs = boost::lexical_cast< int >( argv[1] );
        }
        catch (const boost::bad_lexical_cast &) {
            
        }
        
        // n_steps 
        
        if(argc>=3)
        try {
            n_steps = boost::lexical_cast< int >( argv[2] );
        }
        catch (const boost::bad_lexical_cast &) {
            
        }
        
        // X0 
        
        if(argc>=4)
        try {
            X0 = boost::lexical_cast< double >( argv[3] );
        }
        catch (const boost::bad_lexical_cast &) {
            
        }
        
        // stop_time
        
        if(argc>=4)
        try {
            stop_time = boost::lexical_cast< double >( argv[4] );
        }
        catch (const boost::bad_lexical_cast &) {
            
        }
        
        // drift
        
        if(argc>=6)
        {
            ifstream in;
            sprintf(fname,"%s/%s", dir, argv[5]);
            in.open(fname, ios::in);
            if ( in.good() && in.is_open() );
            {
                drift = ml_alloc<double> (n_steps);
                for (int k=0; k<n_steps; k++)
                    drift[k] = 0.0;
                char str[200];
                
                int k=0;
                while ( in>>str and k<n_steps )
                {
                    try {
                        drift[k] = boost::lexical_cast< double >( str );
                    } catch (const boost::bad_lexical_cast &) {
                        }
                    k++;
                }
                
                in.close();
            }
        }
    }