void qr<T>::output(array_2d<T>& x) const { if(x.rows() != m || x.columns() != n) x.resize(idx(m, n)); lapack_interface<T>::call_lapack_geqrf(x, a); }
void write_array_2d(const array_2d <T, K>& a, std::ostream& s) { size_t arr = a.columns(); // number of arrays write_size(arr, s); size_t dim = a.rows(); // dimension of each array for (size_t n = 0, p = 0; n < arr; n++, p += dim) { write_size(dim, s); write(a[p], s, dim); } }
typename image<T, D>::create_new get_quadrange_sub_pix(const image<T, D>& a, const array_2d<double>& map_matrix, const size_array& dst_size) { IplImage* src = a.ipl(); IplImage* dst; if(dst_size[0] == 0 && dst_size[1] == 0) { dst = cvCreateImage(cvGetSize(src), image_details::ipl_depth<T>(), int(a.channels())); } else { dst = cvCreateImage(cvSize(dst_size[1], dst_size[0]), image_details::ipl_depth<T>(), int(a.channels())); } CHECK(map_matrix.rows() == 2, eshape); CHECK(map_matrix.columns() == 2, eshape); CvMat* cvmap_matrix = cvCreateMat(2, 3, image_details::cv_type<double>()); cvmSet(cvmap_matrix, 0, 0, map_matrix(0, 0)); cvmSet(cvmap_matrix, 0, 1, map_matrix(0, 1)); cvmSet(cvmap_matrix, 0, 2, map_matrix(0, 2)); cvmSet(cvmap_matrix, 1, 0, map_matrix(1, 0)); cvmSet(cvmap_matrix, 1, 1, map_matrix(1, 1)); cvmSet(cvmap_matrix, 1, 2, map_matrix(1, 2)); /*cvmap_matrix->data.db[0] = map_matrix(0, 0); cvmap_matrix->data.db[1] = map_matrix(0, 1); cvmap_matrix->data.db[2] = map_matrix(0, 2); cvmap_matrix->data.db[3] = map_matrix(1, 0); cvmap_matrix->data.db[4] = map_matrix(1, 1); cvmap_matrix->data.db[5] = map_matrix(1, 2);*/ cvGetQuadrangleSubPix(src, dst, cvmap_matrix); typename image<T, D>::create_new r(dst); cvReleaseMat(&cvmap_matrix); cvReleaseImage(&src); cvReleaseImage(&dst); return r; }
void kd_tree::build_tree(array_2d<double> &mm){ array_1d<double> i_min,i_max; int i; for(i=0;i<mm.get_cols();i++){ i_min.set(i,0.0); i_max.set(i,1.0); } build_tree(mm,i_min,i_max); }
void qr<T>::output(array_2d<T>& q, array_2d<T>& r) const { array<T> tau(min_nm); if(r.rows() != m || r.columns() != n) r.resize(idx(m, n)); lapack_interface<T>::call_lapack_geqrf(r, tau, a); //Now construct Q //Q should be a MxM matrix if(q.rows() != m || q.columns() != m) q.resize(idx(m, m)); if(n <= m) { //Q can hold the MxN values of R needed by lapack's xORGQR routines for(size_t i = 0; i < m; i++) for(size_t j = 0; j < n; j++) q[m*j + i] = r(i,j); lapack_interface<T>::call_lapack_orgqr(q, tau); } else { //create a new array and do a copy since //Q cannot hold the MxN values of R as needed by lapack's xORGQR routines array_2d<T> temp_q(r(all(), size_range(0, m - 1))); lapack_interface<T>::call_lapack_orgqr(temp_q, tau); //copy the Q values from temp for(size_t i = 0; i < m; i++) for(size_t j = 0; j < m; j++) q[m*j + i] = temp_q[m*j + i]; } // R is upper triangular for(size_t i = 0; i < m; i++) for(size_t j = 0; j < n; j++) if(i > j) r(i,j) = 0; }
void write(const array_2d <T>& a, std::ostream& s) { write(a[0], s, a.length()); }
void read(array_2d <T>& a, std::istream& s) { read(a[0], s, a.length()); }
lapack_from_std_out_and_unroll(ct* dst, ct* w, size_t rows, size_t cols) : dst(dst), w_ptr(w), a(rows, cols) { ptr = a.c_ptr(); }
void kd_tree::build_tree(array_2d<double> &mm, array_1d<double> &nmin, array_1d<double> &nmax){ if(nmin.get_dim()!=mm.get_cols()){ printf("WARNING nimin dim %d cols %d\n",nmin.get_dim(),mm.get_cols()); throw -1; } if(nmax.get_dim()!=mm.get_cols()){ printf("WARNING nmax dim %d cols %d\n",nmax.get_dim(),mm.get_cols()); throw -1; } search_time=0.0; search_ct=0; search_ct_solo=0; search_time_solo=0.0; data.reset(); tree.reset(); array_1d<int> inn,use_left,use_right; array_1d<double> tosort,sorted; int i,j,k,l,inp; tol=1.0e-7; diagnostic=1; tree.set_dim(mm.get_rows(),4); data.set_dim(mm.get_rows(),mm.get_cols()); use_left.set_name("kd_tree_constructor_use_left"); use_right.set_name("kd_tree_constructor_use_right"); tree.set_name("kd_tree_tree"); data.set_name("kd_tree_data"); //tree[i][0] will be the dimension being split //tree[i][1] will be left hand node (so, lt) //tree[i][2] will be right hand node (so, ge) //tree[i][3] will be parent mins.set_name("kd_tree_mins"); maxs.set_name("kd_tree_maxs"); for(i=0;i<data.get_cols();i++){ mins.set(i,nmin.get_data(i)); maxs.set(i,nmax.get_data(i)); } array_1d<double> vector; for(i=0;i<data.get_rows();i++){ data.set_row(i,(*mm(i))); } sorted.set_name("kd_tree_constructor_sorted"); tosort.set_name("kd_tree_constructor_tosort"); inn.set_name("kd_tree_constructor_inn"); /*sort the data points by their 0th dimension component*/ for(i=0;i<data.get_rows();i++){ tosort.set(i,data.get_data(i,0)); inn.set(i,i); } sort_and_check(tosort,sorted,inn); /*try to pick the median value as the first node in the tree (the masterparent)*/ inp=data.get_rows()/2; while(inp>0 && sorted.get_data(inp)-sorted.get_data(inp-1)<tol){ /*make sure that the division doesn't come in the middle of a bunch of identical points*/ inp--; } masterparent=inn.get_data(inp); /*assign the remaining points to either the left branch or the right branch of the masterparent*/ for(j=0;j<data.get_rows();j++){ if(masterparent!=j){ if(data.get_data(j,0)<sorted.get_data(inp)){ use_left.add(j); } else{ use_right.add(j); } } } /*organize all of the points on the left branch of the masterparent*/ if(use_left.get_dim()>0){ organize(use_left,0,masterparent,1,use_left.get_dim(),1); } else tree.set(masterparent,1,-1); /*organize all of the points on the right branch of the masterparent*/ if(use_right.get_dim()>0){ organize(use_right,0,masterparent,1,use_right.get_dim(),2); } else tree.set(masterparent,2,-1); tree.set(masterparent,3,-1);/*masterparent has no parent of its own*/ tree.set(masterparent,0,0);/*masterparent split on the 0th dimension*/ /*check to make sure everything has the dimensions that it should*/ if(mins.get_dim()!=maxs.get_dim() || mins.get_dim()!=data.get_cols() || tree.get_rows()!=data.get_rows()){ printf("WARNING tried to make tree but\n"); printf("nmax %d\n",maxs.get_dim()); printf("nmin %d\n",mins.get_dim()); printf("tree %d %d data %d %d\n",tree.get_rows(),tree.get_cols(), data.get_rows(),data.get_cols()); exit(1); } }
array_8d<double> Nevpt2_npdm::compute_EEEE_matrix(array_2d<double>& onepdm, array_4d<double>& twopdm, array_6d<double>& threepdm, array_8d<double>& fourpdm) { if( mpigetrank() == 0 ) { std::cout << "Building spatial <0|EEEE|0>\n"; int dim = threepdm.dim1(); assert( onepdm.dim1() == twopdm.dim1() ); array_8d<double> eeee_matrix(dim,dim,dim,dim,dim,dim,dim,dim); eeee_matrix.Clear(); // Output text file double factor = 1.0; char file[5000]; sprintf (file, "%s%s%d.%d%s", dmrginp.save_prefix().c_str(),"/EEEE_matrix.", 0, 0,".txt"); ofstream ofs(file); ofs << dim << endl; for(int i=0; i<dim; ++i) { for(int j=0; j<dim; ++j) { for(int k=0; k<dim; ++k) { int d_jk = ( j == k ); for(int l=0; l<dim; ++l) { for(int m=0; m<dim; ++m) { int d_lm = ( l == m ); int d_jm = ( j == m ); for(int n=0; n<dim; ++n) { for(int p=0; p<dim; ++p) { int d_np = ( n == p ); int d_lp = ( l == p ); int d_jp = ( j == p ); for(int q=0; q<dim; ++q) { double val = 0.0; // 1PDM terms val += d_jk * d_lm * d_np * onepdm(i,q); // 2PDM terms val += d_jk * d_lm * 2.0*twopdm(i,p,q,n); // Note factor of two difference between Block 2PDMs and other codes val += d_jk * d_np * 2.0*twopdm(i,m,q,l); val += d_jk * d_lp * 2.0*twopdm(i,m,n,q); val += d_jm * d_np * 2.0*twopdm(i,k,l,q); val += d_jm * d_lp * 2.0*twopdm(i,k,q,n); val += d_lm * d_np * 2.0*twopdm(i,k,q,j); val += d_lm * d_jp * 2.0*twopdm(i,k,n,q); // 3PDM terms val += d_jk * threepdm(i,m,p,q,n,l); val += d_jm * threepdm(i,k,p,q,l,n); val += d_lm * threepdm(i,k,p,q,n,j); val += d_np * threepdm(i,k,m,q,l,j); val += d_lp * threepdm(i,k,m,n,q,j); val += d_jp * threepdm(i,k,m,n,l,q); // 4PDM terms val += fourpdm(i,k,m,p,j,l,n,q); if ( abs(val) > 1e-14 ) { ofs << boost::format("%d %d %d %d %d %d %d %d %20.14e\n") % i % j % k % l % m % n % p % q % val; eeee_matrix(i,j,k,l,m,n,p,q) = val; } } } } } } } } } ofs.close(); // Save binary matrix sprintf (file, "%s%s%d.%d%s", dmrginp.save_prefix().c_str(),"/EEEE_matrix.", 0, 0,".bin"); std::ofstream ofs2(file, std::ios::binary); boost::archive::binary_oarchive save(ofs2); save << eeee_matrix; ofs2.close(); return eeee_matrix; } }