IMPISD_BEGIN_NAMESPACE

GaussianProcessInterpolation::GaussianProcessInterpolation(
    FloatsList x, Floats sample_mean, Floats sample_std, unsigned n_obs,
    UnivariateFunction *mean_function, BivariateFunction *covariance_function,
    Particle *sigma, double sparse_cutoff)
    : Object("GaussianProcessInterpolation%1%"),
      x_(x),
      n_obs_(n_obs),
      mean_function_(mean_function),
      covariance_function_(covariance_function),
      sigma_(sigma),
      cutoff_(sparse_cutoff) {
  // O(M)
  // store dimensions
  M_ = x.size();
  N_ = x[0].size();
  sigma_val_ = Scale(sigma_).get_nuisance();
  // basic checks
  IMP_USAGE_CHECK(sample_mean.size() == M_,
                  "sample_mean should have the same size as x");
  IMP_USAGE_CHECK(sample_std.size() == M_,
                  "sample_std should have the same size as x");
  IMP_USAGE_CHECK(mean_function->get_ndims_x() == N_,
                  "mean_function should have " << N_ << " input dimensions");
  IMP_USAGE_CHECK(mean_function->get_ndims_y() == 1,
                  "mean_function should have 1 output dimension");
  IMP_USAGE_CHECK(covariance_function->get_ndims_x1() == N_,
                  "covariance_function should have "
                      << N_ << " input dimensions for first vector");
  IMP_USAGE_CHECK(covariance_function->get_ndims_x2() == N_,
                  "covariance_function should have "
                      << N_ << " input dimensions for second vector");
  IMP_USAGE_CHECK(covariance_function->get_ndims_y() == 1,
                  "covariance_function should have 1 output dimension");
  // set all flags to false = need update.
  force_mean_update();
  force_covariance_update();
  // compute needed matrices
  compute_I(sample_mean);
  compute_S(sample_std);
}
int main()
{
    vtx **P;
    vtx *gd;
    vtx *S;
    double hmin;

    P = (vtx**)malloc(3 * sizeof(vtx*));
    gd = (vtx*)malloc(sizeof(vtx));
    S = (vtx*)malloc(sizeof(vtx));

    *(P + 0) = initialize_vertex(*(P + 0));
    *(P + 1) = initialize_vertex(*(P + 1));
    *(P + 2) = initialize_vertex(*(P + 2));
    gd = initialize_vertex(gd);
    S = initialize_vertex(S);

    (*(P + 0))->coord_x = -3;
    (*(P + 0))->coord_y = -2;

    do{
        gd = gradient(*(P + 0),gd);
        S = compute_S(gd, S);

        //show_vertex(gd);
        //show_vertex(S);
        hmin = compute_min(*(P + 0), S);
        printf("%.8lf\\\\\\hline\n",hmin);
        (*(P + 1))->coord_x = (*(P+0))->coord_x;
        (*(P + 1))->coord_y = (*(P+0))->coord_y;
        (*(P + 0))->coord_x = (*(P+0))->coord_x + hmin * S->coord_x;
        (*(P + 0))->coord_y = (*(P+0))->coord_y + hmin * S->coord_y;
    }while(distance(*(P + 0), *(P + 1)) > 1e-7);



    return 0;
}
int main(int argc, char ** argv) {


	MPI_Init(&argc, &argv);
	int P, rank;
	MPI_Comm_size(MPI_COMM_WORLD, &P);
	MPI_Comm_rank(MPI_COMM_WORLD, &rank);

    if (isPowerOfTwo(P) == false) {
        if (rank == 0) {
            printf("The number of processes is not a power of two \n");
        }        
        MPI_Finalize();
        return 1;
    }

	if (argc > 1) {
		if (rank == 0) {
			printf("No argument needed\n");
		}
		MPI_Finalize ();
		return 1;
	}

	int k;
	int k_max = 15, k_min = 3;
	double *err_vec, *S_vec;
	err_vec = calloc( k_max - k_min, sizeof(double) );
	S_vec = calloc( k_max - k_min, sizeof(double) );

	for ( k = k_min; k < k_max; k++ ) {
		int n = (int) pow(2, k);
	
		int np = (int) (n - n%P)/P;
	
		double *v, S = 0.0;

		MPI_Status status;
		int i;	

		if ( rank == 0 ) {

			FILE *f;
			f = fopen("Error_Ex03.txt", "w");
			fprintf(f, "Error Ex03, P = %d\n", P);
			
			v = calloc(n, sizeof(double));
			compute_v(n, v);
			
			for (i = 1; i < P; i++ ){
				MPI_Send( &v[np*i], np, MPI_DOUBLE, i, 0, MPI_COMM_WORLD);
			}

			double S_n = compute_S(np, v);
			MPI_Reduce(&S_n, &S, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
		
			double err = compute_error(S);

			S_vec[k - k_min] = S;
			err_vec[k - k_min] = err;

			if (k == k_max-1) {
				print_vec(k_max-k_min, S_vec, err_vec);
				for ( i = 0; i < k_max-k_min; i++ ) {
					fprintf(f, "%1.16f\n", err_vec[i]);
				}
			}

			free(v);
			fclose(f);

		}
		else {

			double *v_n;
			
            if (rank == P-1) {
				v_n = calloc(np + n%P, sizeof(double));
			}
			else {
				v_n = calloc(np, sizeof(double));
			}

			MPI_Recv(v_n, np, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status);
			double S_n = compute_S(np, v_n);
			MPI_Reduce(&S_n, &S, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
		}

	}
	
	MPI_Finalize();

	return 0;
}
Exemple #4
0
int main (int argc, char **argv) 
{
	
	double *S; /*Overlap matrix*/
	double *H; /*Core Hamiltonian*/
	double *D_new; /*Density matrix current*/
	double *D_old; /*Density matrix previous*/
	double *F; /*Fock matrix*/
	erd_t *erd_inp;
	int maxit = MAX_IT; /*Max. no of iterations*/
	int diis_lim = DIIS_LIM;
	int conv; /*convergence flag*/
	basis_set_t *basis; /*Basis set Structure*/
	double *scratch;
	double *S_sinv;


	/*Initialize Basis Set*/
	basis = create_basis_set ();
	load_basis_set (basis, argv[1]);
	preprocess_basis_set (basis);
	
	fprintf (stderr, "\n DEBUG: Initialized basis set successfully \n");
	fflush (stderr);
	
	/*Allocate memory for matrices*/
	F = (double *)malloc (basis->nfunctions * basis->nfunctions * sizeof(double));
	H = (double *)malloc (basis->nfunctions * basis->nfunctions * sizeof(double));
	D_old = (double *)malloc (basis->nfunctions * basis->nfunctions * sizeof(double));
	D_new = (double *)malloc (basis->nfunctions * basis->nfunctions * sizeof(double));
	S = (double *)malloc (basis->nfunctions * basis->nfunctions * sizeof(double));
	S_sinv = (double *)malloc (basis->nfunctions * basis->nfunctions * sizeof(double));
	scratch = (double *)malloc (basis->nfunctions * basis->nfunctions * sizeof(double));
	
	fprintf (stderr, "\n DEBUG: Initialized matrices successfully \n");
	fflush (stderr);

	/*TODO: Initialize integrals package*/
	erd_inp = init_erd (basis);
	
	fprintf (stderr, "\n DEBUG: Initialized ERD successfully \n");
	fflush (stderr);

	/*Compute Core Hamiltonian and overlap matrix*/
	compute_S (S, basis, 0, basis->nshells - 1, 0, basis->nshells - 1);
	compute_H (H, basis, 0, basis->nshells - 1, 0, basis->nshells - 1);

	fprintf (stderr, "\n DEBUG: Computed One electron stuff successfully \n");
	fflush (stderr);
	
	/* printmatCM ("S", S, basis->nfunctions, basis->nfunctions); */
	/* printmatCM ("H", H, basis->nfunctions, basis->nfunctions); */

	/*Compute square root inverse of S*/
	sqrtinv_matrix (basis->nfunctions, S, S_sinv, scratch);

	fprintf (stderr, "\n DEBUG: Computed Square root inverse of S \n");
	fflush (stderr);
	
	/*TODO: SCF iterate until converged*/
	conv = sscf (basis, erd_inp, H, S, S_sinv, basis->nfunctions, basis->nelectrons, maxit, diis_lim, D_old, D_new, F);
	
	if (!conv) {
		fprintf (stderr, "\n DEBUG: Convergence not achieved in %d iterations \n", maxit);
		fflush (stderr);
	} else {
		fprintf (stderr, "\n DEBUG: Convergence achieved! \n");
		fflush (stderr);
	}
		
	/*TODO: Print energy, and eigenvalues*/

	/*TODO: clean exit*/
	destroy_basis_set (basis);
	destroy_erd (erd_inp);
	free (F);
	free (H);
	free (S);
	free (S_sinv);
	free (scratch);
	free (D_old);
	free (D_new);
	
	fprintf (stderr, "\n DEBUG: All allocated memory freed, Exiting. \n");
	fflush (stderr);

	return 0;

}
Exemple #5
0
int main(int argc, char ** argv) {

	MPI_Init(&argc, &argv);
	int P, rank;
	MPI_Comm_size(MPI_COMM_WORLD, &P); // P = number of processes
	MPI_Comm_rank(MPI_COMM_WORLD, &rank); // Rank = numbering of each process

    if (isPowerOfTwo(P) == false) {
        if (rank == 0) {
            printf("The number of processes is not a power of two \n");
        }        
        MPI_Finalize();
        return 1;
    }

	if (argc < 2) {
		if (rank == 0) {
			printf("Usage: ex3 k, n=pow(2,k)\n");
			printf("n = vector/matrix size\n");
		}
		MPI_Finalize ();
		return 1;
	}

	
	int k = atoi(argv[1]);
	int n = (int) pow(2, k);
	
	int np = (int) (n - n%P)/P;
	
	double *v, S = 0.0;

	MPI_Status status;
	int i;	

	if ( rank == 0 ) {
		v = calloc(n, sizeof(double));
		compute_v(n, v);
			
		for (i = 1; i < P; i++ ){
			MPI_Send(&v[np*i], np, MPI_DOUBLE, i, 0, MPI_COMM_WORLD);
		}
		double S_n = compute_S(np, v);
		MPI_Reduce(&S_n, &S, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
		
		printf("S = %1.16f\n", S);
		double err = compute_error(S);
		printf("Error = %1.16f\n", err);

		free(v);

	}
	else {

		double *v_n;
		if (rank == P-1) {
			v_n = calloc(np + n%P, sizeof(double));
		}
		else {
			v_n = calloc(np, sizeof(double));
		}
		MPI_Recv(v_n, np, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status);

		double S_n = compute_S(np, v_n);
		free(v_n);

		MPI_Reduce(&S_n, &S, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
	}

	MPI_Finalize();

	return 0;
}
Exemple #6
0
int main(int argc, char ** argv) {


	MPI_Init(&argc, &argv);
	int P, rank;
	MPI_Comm_size(MPI_COMM_WORLD, &P); // size = number of processes nprocs
	MPI_Comm_rank(MPI_COMM_WORLD, &rank); // Numbering of process


	if (argc > 1) {
		// Only one process needs to print usage output
		if (rank == 0) {
			printf("Argument k needed.\n");
		}
		MPI_Finalize ();
		return 1;
	}

	double start = MPI_Wtime();

	int k = 14;
	int n = (int) pow(2, k);
	int np = (int) (n - n%P)/P;

	double *v, S = 0.0;

	MPI_Status status;
	int i;	

	if ( rank == 0 ) {
	
		v = calloc(n, sizeof(double));
		compute_v(n, v);
	
		for (i = 1; i < P; i++ ){
			MPI_Send( &v[np*i], np, MPI_DOUBLE, i, 0, MPI_COMM_WORLD);
		}

		double S_n = compute_S(np, v);
		MPI_Reduce(&S_n, &S, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);

		double err = compute_error(S);
		printf("Error = %1.16f\n", err);

		free(v);

	}
	else {

		double *v_n;
		if (rank == P-1) {
			v_n = calloc(np + n%P, sizeof(double));
		}
		else {
			v_n = calloc(np, sizeof(double));
		}
		MPI_Recv(v_n, np, MPI_DOUBLE, 0, 0, MPI_COMM_WORLD, &status);

		double S_n = compute_S(np, v_n);

		free(v_n);

		MPI_Reduce(&S_n, &S, 1, MPI_DOUBLE, MPI_SUM, 0, MPI_COMM_WORLD);
	}
	
	double end = MPI_Wtime();
	
	if (rank == 0)
		printf("Elapsed time: %.16f seconds\n", end-start);
	
	
	MPI_Finalize();
	

	return 0;


}