void linear::fill_lambda(){ #ifdef LOAD std::cout << " Reading labmda matrices" << std::endl; loadMarket(lambda_x, "lambda_x.mtx"); loadMarket(lambda_y, "lambda_y.mtx"); #else // div( vectorf, inter_scalarf ); std::cout << " Filling lambda matrices" << std::endl; std::vector<triplet> ax; // list of non-zeros coefficients std::vector<triplet> ay; // list of non-zeros coefficients int N=0; for(F_v_it fv=T.finite_vertices_begin(); fv!=T.finite_vertices_end(); fv++) { ++N; int vi=fv->idx.val(); typedef Vertex::vector_link vector_link; vector_link nabla=fv->nabla(); for( vector_link::iterator nn= nabla.begin(); nn!=nabla.end(); ++nn) { int vj=nn->first->idx.val(); Vector_2 nnabla=nn->second; ax.push_back( triplet(vi,vj, nnabla.x() )); ay.push_back( triplet(vi,vj, nnabla.y() )); } } lambda_x.resize(N,N); lambda_y.resize(N,N); lambda_x.setFromTriplets(ax.begin(), ax.end()); lambda_y.setFromTriplets(ay.begin(), ay.end()); #endif std::cout << " Filled lambda matrices" << std::endl; cout << "matrix size " << lambda_x.rows() << " x " << lambda_x.cols() << endl; return; }
void JGE::HoldKey(const JButton sym) { #if defined (WIN32) || defined (LINUX) if (JGE_BTN_FULLSCREEN == sym) JGEToggleFullscreen(); #endif if (!held(sym)) { keyBuffer.push(triplet(LOCAL_KEY_NONE, sym, false)); holds[sym] = REPEAT_DELAY; } else keyBuffer.push(triplet(LOCAL_KEY_NONE, sym, true)); }
void JGE::PressKey(const LocalKeySym sym) { const pair<keycodes_it, keycodes_it> rng = keyBinds.equal_range(sym); if (rng.first == rng.second) keyBuffer.push(triplet(sym, JGE_BTN_NONE, false)); else for (keycodes_it it = rng.first; it != rng.second; ++it) { #if defined (WIN32) || defined (LINUX) if (JGE_BTN_FULLSCREEN == it->second) JGEToggleFullscreen(); #endif keyBuffer.push(triplet(*it, held(it->second))); } }
/* go from triplets to rank array */ uint32_t *ranks(triplet *T, size_t sz, size_t *retsz, bool *unique) { /* remember old positions */ for (size_t i = 0; i < sz; i++) { T[i].label = i; } vprint("T", T, sz); lsd_sort(T, sz); vprint("Tsort", T, sz); uint32_t *ranks = new uint32_t[sz + 2]; *retsz = sz; uint32_t cur_rank = 0; triplet prev = triplet(999999, 999999, 999999); *unique = true; for (size_t i = 0; i < sz; i++) { if (prev != T[i]) { cur_rank += 1; prev = T[i]; } else { *unique = false; } ranks[T[i].label] = cur_rank; } return ranks; }
void JGE::PressKey(const JButton sym) { #if defined (WIN32) || defined (LINUX) if (sym == JGE_BTN_FULLSCREEN) JGEToggleFullscreen(); #endif keyBuffer.push(triplet(LOCAL_KEY_NONE, sym, held(sym))); }
// first sort, then fix a num and search in 2sum set<vector<int> > find_triplets(vector<int> arr) { sort(arr.begin(), arr.end()); set<vector<int> > triplets; vector<int> triplet(3); int n = arr.size(); for (int i = 0;i < n; i++) { int j = i + 1; int k = n - 1; while (j < k) { int sum_two = arr[i] + arr[j]; if (sum_two + arr[k] < 0) { j++; } else if (sum_two + arr[k] > 0) { k--; } else { triplet[0] = arr[i]; triplet[1] = arr[j]; triplet[2] = arr[k]; triplets.insert(triplet); j++; k--; } } } return triplets; }
SparseMatrix neighbors_distances_matrix(RandomAccessIterator begin, RandomAccessIterator end, const Neighbors& neighbors, DistanceCallback callback, ScalarType& average_distance) { const IndexType k = neighbors[0].size(); const IndexType n = neighbors.size(); if ((end-begin)!=n) throw std::runtime_error("Wrong size"); SparseTriplets sparse_triplets; sparse_triplets.reserve(k*n); average_distance = 0; ScalarType current_distance; for (IndexType i = 0; i < n; ++i) { const LocalNeighbors& current_neighbors = neighbors[i]; for (IndexType j = 0; j < k; ++j) { current_distance = callback.distance(begin[i], begin[current_neighbors[j]]); average_distance += current_distance; SparseTriplet triplet(i, current_neighbors[j], current_distance); sparse_triplets.push_back(triplet); } } average_distance /= (k*n); return sparse_matrix_from_triplets(sparse_triplets, n, n); }
vector<vector<int> > threeSum(vector<int> &num) { int n = num.size(); vector<vector<int>> result; vector<int> triplet(3, 0); int sum; int i, l, r; sort(num.begin(), num.end()); for (i = 0; i < n; i++) { if (i > 0 && num[i] == num[i-1]) continue; l = i+1; r = n-1; while (l < r) { sum = num[i] + num[l] + num[r]; if (sum == 0) { triplet[0] = num[i]; triplet[1] = num[l]; triplet[2] = num[r]; result.push_back(triplet); do { l++; } while (l < r && num[l] == num[l-1]); do { r--; } while (l < r && num[r] == num[r+1]); } else if (sum < 0) { l++; } else { r--; } } } return result; }
vector<vector<int>> threeSum(vector<int>& nums) { vector<vector<int>> res; vector<int> triplet(3,0); sort(nums.begin(), nums.end()); for(int i = 0;i < nums.size();++i){ int target = -nums[i]; int front = i + 1; int back = nums.size() - 1; while(front < back){ int sum = nums[front] + nums[back]; //use if else not 3 if statement because they are parallel; if(sum < target) ++front; else if(sum > target) --back; else{ triplet[0] = nums[i]; triplet[1] = nums[front]; triplet[2] = nums[back]; res.push_back(triplet); //only need to note the duplicate when the sum is 0; //front--> with <--back is the right motion; while(front < back && nums[front] == triplet[1] ) ++front; while(front < back && nums[back] == triplet[2]) --back; } } while(i + 1 < nums.size() && nums[i + 1] == nums[i])//use while not if! ++i; } return res; }
vector<vector<int> > threeSum(vector<int> &num) { // Start typing your C/C++ solution below // DO NOT write int main() function sort(num.begin(), num.end()); vector<vector<int> > triplets; vector<int> triplet(3); int n = num.size(); for (int i = 0; i < n - 2; i++) { if (i > 0 && num[i] == num[i-1]) { continue; } int twoSum = -num[i]; int j = i + 1; int k = n - 1; while (j < k) { int jksum = num[j] + num[k]; if (jksum < twoSum) { do { j++; } while(num[j] == num[j-1] && j < k); } else if (jksum > twoSum) { do { k--; } while (num[k] == num[k+1] && j < k); } else { triplet[0] = num[i]; triplet[1] = num[j]; triplet[2] = num[k]; triplets.push_back(triplet); do { j++; } while(num[j] == num[j-1] && j < k); do { k--; } while (num[k] == num[k+1] && j < k); } } } return triplets; }
void JGE::HoldKey_NoRepeat(const JButton sym) { #if defined (WIN32) || defined (LINUX) if (JGE_BTN_FULLSCREEN == sym) JGEToggleFullscreen(); #endif keyBuffer.push(triplet(LOCAL_KEY_NONE, sym, true)); if (!held(sym)) holds[sym] = std::numeric_limits<float>::quiet_NaN(); }
void JGE::HoldKey_NoRepeat(const LocalKeySym sym) { const pair<keycodes_it, keycodes_it> rng = keyBinds.equal_range(sym); if (rng.first == rng.second) keyBuffer.push(triplet(sym, JGE_BTN_NONE, false)); else for (keycodes_it it = rng.first; it != rng.second; ++it) { #if defined (WIN32) || defined (LINUX) if (JGE_BTN_FULLSCREEN == it->second) { JGEToggleFullscreen(); return; } #endif keyBuffer.push(triplet(*it, true)); if (!held(it->second)) holds[it->second] = std::numeric_limits<float>::quiet_NaN(); } }
vector<vector<int> > threeSum(vector<int> &num) { vector<vector<int> > res; std::sort(num.begin(), num.end()); for (int i = 0; i < num.size(); i++) { int target = -num[i]; int front = i + 1; int back = num.size() - 1; if(target < 0) { break; } while (front < back) { int sum = num[front] + num[back]; // Finding answer which start from number num[i] if (sum < target) front++; else if (sum > target) back--; else { vector<int> triplet(3, 0); triplet[0] = num[i]; triplet[1] = num[front]; triplet[2] = num[back]; res.push_back(triplet); // Processing duplicates of Number 2 // Rolling the front pointer to the next different number forwards while (front < back && num[front] == triplet[1]) front++; // Processing duplicates of Number 3 // Rolling the back pointer to the next different number backwards while (front < back && num[back] == triplet[2]) back--; } } // Processing duplicates of Number 1 while (i + 1 < num.size() && num[i + 1] == num[i]) i++; } return res; }
vector<vector<int> > threeSum(vector<int> &num) { // Start typing your C/C++ solution below // DO NOT write int main() function /*vector<vector <int> > v; int s=0; sort(num.begin(),num.end()); int i,j, n=num.size(); for(i=0;i<n;i++) { int first = i+1; int last = n-1; while(first < last) { int y = (-num[i]) - num[first]; if(num[last] > y) last--; else if(num[last] < y) first++; else { printf("%d %d %d\n",num[i],num[first],num[last]); v[s].push_back(num[i]); v[s].push_back(num[first]); v[s++].push_back(num[last]); first++; last--; } } } return v;*/ sort(num.begin(), num.end()); vector<vector<int> > triplets; vector<int> triplet(3); int n = num.size(); for (int i = 0;i < n; i++) { int j = i + 1; int k = n - 1; while (j < k) { int sum_two = num[i] + num[j]; if (sum_two + num[k] < 0) { j++; } else if (sum_two + num[k] > 0) { k--; } else { triplet[0] = num[i]; triplet[1] = num[j]; triplet[2] = num[k]; triplets.push_back(triplet); j++; k--; } } } }
void MatrixEigenSparse<T>::addMatrix ( int* rows, int nrows, int* cols, int ncols, value_type* data ) { for( int i=0; i < nrows; ++i ) for( int j=0; j < ncols; ++j ) { M_tripletList.push_back(triplet(rows[i], cols[j], data[i*ncols+j]) ); } }
SparseMatrixNeighborsPair angles_matrix_and_neighbors(const Neighbors& neighbors, const DenseMatrix& data) { const IndexType k = neighbors[0].size(); const IndexType n_vectors = data.cols(); SparseTriplets sparse_triplets; sparse_triplets.reserve(k * n_vectors); /* I tried to find better naming, but... */ Neighbors most_collinear_neighbors_of_neighbors; most_collinear_neighbors_of_neighbors.reserve(n_vectors); for (IndexType i = 0; i < n_vectors; ++i) { const LocalNeighbors& current_neighbors = neighbors[i]; LocalNeighbors most_collinear_current_neighbors; most_collinear_current_neighbors.reserve(k); for (IndexType j = 0; j < k; ++j) { const LocalNeighbors& neighbors_of_neighbor = neighbors[current_neighbors[j]]; /* The closer the cos value to -1.0 - the closer the angle to 180.0 */ ScalarType min_cos_value = 1.0, current_cos_value; /* This value will be updated during the seach for most collinear neighbor */ most_collinear_current_neighbors.push_back(0); for (IndexType l = 0; l < k; ++l) { DenseVector neighbor_to_point = data.col(i) - data.col(current_neighbors[j]); DenseVector neighbor_to_its_neighbor = data.col(neighbors_of_neighbor[l]) - data.col(current_neighbors[j]); current_cos_value = neighbor_to_point.dot(neighbor_to_its_neighbor) / (neighbor_to_point.norm() * neighbor_to_its_neighbor.norm()); if (current_cos_value < min_cos_value) { most_collinear_current_neighbors[j] = neighbors_of_neighbor[l]; min_cos_value = current_cos_value; } } SparseTriplet triplet(i, most_collinear_current_neighbors[j], min_cos_value); sparse_triplets.push_back(triplet); } most_collinear_neighbors_of_neighbors.push_back(most_collinear_current_neighbors); } return SparseMatrixNeighborsPair (sparse_matrix_from_triplets(sparse_triplets, n_vectors, n_vectors), most_collinear_neighbors_of_neighbors); }
void JGE::Update(float dt) { for (map<JButton, float>::iterator it = holds.begin(); it != holds.end(); ++it) { if (it->second < 0) { keyBuffer.push(triplet(LOCAL_KEY_NONE, it->first, true)); it->second = REPEAT_PERIOD; } it->second -= dt; } if (mApp != NULL) mApp->Update(); oldHolds = holds; }
vector<vector<int> > threeSum(vector<int> &num) { // Start typing your C/C++ solution below // DO NOT write int main() function int size = num.size(); vector<vector<int>> ret; if( size < 3 ) return ret; sort( num.begin(), num.end() ); vector<int> triplet(3, 0); for( int i = 0; i < size; i++){ int j = i +1, k = size -1; // Avoid duplication if( i > 0 && num[i] == num[i-1] ) continue; while( j < k ){ if( num[j] + num[k] + num[i] > 0 ){ k--; } else if( num[j] + num[k] + num[i] < 0 ){ j++; } else{ triplet[0] = num[i]; triplet[1] = num[j]; triplet[2] = num[k]; ret.push_back( triplet ); do{ j++; }while( num[j]==num[j-1] && j < k); do{ k--; }while( num[k] == num[k+1] && k > j ); } } } return ret; }
CImage *CImageLABtoXYZ(CImage *cimg) { CImage *ncimg=NULL; int p,n,i; ncimg = CreateCImage(cimg->C[0]->ncols,cimg->C[0]->nrows); n = ncimg->C[0]->ncols*ncimg->C[0]->nrows; for (p=0; p < n; p++){ i = triplet(cimg->C[0]->val[p],cimg->C[1]->val[p],cimg->C[2]->val[p]); i = LAB2XYZ(i); ncimg->C[0]->val[p]=t0(i); ncimg->C[1]->val[p]=t1(i); ncimg->C[2]->val[p]=t2(i); } return(ncimg); }
vector<vector<int> > threeSum(vector<int> arr) { // Start typing your C/C++ solution below // DO NOT write int main() function sort(arr.begin(), arr.end()); vector <vector<int> > triplets; vector<int> triplet(3); int n = (int)arr.size(); for (int i = 0; i < n; i++) { int j = i + 1; int k = n - 1; while (j < k) { int sum_two = arr[i] + arr[j]; if (sum_two + arr[k] < 0) { j++; } else if (sum_two + arr[k] > 0) { k--; } else { triplet[0] = arr[i]; triplet[1] = arr[j]; triplet[2] = arr[k]; triplets.push_back(triplet); while( arr[j+1] == arr[j] && j+1 < k) j++; j++; while(arr[k-1] == arr[k] && j < k-1) k--; k--; } } while (i+1 < n && arr[i+1] == arr[i]) i++; } return triplets; }
vector<vector<int> > threeSum(vector<int> &num) { // Start typing your C/C++ solution below // DO NOT write int main() function sort(num.begin(), num.end()); set<vector<int> > triplets; vector<vector<int> > out; vector<int> triplet(3); int n = num.size(); for (int i = 0; i < n - 2; i++) { int twoSum = -num[i]; int j = i + 1; int k = n - 1; while (j < k) { int jksum = num[j] + num[k]; if (jksum < twoSum) { j++; } else if (jksum > twoSum) { k--; } else { triplet[0] = num[i]; triplet[1] = num[j]; triplet[2] = num[k]; triplets.insert(triplet); //not constant time, bad j++; k--; } } } out.assign(triplets.begin(), triplets.end()); return out; }
vector<vector<int> > threeSum(vector<int> &num) { // Start typing your C/C++ solution below // DO NOT write int main() function sort(num.begin(), num.end()); vector<vector<int> > triplets; vector<int> triplet(3); int n = num.size(); for (int i = 0; i < n - 2; i++) { int twoSum = -num[i]; int j = i + 1; int k = n - 1; while (j < k) { int jksum = num[j] + num[k]; if (jksum < twoSum) { j++; } else if (jksum > twoSum) { k--; } else { triplet[0] = num[i]; triplet[1] = num[j]; triplet[2] = num[k]; triplets.push_back(triplet); j++; k--; } } } triplets.erase(unique(triplets.begin(), triplets.end()), triplets.end()); // it's ok it's linear time return triplets; }
vector<vector<int> > threeSum(vector<int> &num) { vector<vector<int> > rtn; if (num.size()<3) return rtn; vector<int> triplet(3,0); // first sort input vector into ascending order sort(num.begin(), num.end()); int start, mid, end, tmpsum; for (start = 0; start<=num.size()-3; start++) { // note uniqueness if (start > 0 && num[start] == num[start - 1]) continue; end = num.size()-1; mid = start + 1; while( mid < end) { tmpsum = num[start] + num[mid]; if (tmpsum + num[end]>0) {end--;} else if (tmpsum + num[end]<0) {mid++;} else { triplet[0] = num[start]; triplet[1] = num[mid]; triplet[2] = num[end]; rtn.push_back(triplet); mid++; end--; // note uniqueness while(num[mid-1]==num[mid] && mid < end) {mid++;} while(num[end+1]==num[end] && mid < end) {end--;} } } } return rtn; }
int main() { // check that it'll find nodes exactly MAX away { tree_type exact_dist(std::ptr_fun(tac)); triplet c0(5, 4, 0); exact_dist.insert(c0); triplet target(7,4,0); std::pair<tree_type::const_iterator,double> found = exact_dist.find_nearest(target,2); assert(found.first != exact_dist.end()); assert(found.second == 2); std::cout << "Test find_nearest(), found at exact distance away from " << target << ", found " << *found.first << std::endl; } // do the same test, except use alternate_triplet as the search key { // NOTE: stores triplet, but we search with alternate_triplet typedef KDTree::KDTree<3, triplet, alternate_tac> alt_tree; triplet actual_target(7,0,0); alt_tree tree; tree.insert( triplet(0, 0, 7) ); tree.insert( triplet(0, 0, 7) ); tree.insert( triplet(0, 0, 7) ); tree.insert( triplet(3, 0, 0) ); tree.insert( actual_target ); tree.optimise(); alternate_triplet target( actual_target ); std::pair<alt_tree::const_iterator,double> found = tree.find_nearest(target); assert(found.first != tree.end()); std::cout << "Test with alternate search type, found: " << *found.first << ", wanted " << actual_target << std::endl; assert(found.second == 0); assert(*found.first == actual_target); } { tree_type exact_dist(std::ptr_fun(tac)); triplet c0(5, 2, 0); exact_dist.insert(c0); triplet target(7,4,0); // call find_nearest without a range value - it found a compile error earlier. std::pair<tree_type::const_iterator,double> found = exact_dist.find_nearest(target); assert(found.first != exact_dist.end()); std::cout << "Test find_nearest(), found at exact distance away from " << target << ", found " << *found.first << " @ " << found.second << " should be " << std::sqrt(8) << std::endl; assert(found.second == std::sqrt(8)); } { tree_type exact_dist(std::ptr_fun(tac)); triplet c0(5, 2, 0); exact_dist.insert(c0); triplet target(7,4,0); std::pair<tree_type::const_iterator,double> found = exact_dist.find_nearest(target,std::sqrt(8)); assert(found.first != exact_dist.end()); std::cout << "Test find_nearest(), found at exact distance away from " << target << ", found " << *found.first << " @ " << found.second << " should be " << std::sqrt(8) << std::endl; assert(found.second == std::sqrt(8)); } tree_type src(std::ptr_fun(tac)); triplet c0(5, 4, 0); src.insert(c0); triplet c1(4, 2, 1); src.insert(c1); triplet c2(7, 6, 9); src.insert(c2); triplet c3(2, 2, 1); src.insert(c3); triplet c4(8, 0, 5); src.insert(c4); triplet c5(5, 7, 0); src.insert(c5); triplet c6(3, 3, 8); src.insert(c6); triplet c7(9, 7, 3); src.insert(c7); triplet c8(2, 2, 6); src.insert(c8); triplet c9(2, 0, 6); src.insert(c9); std::cout << src << std::endl; src.erase(c0); src.erase(c1); src.erase(c3); src.erase(c5); src.optimise(); // test the efficient_replace_and_optimise() tree_type eff_repl = src; { std::vector<triplet> vec; // erased above as part of test vec.push_back(triplet(5, 4, 0)); // erased above as part of test vec.push_back(triplet(4, 2, 1)); vec.push_back(triplet(7, 6, 9)); // erased above as part of test vec.push_back(triplet(2, 2, 1)); vec.push_back(triplet(8, 0, 5)); // erased above as part of test vec.push_back(triplet(5, 7, 0)); vec.push_back(triplet(3, 3, 8)); vec.push_back(triplet(9, 7, 3)); vec.push_back(triplet(2, 2, 6)); vec.push_back(triplet(2, 0, 6)); eff_repl.clear(); eff_repl.efficient_replace_and_optimise(vec); } std::cout << std::endl << src << std::endl; tree_type copied(src); std::cout << copied << std::endl; tree_type assigned; assigned = src; std::cout << assigned << std::endl; for (int loop = 0; loop != 4; ++loop) { tree_type * target; switch (loop) { case 0: std::cout << "Testing plain construction" << std::endl; target = &src; break; case 1: std::cout << "Testing copy-construction" << std::endl; target = &copied; break; case 2: std::cout << "Testing assign-construction" << std::endl; target = &assigned; break; default: case 4: std::cout << "Testing efficient-replace-and-optimise" << std::endl; target = &eff_repl; break; } tree_type & t = *target; int i=0; for (tree_type::const_iterator iter=t.begin(); iter!=t.end(); ++iter, ++i); std::cout << "iterator walked through " << i << " nodes in total" << std::endl; if (i!=6) { std::cerr << "Error: does not tally with the expected number of nodes (6)" << std::endl; return 1; } i=0; for (tree_type::const_reverse_iterator iter=t.rbegin(); iter!=t.rend(); ++iter, ++i); std::cout << "reverse_iterator walked through " << i << " nodes in total" << std::endl; if (i!=6) { std::cerr << "Error: does not tally with the expected number of nodes (6)" << std::endl; return 1; } triplet s(5, 4, 3); std::vector<triplet> v; unsigned int const RANGE = 3; size_t count = t.count_within_range(s, RANGE); std::cout << "counted " << count << " nodes within range " << RANGE << " of " << s << ".\n"; t.find_within_range(s, RANGE, std::back_inserter(v)); std::cout << "found " << v.size() << " nodes within range " << RANGE << " of " << s << ":\n"; std::vector<triplet>::const_iterator ci = v.begin(); for (; ci != v.end(); ++ci) std::cout << *ci << " "; std::cout << "\n" << std::endl; std::cout << std::endl << t << std::endl; // search for all the nodes at exactly 0 dist away for (tree_type::const_iterator target = t.begin(); target != t.end(); ++target) { std::pair<tree_type::const_iterator,double> found = t.find_nearest(*target,0); assert(found.first != t.end()); assert(*found.first == *target); std::cout << "Test find_nearest(), found at exact distance away from " << *target << ", found " << *found.first << std::endl; } { const double small_dist = 0.0001; std::pair<tree_type::const_iterator,double> notfound = t.find_nearest(s,small_dist); std::cout << "Test find_nearest(), nearest to " << s << " within " << small_dist << " should not be found" << std::endl; if (notfound.first != t.end()) { std::cout << "ERROR found a node at dist " << notfound.second << " : " << *notfound.first << std::endl; std::cout << "Actual distance = " << s.distance_to(*notfound.first) << std::endl; } assert(notfound.first == t.end()); } { std::pair<tree_type::const_iterator,double> nif = t.find_nearest_if(s,std::numeric_limits<double>::max(),Predicate()); std::cout << "Test find_nearest_if(), nearest to " << s << " @ " << nif.second << ": " << *nif.first << std::endl; std::pair<tree_type::const_iterator,double> cantfind = t.find_nearest_if(s,std::numeric_limits<double>::max(),FalsePredicate()); std::cout << "Test find_nearest_if(), nearest to " << s << " should never be found (predicate too strong)" << std::endl; assert(cantfind.first == t.end()); } { std::pair<tree_type::const_iterator,double> found = t.find_nearest(s,std::numeric_limits<double>::max()); std::cout << "Nearest to " << s << " @ " << found.second << " " << *found.first << std::endl; std::cout << "Should be " << found.first->distance_to(s) << std::endl; // NOTE: the assert does not check for an exact match, as it is not exact when -O2 or -O3 is // switched on. Some sort of optimisation makes the math inexact. assert( fabs(found.second - found.first->distance_to(s)) < std::numeric_limits<double>::epsilon() ); } { triplet s2(10, 10, 2); std::pair<tree_type::const_iterator,double> found = t.find_nearest(s2,std::numeric_limits<double>::max()); std::cout << "Nearest to " << s2 << " @ " << found.second << " " << *found.first << std::endl; std::cout << "Should be " << found.first->distance_to(s2) << std::endl; // NOTE: the assert does not check for an exact match, as it is not exact when -O2 or -O3 is // switched on. Some sort of optimisation makes the math inexact. assert( fabs(found.second - found.first->distance_to(s2)) < std::numeric_limits<double>::epsilon() ); } std::cout << std::endl; std::cout << t << std::endl; // Testing iterators { std::cout << "Testing iterators" << std::endl; t.erase(c2); t.erase(c4); t.erase(c6); t.erase(c7); t.erase(c8); // t.erase(c9); std::cout << std::endl << t << std::endl; std::cout << "Forward iterator test..." << std::endl; std::vector<triplet> forwards; for (tree_type::iterator i = t.begin(); i != t.end(); ++i) { std::cout << *i << " " << std::flush; forwards.push_back(*i); } std::cout << std::endl; std::cout << "Reverse iterator test..." << std::endl; std::vector<triplet> backwards; for (tree_type::reverse_iterator i = t.rbegin(); i != t.rend(); ++i) { std::cout << *i << " " << std::flush; backwards.push_back(*i); } std::cout << std::endl; std::reverse(backwards.begin(),backwards.end()); assert(backwards == forwards); } } // Walter reported that the find_within_range() wasn't giving results that were within // the specified range... this is the test. { tree_type tree(std::ptr_fun(tac)); tree.insert( triplet(28.771200,16.921600,-2.665970) ); tree.insert( triplet(28.553101,18.649700,-2.155560) ); tree.insert( triplet(28.107500,20.341400,-1.188940) ); tree.optimise(); std::deque< triplet > vectors; triplet sv(18.892500,20.341400,-1.188940); tree.find_within_range(sv, 10.0f, std::back_inserter(vectors)); std::cout << std::endl << "Test find_with_range( " << sv << ", 10.0f) found " << vectors.size() << " candidates." << std::endl; // double-check the ranges for (std::deque<triplet>::iterator v = vectors.begin(); v != vectors.end(); ++v) { double dist = sv.distance_to(*v); std::cout << " " << *v << " dist=" << dist << std::endl; if (dist > 10.0f) std::cout << " This point is too far! But that is by design, its within a 'box' with a 'radius' of 10, not a sphere with a radius of 10" << std::endl; // Not a valid test, it can be greater than 10 if the point is in the corners of the box. // assert(dist <= 10.0f); } } return 0; }
uint32_t *idc3(uint32_t *T, size_t n, size_t *retsz) { vprint("args", T, n); T[n++] = 0; // step 0: construct a sample size_t B0len = (n+1)/3; #define toC(i) ((i < B0len) ? (1 + 3*i) : (2 + 3*(i-B0len))) // step 1: sort sample suffixes triplet *R = new triplet[n * 3 / 2 + 3]; triplet *Rptr = R; for (int j = 1; j <= 2; j++) { size_t i = j; for (; i < n - 2; i += 3) { *Rptr++ = triplet(T[i], T[i+1], T[i+2]); } for (; i < n - 1; i += 3) { *Rptr++ = triplet(T[i], T[i+1], 0); } for (; i < n; i += 3) { *Rptr++ = triplet(T[i], 0, 0); } } bool unique = false; size_t Rsz = Rptr - R; size_t Rrsz, SARsz; uint32_t *Rr = ranks(R, Rsz, &Rrsz, &unique); vprint("Rr", Rr, Rrsz) delete[] R; uint32_t *SAR = unique ? toSA(Rr, Rrsz, &SARsz) : idc3(Rr, Rrsz, &SARsz); vprint("SAR", SAR, SARsz) delete[] Rr; uint32_t *rank = new uint32_t[n+2]; for (size_t i = 1; i < SARsz; i++) { rank[toC(SAR[i])] = i; } // step 2: sort nonsample suffixes triplet *SB0 = new triplet[n/3 + 3]; triplet *SB0ptr = SB0; for (size_t i = 0; i < n; i += 3) { *SB0ptr++ = triplet(T[i], rank[i+1], i); } size_t SB0sz = SB0ptr - SB0; lsd_sort(SB0, SB0sz); // step 3: merge uint32_t *Sc = new uint32_t[SARsz - 1]; size_t Scsz = SARsz - 1; uint32_t *buf = new uint32_t[n + 1]; uint32_t *buf_ptr = buf; for (size_t i = 1; i < SARsz; i++) { Sc[i-1] = toC(SAR[i]); } delete[] SAR; size_t sbi = 0; size_t sci = 0; while (sbi < SB0sz && sci < Scsz) { uint32_t i = Sc[sci]; uint32_t j = SB0[sbi].arr[2]; if (i % 3 == 1) { if (T[i] < T[j] || (T[i] == T[j] && rank[i+1] <= rank[j+1])) { *buf_ptr++ = i; sci++; } else { *buf_ptr++ = j; sbi++; } } else if (i % 3 == 2) { if (LE(T[i], T[i+1], rank[i+2], T[j], T[j+1], rank[j+2])) { *buf_ptr++ = i; sci++; } else { *buf_ptr++ = j; sbi++; } } else { assert(false); } } while (sci < Scsz) { uint32_t i = Sc[sci++]; *buf_ptr++ = i; } while (sbi < SB0sz) { uint32_t j = SB0[sbi++].arr[2]; *buf_ptr++ = j; } delete[] Sc; delete[] SB0; delete[] rank; *retsz = buf_ptr - buf; return buf; }
int main() { // check that it'll find nodes exactly MAX away { tree_type exact_dist(std::ptr_fun(tac)); triplet c0(5, 4, 0); exact_dist.insert(c0); triplet target(7,4,0); std::pair<tree_type::const_iterator,double> found = exact_dist.find_nearest(target,2); assert(found.first != exact_dist.end()); assert(found.second == 2); std::cout << "Test find_nearest(), found at exact distance away from " << target << ", found " << *found.first << std::endl; } { tree_type exact_dist(std::ptr_fun(tac)); triplet c0(5, 2, 0); exact_dist.insert(c0); triplet target(7,4,0); // call find_nearest without a range value - it found a compile error earlier. std::pair<tree_type::const_iterator,double> found = exact_dist.find_nearest(target); assert(found.first != exact_dist.end()); std::cout << "Test find_nearest(), found at exact distance away from " << target << ", found " << *found.first << " @ " << found.second << " should be " << sqrt(8) << std::endl; assert(found.second == sqrt(8)); } { tree_type exact_dist(std::ptr_fun(tac)); triplet c0(5, 2, 0); exact_dist.insert(c0); triplet target(7,4,0); std::pair<tree_type::const_iterator,double> found = exact_dist.find_nearest(target,sqrt(8)); assert(found.first != exact_dist.end()); std::cout << "Test find_nearest(), found at exact distance away from " << target << ", found " << *found.first << " @ " << found.second << " should be " << sqrt(8) << std::endl; assert(found.second == sqrt(8)); } tree_type src(std::ptr_fun(tac)); triplet c0(5, 4, 0); src.insert(c0); triplet c1(4, 2, 1); src.insert(c1); triplet c2(7, 6, 9); src.insert(c2); triplet c3(2, 2, 1); src.insert(c3); triplet c4(8, 0, 5); src.insert(c4); triplet c5(5, 7, 0); src.insert(c5); triplet c6(3, 3, 8); src.insert(c6); triplet c7(9, 7, 3); src.insert(c7); triplet c8(2, 2, 6); src.insert(c8); triplet c9(2, 0, 6); src.insert(c9); std::cout << src << std::endl; src.erase(c0); src.erase(c1); src.erase(c3); src.erase(c5); src.optimise(); // test the efficient_replace_and_optimise() tree_type eff_repl = src; { std::vector<triplet> vec; // erased above as part of test vec.push_back(triplet(5, 4, 0)); // erased above as part of test vec.push_back(triplet(4, 2, 1)); vec.push_back(triplet(7, 6, 9)); // erased above as part of test vec.push_back(triplet(2, 2, 1)); vec.push_back(triplet(8, 0, 5)); // erased above as part of test vec.push_back(triplet(5, 7, 0)); vec.push_back(triplet(3, 3, 8)); vec.push_back(triplet(9, 7, 3)); vec.push_back(triplet(2, 2, 6)); vec.push_back(triplet(2, 0, 6)); eff_repl.clear(); eff_repl.efficient_replace_and_optimise(vec); } std::cout << std::endl << src << std::endl; tree_type copied(src); std::cout << copied << std::endl; tree_type assigned; assigned = src; std::cout << assigned << std::endl; for (int loop = 0; loop != 4; ++loop) { tree_type * target; switch (loop) { case 0: std::cout << "Testing plain construction" << std::endl; target = &src; break; case 1: std::cout << "Testing copy-construction" << std::endl; target = &copied; break; case 2: std::cout << "Testing assign-construction" << std::endl; target = &assigned; break; default: case 4: std::cout << "Testing efficient-replace-and-optimise" << std::endl; target = &eff_repl; break; } tree_type & t = *target; int i=0; for (tree_type::const_iterator iter=t.begin(); iter!=t.end(); ++iter, ++i); std::cout << "iterator walked through " << i << " nodes in total" << std::endl; if (i!=6) { std::cerr << "Error: does not tally with the expected number of nodes (6)" << std::endl; return 1; } i=0; for (tree_type::const_reverse_iterator iter=t.rbegin(); iter!=t.rend(); ++iter, ++i); std::cout << "reverse_iterator walked through " << i << " nodes in total" << std::endl; if (i!=6) { std::cerr << "Error: does not tally with the expected number of nodes (6)" << std::endl; return 1; } triplet s(5, 4, 3); std::vector<triplet> v; unsigned int const RANGE = 3; size_t count = t.count_within_range(s, RANGE); std::cout << "counted " << count << " nodes within range " << RANGE << " of " << s << ".\n"; t.find_within_range(s, RANGE, std::back_inserter(v)); std::cout << "found " << v.size() << " nodes within range " << RANGE << " of " << s << ":\n"; std::vector<triplet>::const_iterator ci = v.begin(); for (; ci != v.end(); ++ci) std::cout << *ci << " "; std::cout << "\n" << std::endl; std::cout << std::endl << t << std::endl; // search for all the nodes at exactly 0 dist away for (tree_type::const_iterator target = t.begin(); target != t.end(); ++target) { std::pair<tree_type::const_iterator,double> found = t.find_nearest(*target,0); assert(found.first != t.end()); assert(*found.first == *target); std::cout << "Test find_nearest(), found at exact distance away from " << *target << ", found " << *found.first << std::endl; } { const double small_dist = 0.0001; std::pair<tree_type::const_iterator,double> notfound = t.find_nearest(s,small_dist); std::cout << "Test find_nearest(), nearest to " << s << " within " << small_dist << " should not be found" << std::endl; if (notfound.first != t.end()) { std::cout << "ERROR found a node at dist " << notfound.second << " : " << *notfound.first << std::endl; std::cout << "Actual distance = " << s.distance_to(*notfound.first) << std::endl; } assert(notfound.first == t.end()); } { std::pair<tree_type::const_iterator,double> nif = t.find_nearest_if(s,std::numeric_limits<double>::max(),Predicate()); std::cout << "Test find_nearest_if(), nearest to " << s << " @ " << nif.second << ": " << *nif.first << std::endl; std::pair<tree_type::const_iterator,double> cantfind = t.find_nearest_if(s,std::numeric_limits<double>::max(),FalsePredicate()); std::cout << "Test find_nearest_if(), nearest to " << s << " should never be found (predicate too strong)" << std::endl; assert(cantfind.first == t.end()); } { std::pair<tree_type::const_iterator,double> found = t.find_nearest(s,std::numeric_limits<double>::max()); std::cout << "Nearest to " << s << " @ " << found.second << " " << *found.first << std::endl; std::cout << "Should be " << found.first->distance_to(s) << std::endl; // NOTE: the assert does not check for an exact match, as it is not exact when -O2 or -O3 is // switched on. Some sort of optimisation makes the math inexact. assert( fabs(found.second - found.first->distance_to(s)) < std::numeric_limits<double>::epsilon() ); } { triplet s2(10, 10, 2); std::pair<tree_type::const_iterator,double> found = t.find_nearest(s2,std::numeric_limits<double>::max()); std::cout << "Nearest to " << s2 << " @ " << found.second << " " << *found.first << std::endl; std::cout << "Should be " << found.first->distance_to(s2) << std::endl; // NOTE: the assert does not check for an exact match, as it is not exact when -O2 or -O3 is // switched on. Some sort of optimisation makes the math inexact. assert( fabs(found.second - found.first->distance_to(s2)) < std::numeric_limits<double>::epsilon() ); } std::cout << std::endl; std::cout << t << std::endl; // Testing iterators { std::cout << "Testing iterators" << std::endl; t.erase(c2); t.erase(c4); t.erase(c6); t.erase(c7); t.erase(c8); // t.erase(c9); std::cout << std::endl << t << std::endl; std::cout << "Forward iterator test..." << std::endl; std::vector<triplet> forwards; for (tree_type::iterator i = t.begin(); i != t.end(); ++i) { std::cout << *i << " " << std::flush; forwards.push_back(*i); } std::cout << std::endl; std::cout << "Reverse iterator test..." << std::endl; std::vector<triplet> backwards; for (tree_type::reverse_iterator i = t.rbegin(); i != t.rend(); ++i) { std::cout << *i << " " << std::flush; backwards.push_back(*i); } std::cout << std::endl; std::reverse(backwards.begin(),backwards.end()); assert(backwards == forwards); } } return 0; }
//--------------------------------------------------------------------------- std::vector<boost::shared_ptr<TFormMachine> > CreateMachines( TFormSimStagecraftMain * const formParent, const int level) { std::vector<boost::shared_ptr<TFormMachine> > machines; switch (level) { case 1: { boost::shared_ptr<TFormMachine> m1( new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> m2( new TFormPar64(0,formParent)); machines.push_back(m1); machines.push_back(m2); } break; case 2: { boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> speaker(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> mic(new TFormShureSm58(0,formParent)); machines.push_back(mic); machines.push_back(speaker); machines.push_back(wallSocket220); } break; case 3: { boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> speaker1(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> speaker2(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> mic(new TFormShureSm58(0,formParent)); boost::shared_ptr<TFormMachine> triplet(new TFormTriplet(0,formParent)); boost::shared_ptr<TFormMachine> soundTable(new TFormSimpleSound1(0,formParent)); machines.push_back(speaker1); machines.push_back(mic); machines.push_back(speaker2); machines.push_back(wallSocket220); machines.push_back(soundTable); machines.push_back(triplet); } break; case 4: { boost::shared_ptr<TFormMachine> dimmerpack(new TFormDimblockV3(0,formParent)); boost::shared_ptr<TFormMachine> lighttable(new TFormSimpleShine1(0,formParent)); boost::shared_ptr<TFormMachine> wallSocketPower(new TFormWallSocketPower(0,formParent)); boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> par64_1(new TFormPar64(0,formParent)); boost::shared_ptr<TFormMachine> par64_2(new TFormPar64(0,formParent)); boost::shared_ptr<TFormMachine> par64_3(new TFormPar64(0,formParent)); boost::shared_ptr<TFormMachine> par64_4(new TFormPar64(0,formParent)); boost::shared_ptr<TFormMachine> par64_5(new TFormPar64(0,formParent)); machines.push_back(wallSocketPower); machines.push_back(dimmerpack); machines.push_back(wallSocket220); machines.push_back(par64_1); machines.push_back(lighttable); machines.push_back(par64_2); machines.push_back(par64_3); machines.push_back(par64_4); machines.push_back(par64_5); } break; case 5: { boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> speaker1(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> speaker2(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> mic1(new TFormShureSm58(0,formParent)); boost::shared_ptr<TFormMachine> mic2(new TFormShureSm58(0,formParent)); boost::shared_ptr<TFormMachine> triplet(new TFormTriplet(0,formParent)); boost::shared_ptr<TFormMachine> soundTable(new TFormSimpleSound2(0,formParent)); machines.push_back(mic1); machines.push_back(triplet); machines.push_back(mic2); machines.push_back(speaker1); machines.push_back(soundTable); machines.push_back(speaker2); machines.push_back(wallSocket220); } break; case 6: { boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> mic1(new TFormShureSm58(0,formParent)); boost::shared_ptr<TFormMachine> speaker1(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> triplet(new TFormTriplet(0,formParent)); boost::shared_ptr<TFormMachine> soundTable3(new TFormSimpleSound3(0,formParent)); machines.push_back(mic1); machines.push_back(speaker1); machines.push_back(wallSocket220); machines.push_back(triplet); machines.push_back(soundTable3); } break; case 7: { boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> mic1(new TFormShureSm58(0,formParent)); boost::shared_ptr<TFormMachine> mic2(new TFormShureSm58(0,formParent)); boost::shared_ptr<TFormMachine> mic3(new TFormShureSm58(0,formParent)); boost::shared_ptr<TFormMachine> speaker1(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> speaker2(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> speaker3(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> speaker4(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> octlet(new TFormOctlet(0,formParent)); boost::shared_ptr<TFormMachine> soundTable3(new TFormSimpleSound3(0,formParent)); machines.push_back(mic1); machines.push_back(mic2); machines.push_back(mic3); machines.push_back(octlet); machines.push_back(speaker1); machines.push_back(speaker2); machines.push_back(speaker3); machines.push_back(speaker4); machines.push_back(wallSocket220); machines.push_back(soundTable3); } break; case 8: { //Put a CD on speakers without using a soundtable boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> speaker1(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> octlet(new TFormOctlet(0,formParent)); boost::shared_ptr<TFormCdPlayer> cdPlayer(new TFormCdPlayer(0,formParent)); boost::shared_ptr<TFormTransitionPieceJackMaleTwoCinchFemale> transitionPiece( new TFormTransitionPieceJackMaleTwoCinchFemale(0,formParent)); machines.push_back(octlet); machines.push_back(speaker1); machines.push_back(wallSocket220); machines.push_back(cdPlayer); machines.push_back(transitionPiece); } break; case 9: { //Put a CD on speakers with using a soundtable boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> speaker1(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> octlet(new TFormOctlet(0,formParent)); boost::shared_ptr<TFormCdPlayer> cdPlayer(new TFormCdPlayer(0,formParent)); boost::shared_ptr<TFormMachine> soundTable4(new TFormSimpleSound4(0,formParent)); machines.push_back(octlet); machines.push_back(speaker1); machines.push_back(cdPlayer); machines.push_back(wallSocket220); machines.push_back(soundTable4); } break; case 10: { //Record a CD on MD play boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> speaker1(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> octlet(new TFormOctlet(0,formParent)); //boost::shared_ptr<TFormMachine> soundTable4(new TFormSimpleSound4(0,formParent)); boost::shared_ptr<TFormMdPlayer> mdPlayer(new TFormMdPlayer(0,formParent)); boost::shared_ptr<TFormCdPlayer> cdPlayer(new TFormCdPlayer(0,formParent)); boost::shared_ptr<TFormTransitionPieceJackMaleTwoCinchFemale> transitionPiece( new TFormTransitionPieceJackMaleTwoCinchFemale(0,formParent)); machines.push_back(octlet); machines.push_back(speaker1); machines.push_back(wallSocket220); //machines.push_back(soundTable4); machines.push_back(mdPlayer); machines.push_back(transitionPiece); machines.push_back(cdPlayer); } break; case 11: { //Record a CD and microphone on MD play boost::shared_ptr<TFormMachine> mic1(new TFormShureSm58(0,formParent)); boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> speaker1(new TFormRcf322A(0,formParent)); boost::shared_ptr<TFormMachine> octlet(new TFormOctlet(0,formParent)); boost::shared_ptr<TFormMachine> soundTable4(new TFormSimpleSound4(0,formParent)); boost::shared_ptr<TFormMdPlayer> mdPlayer(new TFormMdPlayer(0,formParent)); //boost::shared_ptr<TFormCdPlayer> cdPlayer(new TFormCdPlayer(0,formParent)); boost::shared_ptr<TFormTransitionPieceJackMaleTwoCinchFemale> transitionPiece( new TFormTransitionPieceJackMaleTwoCinchFemale(0,formParent)); machines.push_back(wallSocket220); machines.push_back(speaker1); machines.push_back(octlet); machines.push_back(mic1); machines.push_back(soundTable4); machines.push_back(transitionPiece); //machines.push_back(cdPlayer); machines.push_back(mdPlayer); } break; case 12: { //Level 12: Learn to use the crossfader boost::shared_ptr<TFormMachine> dimmerpack(new TFormDimblockV3(0,formParent)); boost::shared_ptr<TFormMachine> lighttable(new TFormSimpleShine2(0,formParent)); boost::shared_ptr<TFormMachine> wallSocketPower(new TFormWallSocketPower(0,formParent)); boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> par64_1(new TFormPar64(0,formParent)); boost::shared_ptr<TFormMachine> par64_2(new TFormPar64(0,formParent)); boost::shared_ptr<TFormMachine> par64_3(new TFormPar64(0,formParent)); boost::shared_ptr<TFormMachine> par64_4(new TFormPar64(0,formParent)); boost::shared_ptr<TFormMachine> par64_5(new TFormPar64(0,formParent)); machines.push_back(wallSocketPower); machines.push_back(dimmerpack); machines.push_back(wallSocket220); machines.push_back(par64_1); machines.push_back(lighttable); machines.push_back(par64_2); machines.push_back(par64_3); machines.push_back(par64_4); machines.push_back(par64_5); } break; case 13: { boost::shared_ptr<TFormMachine> wallSocket220(new TFormWallSocket220(0,formParent)); boost::shared_ptr<TFormMachine> mic(new TFormShureSm58(0,formParent)); boost::shared_ptr<TFormMachine> speaker(new TFormRcfEvent3000(0,formParent)); boost::shared_ptr<TFormMachine> amplifier(new TFormEasyAmp(0,formParent)); machines.push_back(mic); machines.push_back(speaker); machines.push_back(wallSocket220); machines.push_back(amplifier); } break; default: //Do nothing break; } return machines; }
void linear::fill_mass() { #ifdef LOAD std::cout << " Reading mass matrix" << std::endl; loadMarket(mass, "mass.mtx"); #else std::cout << " Filling mass matrix" << std::endl; std::vector<triplet> aa; // list of non-zeros coefficients int N=0; for(F_v_it fv=T.finite_vertices_begin(); fv!=T.finite_vertices_end(); fv++) { ++N; int vi=fv->idx.val(); typedef Vertex::scalar_link scalar_link; scalar_link masss=fv->mass(); for( scalar_link::iterator nn= masss.begin(); nn!=masss.end(); ++nn) { int vj=nn->first->idx.val(); FT mm = nn->second; aa.push_back( triplet(vi,vj, mm )); } } mass.resize(N,N); mass.setFromTriplets(aa.begin(), aa.end()); std::cout << " Filled mass matrix" << std::endl; cout << "matrix size " << mass.rows() << " x " << mass.cols() << endl; #endif // Only non-direct iterative solvers #ifndef DIRECT_SOLVER solver_mass.setTolerance( TOL ); #endif solver_mass.compute(mass); if(solver_mass.info()!=Eigen::Success) { std::cout << "Failure decomposing mass matrix\n"; } return; }
void linear::fill_stiff(void){ #ifdef LOAD std::cout << " Reading stiffness matrix" << std::endl; loadMarket(stiff, "stiff.mtx"); loadMarket(stiffp1, "stiffp1.mtx"); #else std::cout << " Filling stiffness matrix" << std::endl; // int n=simu.no_of_points(); std::vector<triplet> aa , bb ; // list of non-zeros coefficients int N=0; for(F_v_it fv=T.finite_vertices_begin(); fv!=T.finite_vertices_end(); fv++) { ++N; int vi=fv->idx.val(); typedef Vertex::scalar_link scalar_link; // typedef std::map<Vertex_handle,Vector_2> vector_link; scalar_link stiffs=fv->stiff(); for( scalar_link::iterator nn= stiffs.begin(); nn!=stiffs.end(); ++nn) { int vj=nn->first->idx.val(); FT ddelta = nn->second; // wrong sign here ??? // Aqui con Ada // cout << vi << " , " << vj << " " << ddelta << endl; aa.push_back( triplet(vi,vj, -ddelta )); if( (vi!=0) && (vj!=0) ) bb.push_back( triplet(vi - 1 , vj -1 , -ddelta )); } } stiff.resize(N,N); stiff.setFromTriplets(aa.begin(), aa.end()); std::cout << " Filled stiffness matrix" << std::endl; cout << "matrix size " << stiff.rows() << " x " << stiff.cols() << endl; // F_v_it fv=T.finite_vertices_begin(); // int i0=fv->idx.val(); // aa.push_back( triplet( N , i0 , 1 ) ); // anchor particle 0 to have fixed pressure // //aa.push_back( triplet( N , 0 , 1 ) ); // anchor particle 0 to have fixed pressure // stiffp1.resize(N+1,N+1); // stiffp1.setFromTriplets(aa.begin(), aa.end()); stiffp1.resize(N-1,N-1); stiffp1.setFromTriplets(bb.begin(), bb.end()); std::cout << " Filled stiffness plus 1 matrix" << std::endl; cout << "matrix size " << stiffp1.rows() << " x " << stiffp1.cols() << endl; #endif // Only non-direct iterative solvers #ifndef DIRECT_SOLVER solver_stiffp1.setTolerance( TOL ); solver_stiffp1.setMaxIterations( 40 * N ); #endif solver_stiffp1.compute(stiffp1); if(solver_stiffp1.info()!=Eigen::Success) { std::cout << "Failure decomposing stiff plus 1 matrix\n"; } return; }
int main() { int flag,number; char input[3]; //creating 3 node type variables new_node current and head node *new_node,*current; printf("\nEnter data to First linked list\n"); //Dynamic initializtion new_node=(node *)malloc(sizeof(node)); printf("\nEnter data to the node: "); //Storing some data scanf("%d",&new_node->data); //head pointing to the new node head=new_node; new_node->next=NULL; length_1++; current=new_node; printf("\nDo you want to enter new node(yes/no):"); scanf("%s",input); flag=string_test(input); //Iterate itself until flag is 1 i. the string entered is yes while(flag==1) { length_1++; //calling create_node function to create new node and link it current=create_node(current); printf("\nDo you want to enter new node(yes/no):"); scanf("%s",input); //calling string_test fuction to check whether the input is yes or no flag=string_test(input); } //Calling the display function and passing head as the value display(head); printf("\nEnter the data to Second linked list"); //Dynamic initializtion new_node=(node *)malloc(sizeof(node)); printf("\nEnter data to the node: "); //Storing some data scanf("%d",&new_node->data); //head pointing to the new node head2=new_node; new_node->next=NULL; length_2++; current=new_node; printf("\nDo you want to enter new node(yes/no):"); scanf("%s",input); flag=string_test(input); //Iterate itself until flag is 1 i. the string entered is yes while(flag==1) { length_2++; //calling create_node function to create new node and link it current=create_node(current); printf("\nDo you want to enter new node(yes/no):"); scanf("%s",input); //calling string_test fuction to check whether the input is yes or no flag=string_test(input); } //Calling the display function and passing head as the value display(head2); printf("\nEnter the data to Third linked list"); //Dynamic initializtion new_node=(node *)malloc(sizeof(node)); printf("\nEnter data to the node: "); //Storing some data scanf("%d",&new_node->data); //head pointing to the new node head3=new_node; new_node->next=NULL; length_3++; current=new_node; printf("\nDo you want to enter new node(yes/no):"); scanf("%s",input); flag=string_test(input); //Iterate itself until flag is 1 i. the string entered is yes while(flag==1) { length_3++; //calling create_node function to create new node and link it current=create_node(current); printf("\nDo you want to enter new node(yes/no):"); scanf("%s",input); //calling string_test fuction to check whether the input is yes or no flag=string_test(input); } //Calling the display function and passing head as the value display(head3); printf("\nEnter the number to find its triplet:"); scanf("%d",&number); triplet(number); return 0; }