int main () { //Remove shared memory on construction and destruction struct shm_remove { //<- #if 1 shm_remove() { shared_memory_object::remove(test::get_process_id_name()); } ~shm_remove(){ shared_memory_object::remove(test::get_process_id_name()); } #else //-> shm_remove() { shared_memory_object::remove("MySharedMemory"); } ~shm_remove(){ shared_memory_object::remove("MySharedMemory"); } //<- #endif //-> } remover; //<- #if 1 managed_shared_memory segment( create_only, test::get_process_id_name(), //segment name 65536); //segment size in bytes #else //-> managed_shared_memory segment( create_only, "MySharedMemory", //segment name 65536); //segment size in bytes //<- #endif //-> //Construct shared memory vector MyVector *myvector = segment.construct<MyVector>("MyVector") (IntAllocator(segment.get_segment_manager())); //Fill vector myvector->reserve(100); for(int i = 0; i < 100; ++i){ myvector->push_back(i); } //Create the vectorstream. To create the internal shared memory //basic_string we need to pass the shared memory allocator as //a constructor argument MyVectorStream myvectorstream(CharAllocator(segment.get_segment_manager())); //Reserve the internal string myvectorstream.reserve(100*5); //Write all vector elements as text in the internal string //Data will be directly written in shared memory, because //internal string's allocator is a shared memory allocator for(std::size_t i = 0, max = myvector->size(); i < max; ++i){ myvectorstream << (*myvector)[i] << std::endl; } //Auxiliary vector to compare original data MyVector *myvector2 = segment.construct<MyVector>("MyVector2") (IntAllocator(segment.get_segment_manager())); //Avoid reallocations myvector2->reserve(100); //Extract all values from the internal //string directly to a shared memory vector. std::istream_iterator<int> it(myvectorstream), itend; std::copy(it, itend, std::back_inserter(*myvector2)); //Compare vectors assert(std::equal(myvector->begin(), myvector->end(), myvector2->begin())); //Create a copy of the internal string MyString stringcopy (myvectorstream.vector()); //Now we create a new empty shared memory string... MyString *mystring = segment.construct<MyString>("MyString") (CharAllocator(segment.get_segment_manager())); //...and we swap vectorstream's internal string //with the new one: after this statement mystring //will be the owner of the formatted data. //No reallocations, no data copies myvectorstream.swap_vector(*mystring); //Let's compare both strings assert(stringcopy == *mystring); //Done, destroy and delete vectors and string from the segment segment.destroy_ptr(myvector2); segment.destroy_ptr(myvector); segment.destroy_ptr(mystring); return 0; }
int main() { // Create a default vector MyVector sam; // push some data into sam cout << "\nPushing three values into sam"; sam.push_back(TEST_VALUE1); sam.push_back(TEST_VALUE2); sam.push_back(TEST_VALUE3); cout << "\nThe values in sam are: "; // test for out of bounds condition here // and test exception for (int i = 0; i < sam.size() + 1; i++) { try { cout << sam.at(i) << " "; } catch (int badIndex) { cout << "\nOut of bounds at index " << badIndex << endl; } } cout << "\n--------------\n"; // clear sam and display its size and capacity sam.clear(); cout << "\nsam has been cleared."; cout << "\nSam's size is now " << sam.size(); cout << "\nSam's capacity is now " << sam.capacity() << endl; cout << "---------------\n"; // Push 12 values into the vector - it should grow cout << "\nPush 12 values into sam."; for (int i = 0; i < MAX; i++) sam.push_back(i); cout << "\nSam's size is now " << sam.size(); cout << "\nSam's capcacity is now " << sam.capacity() << endl; cout << "---------------\n"; cout << "\nTest to see if contents are correct..."; // display the values in the vector for (int i = 0; i < sam.size(); i++) { cout << sam.at(i) << " "; } cout << "\n--------------\n"; cout << "\n\nTest Complete..."; cout << endl; system("PAUSE"); return 0; }
//Main function. For parent process argc == 1, for child process argc == 2 int main(int argc, char *argv[]) { if(argc == 1){ //Parent process //Remove shared memory on construction and destruction struct shm_remove { //<- #if 1 shm_remove() { shared_memory_object::remove(test::get_process_id_name()); } ~shm_remove(){ shared_memory_object::remove(test::get_process_id_name()); } #else //-> shm_remove() { shared_memory_object::remove("MySharedMemory"); } ~shm_remove(){ shared_memory_object::remove("MySharedMemory"); } //<- #endif //-> } remover; //<- (void)remover; //-> //Create a new segment with given name and size //<- #if 1 managed_shared_memory segment(create_only, test::get_process_id_name(), 65536); #else //-> managed_shared_memory segment(create_only, "MySharedMemory", 65536); //<- #endif //-> //Initialize shared memory STL-compatible allocator const ShmemAllocator alloc_inst (segment.get_segment_manager()); //Construct a vector named "MyVector" in shared memory with argument alloc_inst MyVector *myvector = segment.construct<MyVector>("MyVector")(alloc_inst); for(int i = 0; i < 100; ++i) //Insert data in the vector myvector->push_back(i); //Launch child process std::string s(argv[0]); s += " child "; //<- s += test::get_process_id_name(); //-> if(0 != std::system(s.c_str())) return 1; //Check child has destroyed the vector if(segment.find<MyVector>("MyVector").first) return 1; } else{ //Child process //Open the managed segment //<- #if 1 managed_shared_memory segment(open_only, argv[2]); #else //-> managed_shared_memory segment(open_only, "MySharedMemory"); //<- #endif //-> //Find the vector using the c-string name MyVector *myvector = segment.find<MyVector>("MyVector").first; //Use vector in reverse order std::sort(myvector->rbegin(), myvector->rend()); //When done, destroy the vector from the segment segment.destroy<MyVector>("MyVector"); } return 0; };
int main () { using namespace boost::interprocess; //Remove shared memory on construction and destruction struct shm_remove { //<- #if 1 shm_remove() { shared_memory_object::remove(test::get_process_id_name()); } ~shm_remove() { shared_memory_object::remove(test::get_process_id_name()); } #else //-> shm_remove() { shared_memory_object::remove("MySharedMemory"); } ~shm_remove() { shared_memory_object::remove("MySharedMemory"); } //<- #endif //-> } remover; //A managed shared memory where we can construct objects //associated with a c-string //<- #if 1 managed_shared_memory segment(create_only,test::get_process_id_name(), 65536); #else //-> managed_shared_memory segment(create_only, "MySharedMemory", //segment name 65536); //<- #endif //-> //Alias an STL-like allocator of ints that allocates ints from the segment typedef allocator<int, managed_shared_memory::segment_manager> ShmemAllocator; //Alias a vector that uses the previous STL-like allocator typedef vector<int, ShmemAllocator> MyVector; int initVal[] = {0, 1, 2, 3, 4, 5, 6 }; const int *begVal = initVal; const int *endVal = initVal + sizeof(initVal)/sizeof(initVal[0]); //Initialize the STL-like allocator const ShmemAllocator alloc_inst (segment.get_segment_manager()); //Construct the vector in the shared memory segment with the STL-like allocator //from a range of iterators MyVector *myvector = segment.construct<MyVector> ("MyVector")/*object name*/ (begVal /*first ctor parameter*/, endVal /*second ctor parameter*/, alloc_inst /*third ctor parameter*/); //Use vector as your want std::sort(myvector->rbegin(), myvector->rend()); // . . . //When done, destroy and delete vector from the segment segment.destroy<MyVector>("MyVector"); return 0; }
int main() { const std::string Help = "-------------------------------------------------------------------------\n" "TestComputeAKV: \n" "-------------------------------------------------------------------------\n" "OPTIONS: \n" "Nth=<int> theta resolution [default 3] \n" "Nph=<int> phi resolution [default 4] \n" "Radius=<double> radius of sphere. [default 1.0] \n" "AKVGuess=MyVector<double> a guess for the values of THETA, thetap, phip \n" " [default (0.,0.,0.)] \n" "L_resid_tol=<double> tolerance for L residuals when finding approximate \n" " Killing vectors. [default 1.e-12] \n" "v_resid_tol=<double> tolerance for v residuals when finding approximate \n" " Killing vectors. [default 1.e-12] \n" "min_thetap = for values less than this, thetap is considered close to \n" " zero. [default 1.e-5] \n" "symmetry_tol=<double> abs(THETA) must be less than this value to be \n" " considered an exact symmetry. [default 1.e-11] \n" "ResidualSize=<double> determines the tolerance for residuals from the \n" " multidimensional root finder. [default to 1.e-11] \n" "Solver = <std::string> which gsl multidimensional root finding algorith \n" " should be used. [default Newton] \n" "Verbose=<bool> Print spectral coefficients and warnings if true \n" " [default false] \n" ; std::string Options = ReadFileIntoString("Test.input"); OptionParser op(Options,Help); const int Nth = op.Get<int>("Nth", 3); const int Nph = op.Get<int>("Nph", 4); const double rad = op.Get<double>("Radius",1.0); MyVector<double> AKVGuess = op.Get<MyVector<double> >("AKVGuess",MyVector<double>(MV::Size(3),0.0)); //must be three-dimensional REQUIRE(AKVGuess.Size()==3,"AKVGuess has Size " << AKVGuess.Size() << ", should be 3."); const double L_resid_tol = op.Get<double>("L_resid_tol", 1.e-12); const double v_resid_tol = op.Get<double>("L_resid_tol", 1.e-12); const double residualSize = op.Get<double>("ResidualSize", 1.e-11); const double min_thetap = op.Get<double>("min_theta",1.e-5); const double symmetry_tol = op.Get<double>("symmetry_tol",1.e-11); const std::string solver = op.Get<std::string>("Solver","Newton"); const bool verbose = op.Get<bool>("Verbose", false); const MyVector<bool> printDiagnostic = MyVector<bool>(MV::Size(6), true); //create skm const StrahlkorperMesh skm(Nth, Nph); //create surface basis const SurfaceBasis sb(skm); //get theta, phi const DataMesh theta(skm.SurfaceCoords()(0)); const DataMesh phi(skm.SurfaceCoords()(1)); //set the initial guesses to be along particular axes const int axes = 3; //the number of perpendicular axes //create conformal factors for every rotation const int syms = 5; //the number of axisymmetries we are testing for(int s=4; s<5; s++) { //index over conformal factor symmetries //for(int s=0; s<syms; s++){//index over conformal factor symmetries //create conformal factor const DataMesh Psi = ConstructConformalFactor(theta, phi, s); //set the initial guesses double THETA[3] = {AKVGuess[0],0.,0.}; double thetap[3] = {AKVGuess[1],0.,0.}; double phip[3] = {AKVGuess[2],0.,0.}; //save the v, xi solutions along particular axes MyVector<DataMesh> v(MV::Size(3),DataMesh::Empty); MyVector<DataMesh> rotated_v(MV::Size(3),DataMesh::Empty); MyVector<Tensor<DataMesh> > xi(MV::Size(axes),Tensor<DataMesh>(2,"1",DataMesh::Empty)); //save the <v_i|v_j> inner product solutions double v0v0 = 0.; double v1v1 = 0.; double v2v2 = 0.; double v0v1 = 0.; double v0v2 = 0.; double v1v2 = 0.; //int symmetries[3] = 0; //counts the number of symmetries //compute some useful quantities const DataMesh rp2 = rad * Psi * Psi; const DataMesh r2p4 = rp2*rp2; const DataMesh llncf = sb.ScalarLaplacian(log(Psi)); const DataMesh Ricci = 2.0 * (1.0-2.0*llncf) / r2p4; const Tensor<DataMesh> GradRicci = sb.Gradient(Ricci); for(int a=0; a<axes; a++) { //index over perpendicular axes to find AKV solutions //if the diagnostics below decide that there is a bad solution for v[a] //(usually a repeated solution), this flag will indicate that the //solver should be run again bool badAKVSolution = false; //generate a guess for the next axis of symmetry based on prior solutions. AxisInitialGuess(thetap, phip, a); //create L DataMesh L(DataMesh::Empty); //setup struct with all necessary data rparams p = {theta, phi, rp2, sb, llncf, GradRicci, L, v[a], L_resid_tol, v_resid_tol, verbose, true }; RunAKVsolvers(THETA[a], thetap[a], phip[a], min_thetap, residualSize, verbose, &p, solver); std::cout << "Solution found with : THETA[" << a << "] = " << THETA[a] << "\n" << " thetap[" << a << "] = " << (180.0/M_PI)*thetap[a] << "\n" << " phip[" << a << "] = " << (180.0/M_PI)*phip[a] << std::endl; //check inner products // <v_i|v_j> = Integral 0.5 * Ricci * Grad(v_i) \cdot Grad(v_j) dA switch(a) { case 0: //compute inner product <v_0|v_0> v0v0 = AKVInnerProduct(v[0],v[0],Ricci,sb)*sqrt(2.)*M_PI; //if(v0v0<symmetry_tol) //symmetries++; std::cout << "<v_0|v_0> = " << v0v0 << std::endl; std::cout << "-THETA <v_0|v_0> = " << -THETA[a]*v0v0 << std::endl; break; case 1: //compute inner products <v_1|v_1>, <v_0|v_1> v1v1 = AKVInnerProduct(v[1],v[1],Ricci,sb)*sqrt(2.)*M_PI; v0v1 = AKVInnerProduct(v[0],v[1],Ricci,sb)*sqrt(2.)*M_PI; //if(v1v1<symmetry_tol) //symmetries++; std::cout << "<v_1|v_1> = " << v1v1 << std::endl; std::cout << "<v_0|v_1> = " << v0v1 << std::endl; std::cout << "-THETA <v_1|v_1> = " << -THETA[a]*v1v1 << std::endl; if(fabs(v0v0) == fabs(v1v2)) badAKVSolution = true; break; case 2: //compute inner products <v_2|v_2>, <v_0|v_2>, <v_1|v_2> v2v2 = AKVInnerProduct(v[2],v[2],Ricci,sb)*sqrt(2.)*M_PI; v0v2 = AKVInnerProduct(v[0],v[2],Ricci,sb)*sqrt(2.)*M_PI; v1v2 = AKVInnerProduct(v[1],v[2],Ricci,sb)*sqrt(2.)*M_PI; //if(v2v2<symmetry_tol) //symmetries++; std::cout << "<v_2|v_2> = " << v2v2 << std::endl; std::cout << "<v_0|v_2> = " << v0v2 << std::endl; std::cout << "<v_1|v_2> = " << v1v2 << std::endl; std::cout << "-THETA <v_2|v_2> = " << -THETA[a]*v2v2 << std::endl; if(fabs(v0v0) == fabs(v0v2)) badAKVSolution = true; if(fabs(v1v1) == fabs(v1v2)) badAKVSolution = true; break; } //Gram Schmidt orthogonalization switch(a) { case 1: if(v0v0<symmetry_tol && v1v1<symmetry_tol) { //two symmetries, v2v2 should also be symmetric GramSchmidtOrthogonalization(v[0], v0v0, v[1], v0v1); } break; case 2: if(v0v0<symmetry_tol) { if(v1v1<symmetry_tol) { REQUIRE(v2v2<symmetry_tol, "Three symmetries required, but only two found."); GramSchmidtOrthogonalization(v[0], v0v0, v[2], v0v2); GramSchmidtOrthogonalization(v[1], v1v1, v[2], v1v2); } else if(v2v2<symmetry_tol) { REQUIRE(false, "Three symmetries required, but only two found."); } else { GramSchmidtOrthogonalization(v[1], v1v1, v[2], v1v2); } } else if(v1v1<symmetry_tol) { if(v2v2<symmetry_tol) { REQUIRE(false, "Three symmetries required, but only two found."); } else { GramSchmidtOrthogonalization(v[0], v0v0, v[2], v0v2); } } else if(v2v2<symmetry_tol) { GramSchmidtOrthogonalization(v[0], v0v0, v[1], v0v1); } break; } //create xi (1-form) xi[a] = ComputeXi(v[a], sb); //perform diagnostics //Psi and xi are unscaled and unrotated KillingDiagnostics(sb, L, Psi, xi[a], rad, printDiagnostic); //rotate v, Psi for analysis rotated_v[a] = RotateOnSphere(v[a],theta,phi, sb,thetap[a],phip[a]); DataMesh rotated_Psi = RotateOnSphere(Psi,theta,phi, sb,thetap[a],phip[a]); //compare scale factors const double scaleAtEquator = NormalizeAKVAtOnePoint(sb, rotated_Psi, rotated_v[a], rad, M_PI/2., 0.0); PrintSurfaceNormalization(sb,rotated_Psi,theta,phi,rotated_v[a],scaleAtEquator,rad); MyVector<double> scaleInnerProduct = InnerProductScaleFactors(v[a], v[a], Ricci, r2p4, sb); PrintSurfaceNormalization(sb,rotated_Psi,theta,phi,rotated_v[a],scaleInnerProduct[0],rad); PrintSurfaceNormalization(sb,rotated_Psi,theta,phi,rotated_v[a],scaleInnerProduct[1],rad); PrintSurfaceNormalization(sb,rotated_Psi,theta,phi,rotated_v[a],scaleInnerProduct[2],rad); OptimizeScaleFactor(rotated_v[a], rotated_Psi, rad, sb, theta, phi, scaleAtEquator, scaleInnerProduct[0], scaleInnerProduct[1], scaleInnerProduct[2]); //scale v v[a] *= scaleAtEquator; //recompute scaled xi (1-form) xi[a] = ComputeXi(v[a], sb); if(badAKVSolution) { v[a] = 0.; thetap[a] += M_PI/4.; phip[a] += M_PI/4.; a--; std::cout << "This was a bad / repeated solution, and will be recomputed." << std::endl; } std::cout << std::endl; }//end loop over perpendicular AKV axes std::cout << "\n" << std::endl; } // Return 0 for success return NumberOfTestsFailed; }
uint64_t count64() { MessageHandler mh; mh.begin("counting") << " paths of " << typenameof(spec); std::vector<Word> tmp(stateWords + 1); Word* ptmp = tmp.data(); int const n = spec.get_root(state(ptmp)); if (n <= 0) { mh << " ..."; mh.end(0); return (n == 0) ? 0 : 1; } mh << "\n"; uint64_t total = 0; size_t maxWidth = 0; //std::cerr << "\nLevel,Width\n"; std::vector<MemoryPool> pools(n + 1); MyVector<MyList<Word> > vnodeTable(n + 1); MyVector<UniqTable> uniqTable; uniqTable.reserve(n + 1); for (int i = 0; i <= n; ++i) { uniqTable.push_back(UniqTable(hasher, hasher)); } Word* p0 = vnodeTable[n].alloc_front(stateWords + 1); spec.get_copy(state(p0), state(ptmp)); spec.destruct(state(ptmp)); number64(p0) = 1; for (int i = n; i > 0; --i) { MyList<Word>& vnodes = vnodeTable[i]; size_t m = vnodes.size(); //std::cerr << i << "," << m << "\n"; maxWidth = std::max(maxWidth, m); MyList<Word>& nextVnodes = vnodeTable[i - 1]; UniqTable& nextUniq = uniqTable[i - 1]; Word* pp = nextVnodes.alloc_front(stateWords + 1); //if (nextUniq.size() < m) nextUniq.rehash(m); for (; !vnodes.empty(); vnodes.pop_front()) { Word* p = vnodes.front(); if (number64(p) == 0) { spec.destruct(state(p)); continue; } for (int b = 0; b <= 1; ++b) { spec.get_copy(state(pp), state(p)); int ii = spec.get_child(state(pp), i, b); if (ii <= 0) { spec.destruct(state(pp)); if (ii != 0) { total += number64(p); } } else if (ii < i - 1) { Word* qq = vnodeTable[ii].alloc_front(stateWords + 1); spec.get_copy(state(qq), state(pp)); spec.destruct(state(pp)); Word* qqq = uniqTable[ii].add(qq); if (qqq == qq) { number64(qqq) = number64(p); } else { spec.destruct(state(qq)); number64(qqq) += number64(p); vnodeTable[ii].pop_front(); } } else { assert(ii == i - 1); Word* ppp = nextUniq.add(pp); if (ppp == pp) { number64(ppp) = number64(p); pp = nextVnodes.alloc_front(stateWords + 1); } else { spec.destruct(state(pp)); number64(ppp) += number64(p); } } } spec.destruct(state(p)); } nextVnodes.pop_front(); nextUniq.clear(); pools[i].clear(); spec.destructLevel(i); mh << "."; } mh.end(maxWidth); return total; }
std::string count() { MessageHandler mh; mh.begin("counting") << " paths of " << typenameof(spec); std::vector<Word> tmp(stateWords + 1); Word* ptmp = tmp.data(); int const n = spec.get_root(state(ptmp)); if (n <= 0) { mh << " ..."; mh.end(0); return (n == 0) ? "0" : "1"; } uint64_t totalStorage[n / 63 + 1]; BigNumber total(totalStorage); total.store(0); size_t maxWidth = 0; //std::cerr << "\nLevel,Width\n"; std::vector<MemoryPool> pools(n + 1); MyVector<MyList<Word> > vnodeTable(n + 1); MyVector<UniqTable> uniqTable; uniqTable.reserve(n + 1); for (int i = 0; i <= n; ++i) { uniqTable.push_back(UniqTable(hasher, hasher)); } int numberWords = 1; Word* p0 = vnodeTable[n].alloc_front(stateWords + 1); spec.get_copy(state(p0), state(ptmp)); spec.destruct(state(ptmp)); number(p0).store(1); mh.setSteps(n); for (int i = n; i > 0; --i) { MyList<Word>& vnodes = vnodeTable[i]; size_t m = vnodes.size(); //std::cerr << i << "," << m << "\n"; maxWidth = std::max(maxWidth, m); MyList<Word>& nextVnodes = vnodeTable[i - 1]; UniqTable& nextUniq = uniqTable[i - 1]; int const nextWords = stateWords + numberWords + 1; Word* pp = nextVnodes.alloc_front(nextWords); //if (nextUniq.size() < m) nextUniq.rehash(m); for (; !vnodes.empty(); vnodes.pop_front()) { Word* p = vnodes.front(); if (number(p).equals(0)) { spec.destruct(state(p)); continue; } for (int b = 0; b <= 1; ++b) { spec.get_copy(state(pp), state(p)); int ii = spec.get_child(state(pp), i, b); if (ii <= 0) { spec.destruct(state(pp)); if (ii != 0) { total.add(number(p)); } } else if (ii < i - 1) { Word* qq = vnodeTable[ii].alloc_front( nextWords + (i - ii) / 63); spec.get_copy(state(qq), state(pp)); spec.destruct(state(pp)); Word* qqq = uniqTable[ii].add(qq); if (qqq == qq) { number(qqq).store(number(p)); } else { spec.destruct(state(qq)); int w = number(qqq).add(number(p)); if (numberWords < w) { numberWords = w; //FIXME might be broken at long skip } vnodeTable[ii].pop_front(); } } else { assert(ii == i - 1); Word* ppp = nextUniq.add(pp); if (ppp == pp) { number(ppp).store(number(p)); pp = nextVnodes.alloc_front(nextWords); } else { spec.destruct(state(pp)); int w = number(ppp).add(number(p)); if (numberWords < w) { numberWords = w; //FIXME might be broken at long skip } } } } spec.destruct(state(p)); } nextVnodes.pop_front(); nextUniq.clear(); pools[i].clear(); spec.destructLevel(i); mh.step(); } mh.end(maxWidth); return total; }
void DrawMissiles(vector<missile*> missiles, myVertex* terrainVertex, Spiders* spiders){ vector<missile*>::iterator it; vector<int> needToExit; int i = 0, j = 0; float tmpSize; for (it = missiles.begin(); it != missiles.end(); it++){ if ((*it)->needToExit()){ continue; } float terrainY = getYFromXZ ((*it)->getX(), (*it)->getZ(), terrainVertex); if ((*it)->isColliding(terrainY)){ //Utilize "explode XX.tga" if (explodeModeFlag){ if (!(*it)->tgaNeedToExit()){ (*it)->tgaExplode(); } else{ needToExit.push_back(i); } } //Utilize "fire1.bmp" else{ if (!(*it)->needToExit()){ (*it)->explode(); } else{ needToExit.push_back(i); } } tmpSize = 0; MyVector tmpPos = MyVectorBuilder::createMyVectorBuilder() .withX((*it)->getX()) .withY(0) .withZ((*it)->getZ()) .build(); if ((*it)->getExplodeFrame() == 2){ for (j = 0; j<(int)spiders->getSpiderList().size();j++){ tmpSize = spiders->getSpiderList().at(i).getSize(); if (abs((*it)->getX() - spiders->getSpiderList().at(j).getPosition().getX()) > tmpSize + 20){ continue; } if (abs((*it)->getZ() - spiders->getSpiderList().at(j).getPosition().getZ()) > tmpSize + 20){ continue; } if (tmpPos.distance(spiders->getSpiderList().at(j).getPosition()) < tmpSize + 20){ spiders->die(j, 1); } } } } else{ (*it)->drawMissile(); (*it)->forward(); } i++; } //clear missiles that already exit //sort (needToExit.begin(), needToExit.end(), myfunction); //for (i = 0; i < needToExit.size(); i++){ // missiles.erase(missiles.begin()+needToExit.at(i)-i); //} //needToExit.clear(); }
// This tests basic segmented vector construction and iteration. void TestBasics() { // A SegmentedVector with a POD element type. typedef SegmentedVector<int, 1024, InfallibleAllocPolicy> MyVector; MyVector v; int i, n; MOZ_RELEASE_ASSERT(v.IsEmpty()); // Add 100 elements, then check various things. i = 0; for ( ; i < 100; i++) { gDummy = v.Append(mozilla::Move(i)); } MOZ_RELEASE_ASSERT(!v.IsEmpty()); MOZ_RELEASE_ASSERT(v.Length() == 100); n = 0; for (auto iter = v.Iter(); !iter.Done(); iter.Next()) { MOZ_RELEASE_ASSERT(iter.Get() == n); n++; } MOZ_RELEASE_ASSERT(n == 100); // Add another 900 elements, then re-check. for ( ; i < 1000; i++) { v.InfallibleAppend(mozilla::Move(i)); } MOZ_RELEASE_ASSERT(!v.IsEmpty()); MOZ_RELEASE_ASSERT(v.Length() == 1000); n = 0; for (auto iter = v.Iter(); !iter.Done(); iter.Next()) { MOZ_RELEASE_ASSERT(iter.Get() == n); n++; } MOZ_RELEASE_ASSERT(n == 1000); // Pop off all of the elements. MOZ_RELEASE_ASSERT(v.Length() == 1000); for (int len = (int)v.Length(); len > 0; len--) { MOZ_RELEASE_ASSERT(v.GetLast() == len - 1); v.PopLast(); } MOZ_RELEASE_ASSERT(v.IsEmpty()); MOZ_RELEASE_ASSERT(v.Length() == 0); // Fill the vector up again to prepare for the clear. for (i = 0; i < 1000; i++) { v.InfallibleAppend(mozilla::Move(i)); } MOZ_RELEASE_ASSERT(!v.IsEmpty()); MOZ_RELEASE_ASSERT(v.Length() == 1000); v.Clear(); MOZ_RELEASE_ASSERT(v.IsEmpty()); MOZ_RELEASE_ASSERT(v.Length() == 0); }
// no need for origin but here to remind that this will give X and Y offset to the point from // the same center used as polar origin // <!> have to make it consistent with (i,j) orientation (computer graphics window basis orientation) <!> MyVector <float> Util::fromPolarToCartesian(MyVector <float> origin, MyVector <float> v) { return MyVector <float> (v.getX() * std::cos(v.getY()), v.getX() * std::sin(v.getY())); }
float Util::norm(MyVector <float> v1, MyVector <float> v2) { return norm(v1.getX(), v1.getY(), v2.getX(), v2.getY()); }
/********************************************************** * * RenderSpan * * parameters IN: * int y * EdgeBox ** edgeBox1 * EdgeBox ** edgeBox2 * *********************************************************/ void RenderSpan (int y, EdgeBox ** edgeBox1, EdgeBox ** edgeBox2) { EdgeBox * tempEdgeBox; int x, z; double dz, di; MyVector dw; if ((*edgeBox1)->x > (*edgeBox2)->x) { tempEdgeBox = *edgeBox1; *edgeBox1 = *edgeBox2; *edgeBox2 = tempEdgeBox; } int x1 = (int)(*edgeBox1)->x; int x2 = (int)(*edgeBox2)->x; if (x1 != x2) { int dx = x2 - x1; double currZ = (*edgeBox1)->z; double currI = (*edgeBox1)->i; MyVector currW = (*edgeBox1)->w; dz = ((*edgeBox2)->z - currZ) / dx; di = ((*edgeBox2)->i - currI) / dx; dw.SetX( ((*edgeBox2)->w.GetX() - currW.GetX()) / dx); dw.SetY( ((*edgeBox2)->w.GetY() - currW.GetY()) / dx); dw.SetZ( ((*edgeBox2)->w.GetZ() - currW.GetZ()) / dx); for (x = x1; x <= x2 - 1; x++) { z = (int)currZ; if (z < zBufferAt[x][y]) { zBufferAt[x][y] = z; RenderPixel (x, y, currI, currW); } currZ += dz; currI += di; currW.SetX( currW.GetX() + dw.GetX()); currW.SetY( currW.GetY() + dw.GetY()); currW.SetZ( currW.GetZ() + dw.GetZ()); } } }
/********************************************************** * * AddEdgeToList * * parameters IN: * VertexCell * vertex1 * VertexCell * vertex2 * *********************************************************/ void AddEdgeToList (VertexCell * vertex1, VertexCell * vertex2) { VertexCell * tempVertex; MyVector dw; EdgeBox * edgeBox; if (vertex1->screenPos.GetY() > vertex2->screenPos.GetY()) { tempVertex = vertex1; vertex1 = vertex2; vertex2 = tempVertex; } int y1 = vertex1->screenPos.GetY(); int y2 = vertex2->screenPos.GetY(); if (y1 != y2) { int dy = y2 - y1; double currX = vertex1->screenPos.GetX(); double currZ = vertex1->screenPos.GetZ(); double currI = lightVector.DotProduct (vertex1->vertexNormal); MyVector currW = vertex1->worldPos; double dx = (vertex2->screenPos.GetX() - currX) / dy; double dz = (vertex2->screenPos.GetZ() - currZ) / dy; double di = (lightVector.DotProduct (vertex2->vertexNormal) - currI) / dy; dw.SetX( (vertex2->worldPos.GetX() - currW.GetX()) / dy); dw.SetY( (vertex2->worldPos.GetY() - currW.GetY()) / dy); dw.SetZ( (vertex2->worldPos.GetZ() - currW.GetZ()) / dy); for (int y = y1; y <= y2 - 1; y++) { edgeBox = new EdgeBox; edgeBox->x = currX; edgeBox->z = (int)currZ; edgeBox->i = currI; edgeBox->w = currW; edgeBox->next = edgeListAt[y]; edgeListAt[y] = edgeBox; currX += dx; currZ += dz; currI += di; currW.SetX( currW.GetX() + dw.GetX()); currW.SetY( currW.GetY() + dw.GetY()); currW.SetZ( currW.GetZ() + dw.GetZ()); } } }
/** * Resizes the table rows. * @param n the number of rows. */ void setNumRows(int n) { table.resize(n); }
/** * Clears and initializes the table. * @param n the number of rows. */ void init(int n = 0) { table.clear(); table.resize(n); }
/** * Gets the number of rows. * @return the number of rows. */ int numRows() const { return table.size(); }