int main() { Liste l1=Exemple1(); Liste l2=Exemple2(); printf("Liste1 de 7 elements :\n"); afficherliste(l1); printf("Liste2 de 6 elements :\n"); afficherliste(l2); Arbin a1=la(l1); Arbin a2=la(l2); printf("Affichage de l'arbre1\n"); afficherArbre(a1); printf("Affichage de l'arbre2\n"); afficherArbre(a2); printf("\n"); Liste l3=al(a1); printf("al sur arbre1 :\n"); afficherliste(l3); Arbin u0=union0(a1,a2); Arbin u1=union1(a1,a2); printf("Affichage de union0 :\n"); afficherArbre(u0); printf("Affichage de union1 :\n"); afficherArbre(u1); printf("Oter le minimum de l'arbre1\n"); Arbin o=om(a1); afficherArbre(o); Arbin i=ins(a1,42); printf("Insertion de 42 dans l'arbre1\n"); afficherArbre(i); freeListe(l1); freeListe(l2); freeListe(l3); freeArbre(a1); freeArbre(a2); freeArbre(u0); freeArbre(u1); freeArbre(o); freeArbre(i); return 0; }
void MainWindow::open(QString fileName) { std::ifstream ifs(qPrintable(fileName)); char c; double x,y; Segment_2 s; while(ifs >> c){ if(c == 's'){ ifs >> x >> y; Point_2 p(x,y); ifs >> x >> y; Point_2 q(x,y); Line_arc_2 la(Segment_2(p,q)); for(std::vector<CGAL::Object>::iterator it = arcs.begin(); it != arcs.end(); ++it){ Circular_arc_2 vca; Line_arc_2 vla; if(assign(vca, *it)){ CGAL::intersection(la, vca, std::back_inserter(intersections)); } else if(assign(vla, *it)){ CGAL::intersection(la, vla, std::back_inserter(intersections)); } } arcs.push_back(make_object(la)); } else if(c == 'c'){
int* alltmera(int kryddnejlika, std::string* krympning) { if (kryddnejlika > 3 || *krympning == "kugg") return new int (29408); int krypta = kryddnejlika + 1; std::string* kula = new std::string("kulmen"); int* kullerbytta = ann(krypta, kula); std::string* kulspruta = new std::string("kundmottagning"); int* kunde = allmoge(krypta, kulspruta); std::string* kung = new std::string("kunnat"); int* kunna = anskaffning(krypta, kung); std::string kunskapsutveckling("kupering"); int kupa = annanstans(&krypta, kunskapsutveckling); std::string kurva("kvar"); std::string* kvadd = alltihop(&krypta, kurva); std::string* kvarleva = new std::string("kvarvarande"); int* kvarn = anskaffning(krypta, kvarleva); std::string* kvinna = new std::string("kyrka"); int* kyckling = adressering(krypta, kvinna); std::string kyrkoherde("l"); int kyss = anslutningspropp(0, kyrkoherde); std::string la("lada"); int labb = annanstans(&krypta, la); int* laddning = new int(14289); return laddning; } // alltmera
int main() { string code = getText(); list<Token> tokens; LexicalAnalyzer la(code); // Lines 18-28: tokenize the entire text, store in tokens list while (!la.analyzed()) { tokens.push_back(la.lexer()); } la.initKnownTokenTypes(tokens); Fsm typeSetter; for (auto it = tokens.begin(); it != tokens.end(); ++it) { typeSetter.identify(*it); } if (tokens.back().lexeme() == "") { tokens.back().type("eof"); } else { tokens.push_back(Token("", "eof")); } SyntaxAnalyzer sa(tokens); sa.analyze(); //display(tokens); system("pause"); return 0; }
rc_t fullPipelineTest(ss_m* ssm, test_volume_t* test_vol) { unsigned howManyToInsert = 1000; W_DO(populateBtree(ssm, test_vol, howManyToInsert)); LogArchiver::LogConsumer cons(lsn_t(1,0), BLOCK_SIZE); LogArchiver::ArchiverHeap heap(BLOCK_SIZE); LogArchiver::ArchiveDirectory dir(test_env->archive_dir, BLOCK_SIZE); LogArchiver::BlockAssembly assemb(&dir); LogArchiver la(&dir, &cons, &heap, &assemb); la.fork(); la.activate(lsn_t::null, true /* wait */); // nextLSN of consumer tells us that all logrecs up (and excluding) that // LSN were added to the heap. When shutdown is invoked, heap is then emptied // using the selection method, thus also gauaranteeing that the archive is persistent // up to nextLSN while (cons.getNextLSN() < ssm->log->durable_lsn()) { usleep(1000); // 1ms } la.shutdown(); la.join(); // TODO use archive scanner to verify: // 1) integrity of archive // 2) if no logrecs are missing (scan log with same ignores as log archiver // and check if each logrec is in archiver -- random access, NL join) return RCOK; }
void ResolvedMethod::makeParameterList(TR::ResolvedMethodSymbol *methodSym) { ListAppender<TR::ParameterSymbol> la(&methodSym->getParameterList()); TR::ParameterSymbol *parmSymbol; int32_t slot = 0; int32_t ordinal = 0; uint32_t parmSlots = numberOfParameterSlots(); for (int32_t parmIndex = 0; parmIndex < parmSlots; ++parmIndex) { TR::IlType *type = _parmTypes[parmIndex]; TR::DataType dt = type->getPrimitiveType(); int32_t size = methodSym->convertTypeToSize(dt); parmSymbol = methodSym->comp()->getSymRefTab()->createParameterSymbol(methodSym, slot, type->getPrimitiveType(), false); parmSymbol->setOrdinal(ordinal++); char *s = type->getSignatureName(); uint32_t len = strlen(s); parmSymbol->setTypeSignature(s, len); la.add(parmSymbol); ++slot; } int32_t lastInterpreterSlot = slot + numberOfTemps(); methodSym->setTempIndex(lastInterpreterSlot, methodSym->comp()->fe()); methodSym->setFirstJitTempIndex(methodSym->getTempIndex()); }
Arbin union0(Arbin a1,Arbin a2) { Liste l1=al(a1); Liste l2=al(a2); Liste l=concat(l1,l2); Arbin a=la(l); freeListe(l); freeListe(l1); freeListe(l2); return a; }
void glpk_wrapper::set_objective(Enode * const e) { assert(is_expr_linear(e)); LAExpression la(e); for (auto it = la.begin(); it != la.end(); ++it) { auto v = it->first; auto c = it->second; if (v != nullptr) { glp_set_obj_coef(lp, get_index(v) + 1, c); } } }
int main(int argc, char *argv[]) { SockStream addr; addr.sin_family = AF_INET; addr.sin_addr.s_addr = INADDR_ANY; addr.sin_port = htons(uport); LoggingAcceptor la(addr); for(;;) InitiationDispatcher::Instance()->HandleEvents(); return 0; }
static void do_import(SExpressionHashPackage *pkg, const SReference &a, const SReference &d) { SReference la(a); if(!pkg->Import(la)) { throw IntelibX_package_conflict(a); } if(d.IsEmptyList()) return; SExpressionCons *dp = d.DynamicCastGetPtr<SExpressionCons>(); INTELIB_ASSERT(dp, IntelibX_not_a_list(d)); do_import(pkg, dp->Car(), dp->Cdr()); }
Point intersection(Segment a,Segment b) { line la(a) ,lb(b); Point res = la.intersect(lb); if (res == Point::NaP) return res; if (res == Point::INFP) if ((a.x.x >= min(b.x.x,b.y.x))&&(a.x.x <= max(b.x.x,b.y.x))) return a.x; else return a.y; if (res.x <= min(max(a.x.x,a.y.x),max(b.x.x,b.y.x)) && res.x >= max(min(a.x.x,a.y.x),min(b.x.x,b.y.x)) && res.y <= min(max(a.x.y,a.y.y),max(b.x.y,b.y.y)) && res.y >= max(min(a.x.y,a.y.y),min(b.x.y,b.y.y))) return res; return Point::NaP; };
void Agent::vmTick() { // Tick the VM associated with this agent. assert(vm); // There must *be* a VM to tick. LifeAssert la(this); // sanity check // If we're out of timeslice, give ourselves some more (depending on the game type). if (!vm->timeslice) { vm->timeslice = (engine.version < 3) ? 1 : 5; } // Keep trying to run VMs while we don't run out of timeslice, end up with a blocked VM, or a VM stops. while (vm && vm->timeslice && !vm->isBlocking() && !vm->stopped()) { assert(vm->timeslice > 0); // Tell the VM to tick (using all available timeslice), catching exceptions as necessary. try { vm->tick(); } catch (invalidAgentException &e) { // try letting the exception script handle it if (!queueScript(255)) unhandledException(e.prettyPrint(), true); else stopScript(); // we still want current script to die } catch (creaturesException &e) { unhandledException(e.prettyPrint(), true); } catch (std::exception &e) { unhandledException(e.what(), true); } // If the VM stopped, it's done. if (vm && vm->stopped()) { world.freeVM(vm); vm = NULL; } } // Zot any remaining timeslice, since we're done now. if (vm) vm->timeslice = 0; // If there's no current VM but there's one on the call stack, a previous VM must have finished, // pop one from the call stack to run next time. if (!vm && !vmstack.empty()) { vm = vmstack.front(); vmstack.pop_front(); } }
void Menu::display(float /*t*/, float /*dt*/) { // 3D: Background. video.clearScreen(); video.set3D(); glDisable(GL_FOG); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); Vec4D la(0.1f, 0.1f, 0.1f, 1.0f); glLightModelfv(GL_LIGHT_MODEL_AMBIENT, la); glEnable(GL_COLOR_MATERIAL); glColorMaterial(GL_FRONT_AND_BACK, GL_AMBIENT_AND_DIFFUSE); glColor4f(1.0f, 1.0f, 1.0f, 1.0f); for (OpenGL::Light light = GL_LIGHT0; light < GL_LIGHT0 + 8; ++light) { glLightf(light, GL_CONSTANT_ATTENUATION, 0.0f); glLightf(light, GL_LINEAR_ATTENUATION, 0.7f); glLightf(light, GL_QUADRATIC_ATTENUATION, 0.03f); glDisable(light); } glEnable(GL_CULL_FACE); glEnable(GL_DEPTH_TEST); glDepthFunc(GL_LEQUAL); glEnable(GL_LIGHTING); glEnable(GL_TEXTURE_2D); mBackgroundModel.get()->cam.setup(globalTime); mBackgroundModel.get()->draw(); glDisable(GL_TEXTURE_2D); glDisable(GL_LIGHTING); glDisable(GL_DEPTH_TEST); glDisable(GL_CULL_FACE); // 2D: UI. video.set2D(); glEnable(GL_BLEND); glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA); mGUIFrame->render(); }
void glpk_wrapper::set_constraint(int index, Enode * const e) { DREAL_LOG_INFO << "glpk_wrapper::set_constraint " << e << " with " << e->getPolarity(); assert(is_linear(e)); changed = true; LAExpression la(e); auto vars = e->get_vars(); auto s = vars.size(); auto indices = new int[s + 1]; auto values = new double[s + 1]; int i = 1; for (auto it = la.begin(); it != la.end(); ++it) { auto v = it->first; double c = it->second; if (v != nullptr && c != 0.0) { DREAL_LOG_INFO << "glpk_wrapper::set_constraint " << c << " * " << v; indices[i] = get_index(v) + 1; values[i] = c; i += 1; } else { if (e->isEq()) { assert(!e->hasPolarity() || e->getPolarity() != l_False); DREAL_LOG_INFO << "glpk_wrapper::set_constraint == " << c; glp_set_row_bnds(lp, index, GLP_FX, -c, -c); } else { if (!e->hasPolarity() || e->getPolarity() != l_False) { DREAL_LOG_INFO << "glpk_wrapper::set_constraint <= " << (-c); glp_set_row_bnds(lp, index, GLP_UP, 0, -c); } else { DREAL_LOG_INFO << "glpk_wrapper::set_constraint >= " << (-c); glp_set_row_bnds(lp, index, GLP_LO, -c, 0); } } } } glp_set_mat_row(lp, index, i-1, indices, values); delete[] indices; delete[] values; // name the constraints (helps debugging) if (DREAL_LOG_INFO_IS_ON) { std::ostringstream stream; if (e->getPolarity() == l_False) { stream << "¬"; } stream << e; glp_set_row_name(lp, index, stream.str().c_str()); } }
Point interiorMiterIntersection(Point p1, Point p2, Point p3, double strokeWidth) { Point va(p2-p1); Point vb(p3-p2); Point shiftA = 0.5 * strokeWidth * va.rotatedPI2().normalise(); Point shiftB = 0.5 * strokeWidth * vb.rotatedPI2().normalise(); if ( va.rotatedPI2() * vb >= 0.0 ) { // Left turn shiftA = -shiftA; shiftB = -shiftB; } EuclideanLine la(p1-shiftA,p2-shiftA); EuclideanLine lb(p2-shiftB,p3-shiftB); return intersection(la,lb); }
void DiagramLoader::load() { LexicalAnalyzer la(url); la.scan(); Parser parser (la.getTokens()); parser.parse(); string l =parser.getLabel(); vector<Contour> c = parser.getContours(); vector<Zone> z = parser.getZones(); vector<Zone> sz = parser.getShadedZones(); DiagramCreator dc (l, c,z,sz); diagram = dc.createDiagram(); }
void glpk_wrapper::set_objective(Enode * const e) { changed = true; for (unsigned int i = 1; i <= domain.size(); i++) { glp_set_obj_coef(lp, i, 0); } if (e != nullptr) { assert(is_expr_linear(e)); LAExpression la(e); for (auto it = la.begin(); it != la.end(); ++it) { auto v = it->first; auto c = it->second; if (v != nullptr) { glp_set_obj_coef(lp, get_index(v) + 1, c); } } } }
Point exteriorMiterIntersection(Point p1, Point p2, Point p3, double strokeWidth) { Point va(p2-p1); Point vb(p3-p2); Point shiftA = 0.5 * strokeWidth * va.rotatedPI2().normalise(); Point shiftB = 0.5 * strokeWidth * vb.rotatedPI2().normalise(); if ( va.rotatedPI2() * vb >= 0.0 ) { // Left turn shiftA = -shiftA; shiftB = -shiftB; } EuclideanLine la(p1+shiftA,p2+shiftA); EuclideanLine lb(p2+shiftB,p3+shiftB); Point result = intersection(la,lb); if (result.isInf()) { return p2; } return result; }
QString libkstartperf() { QString lib; QString la_file = KStandardDirs::locate("module", "kstartperf.la"); if (la_file.isEmpty()) { // if no '.la' file could be found, fallback to a search for the .so file // in the standard KDE directories lib = KStandardDirs::locate("module","kstartperf.so"); return lib; } // Find the name of the .so file by reading the .la file QFile la(la_file); if (la.open(QIODevice::ReadOnly)) { QTextStream is(&la); QString line; while (!is.atEnd()) { line = is.readLine(); if (line.left(15) == "library_names='") { lib = line.mid(15); int pos = lib.indexOf(' '); if (pos > 0) lib = lib.left(pos); } } la.close(); } // Look up the actual .so file. lib = KStandardDirs::locate("module", lib); return lib; }
UpdateFC(LibASS *ass) : ass(ass) { start(); if (!wait(500)) { QDialog d(QMPlay2GUI.mainW); d.setWindowTitle(QCoreApplication::applicationName()); QLabel l(QObject::tr("Font cache is updating, please wait")); QProgressBar p; p.setRange(0, 0); QVBoxLayout la(&d); la.addWidget(&l); la.addWidget(&p); d.open(); d.setMinimumSize(d.size()); d.setMaximumSize(d.size()); do el.processEvents(QEventLoop::ExcludeUserInputEvents | QEventLoop::WaitForMoreEvents); while (isRunning()); } }
rc_t runMergerFullTest(ss_m* ssm, test_volume_t* test_vol) { unsigned howManyToInsert = 2000; W_DO(populateBtree(ssm, test_vol, howManyToInsert)); LogArchiver::LogConsumer cons(lsn_t(1,0), BLOCK_SIZE); LogArchiver::ArchiverHeap heap(BLOCK_SIZE); LogArchiver::ArchiveDirectory dir(test_env->archive_dir, BLOCK_SIZE, false); LogArchiver::BlockAssembly assemb(&dir); LogArchiver la(&dir, &cons, &heap, &assemb); la.fork(); la.activate(lsn_t::null, true /* wait */); // wait for logarchiver to consume up to durable LSN, while (cons.getNextLSN() < ssm->log->durable_lsn()) { usleep(1000); // 1ms } LogArchiver::ArchiveScanner::RunMerger* merger = buildRunMergerFromDirectory(dir); PageID prevPID = 0; lsn_t prevLSN = lsn_t::null; logrec_t* lr; while (merger->next(lr)) { EXPECT_TRUE(lr->valid_header(lr->lsn_ck())); EXPECT_TRUE(lr->pid() >= prevPID); EXPECT_TRUE(lr->lsn_ck() != prevLSN); prevPID = lr->pid(); prevLSN = lr->lsn_ck(); } la.shutdown(); la.join(); return RCOK; }
/* * Receive callback for the /camera/depth_registered/points subscription */ std::vector<suturo_perception_msgs::PerceivedObject> SuturoPerceptionKnowledgeROSNode::receive_image_and_cloud(const sensor_msgs::ImageConstPtr& inputImage, const sensor_msgs::PointCloud2ConstPtr& inputCloud) { // process only one cloud pcl::PointCloud<pcl::PointXYZRGB>::Ptr cloud_in (new pcl::PointCloud<pcl::PointXYZRGB>()); pcl::fromROSMsg(*inputCloud,*cloud_in); logger.logInfo((boost::format("Received a new point cloud: size = %s") % cloud_in->points.size()).str()); // Gazebo sends us unorganized pointclouds! // Reorganize them to be able to compute the ROI of the objects // This workaround is only tested for gazebo 1.9! if(!cloud_in->isOrganized ()) { logger.logInfo((boost::format("Received an unorganized PointCloud: %d x %d .Convert it to a organized one ...") % cloud_in->width % cloud_in->height ).str()); pcl::PointCloud<pcl::PointXYZRGB>::Ptr org_cloud (new pcl::PointCloud<pcl::PointXYZRGB>()); org_cloud->width = 640; org_cloud->height = 480; org_cloud->is_dense = false; org_cloud->points.resize(640 * 480); for (int i = 0; i < cloud_in->points.size(); i++) { pcl::PointXYZRGB result; result.x = 0; result.y = 0; result.z = 0; org_cloud->points[i]=cloud_in->points[i]; } cloud_in = org_cloud; } cv_bridge::CvImagePtr cv_ptr; cv_ptr = cv_bridge::toCvCopy(inputImage, enc::BGR8); // Make a deep copy of the passed cv::Mat and set a new // boost pointer to it. boost::shared_ptr<cv::Mat> img(new cv::Mat(cv_ptr->image.clone())); sp.setOriginalRGBImage(img); logger.logInfo("processing..."); sp.setOriginalCloud(cloud_in); sp.processCloudWithProjections(cloud_in); logger.logInfo("Cloud processed. Lock buffer and return the results"); mutex.lock(); perceivedObjects = sp.getPerceivedObjects(); if(sp.getOriginalRGBImage()->cols != sp.getOriginalCloud()->width && sp.getOriginalRGBImage()->rows != sp.getOriginalCloud()->height) { // Adjust the ROI if the image is at 1280x1024 and the pointcloud is at 640x480 if(sp.getOriginalRGBImage()->cols == 1280 && sp.getOriginalRGBImage()->rows == 1024) { for (int i = 0; i < perceivedObjects.size(); i++) { ROI roi = perceivedObjects.at(i).get_c_roi(); roi.origin.x*=2; roi.origin.y*=2; roi.width*=2; roi.height*=2; perceivedObjects.at(i).set_c_roi(roi); } } else { logger.logError("UNSUPPORTED MIXTURE OF IMAGE AND POINTCLOUD DIMENSIONS"); } } // Execution pipeline // Each capability provides an enrichment for the // returned PerceivedObject // initialize threadpool boost::asio::io_service ioService; boost::thread_group threadpool; std::auto_ptr<boost::asio::io_service::work> work(new boost::asio::io_service::work(ioService)); // Add worker threads to threadpool for(int i = 0; i < numThreads; ++i) { threadpool.create_thread( boost::bind(&boost::asio::io_service::run, &ioService) ); } for (int i = 0; i < perceivedObjects.size(); i++) { // Initialize Capabilities ColorAnalysis ca(perceivedObjects[i]); ca.setLowerSThreshold(color_analysis_lower_s); ca.setUpperSThreshold(color_analysis_upper_s); ca.setLowerVThreshold(color_analysis_lower_v); ca.setUpperVThreshold(color_analysis_upper_v); suturo_perception_shape_detection::RandomSampleConsensus sd(perceivedObjects[i]); //suturo_perception_vfh_estimation::VFHEstimation vfhe(perceivedObjects[i]); // suturo_perception_3d_capabilities::CuboidMatcherAnnotator cma(perceivedObjects[i]); // Init the cuboid matcher with the table coefficients suturo_perception_3d_capabilities::CuboidMatcherAnnotator cma(perceivedObjects[i], sp.getTableCoefficients() ); // post work to threadpool ioService.post(boost::bind(&ColorAnalysis::execute, ca)); ioService.post(boost::bind(&suturo_perception_shape_detection::RandomSampleConsensus::execute, sd)); //ioService.post(boost::bind(&suturo_perception_vfh_estimation::VFHEstimation::execute, vfhe)); ioService.post(boost::bind(&suturo_perception_3d_capabilities::CuboidMatcherAnnotator::execute, cma)); // Is 2d recognition enabled? if(!recognitionDir.empty()) { // perceivedObjects[i].c_recognition_label_2d=""; suturo_perception_2d_capabilities::LabelAnnotator2D la(perceivedObjects[i], sp.getOriginalRGBImage(), object_matcher_); la.execute(); } else { // Set an empty label perceivedObjects[i].set_c_recognition_label_2d(""); } } //boost::this_thread::sleep(boost::posix_time::microseconds(1000)); // wait for thread completion. // destroy the work object to wait for all queued tasks to finish work.reset(); ioService.run(); threadpool.join_all(); std::vector<suturo_perception_msgs::PerceivedObject> perceivedObjs = *convertPerceivedObjects(&perceivedObjects); // TODO handle images in this method mutex.unlock(); return perceivedObjs; }
address InterpreterGenerator::generate_native_entry(bool synchronized) { const Register handler = r14; const Register function = r15; assert_different_registers(Rmethod, Rlocals, Rthread, Rstate, Rmonitor, handler, function); // We use the same code for synchronized and not if (native_entry) return native_entry; address start = __ pc(); // Allocate and initialize our stack frame. __ load (Rstate, 0); generate_compute_interpreter_state(true); // Make sure method is native and not abstract #ifdef ASSERT { Label ok; __ lwz (r0, Address(Rmethod, methodOopDesc::access_flags_offset())); __ andi_ (r0, r0, JVM_ACC_NATIVE | JVM_ACC_ABSTRACT); __ compare (r0, JVM_ACC_NATIVE); __ beq (ok); __ should_not_reach_here (__FILE__, __LINE__); __ bind (ok); } #endif // Lock if necessary Label not_synchronized_1; __ bne (CRsync, not_synchronized_1); __ lock_object (Rmonitor); __ bind (not_synchronized_1); // Get signature handler const Address signature_handler_addr( Rmethod, methodOopDesc::signature_handler_offset()); Label return_to_caller, got_signature_handler; __ load (handler, signature_handler_addr); __ compare (handler, 0); __ bne (got_signature_handler); __ call_VM (noreg, CAST_FROM_FN_PTR(address, InterpreterRuntime::prepare_native_call), Rmethod, CALL_VM_NO_EXCEPTION_CHECKS); __ load (r0, Address(Rthread, Thread::pending_exception_offset())); __ compare (r0, 0); __ bne (return_to_caller); __ load (handler, signature_handler_addr); __ bind (got_signature_handler); // Get the native function entry point const Address native_function_addr( Rmethod, methodOopDesc::native_function_offset()); Label got_function; __ load (function, native_function_addr); #ifdef ASSERT { // InterpreterRuntime::prepare_native_call() sets the mirror // handle and native function address first and the signature // handler last, so function should always be set here. Label ok; __ compare (function, 0); __ bne (ok); __ should_not_reach_here (__FILE__, __LINE__); __ bind (ok); } #endif // Call signature handler __ mtctr (handler); __ bctrl (); __ mr (handler, r0); // Pass JNIEnv __ la (r3, Address(Rthread, JavaThread::jni_environment_offset())); // Pass mirror handle if static const Address oop_temp_addr = STATE(_oop_temp); Label not_static; __ bne (CRstatic, not_static); __ get_mirror_handle (r4); __ store (r4, oop_temp_addr); __ la (r4, oop_temp_addr); __ bind (not_static); // Set up the Java frame anchor __ set_last_Java_frame (); // Change the thread state to native const Address thread_state_addr(Rthread, JavaThread::thread_state_offset()); #ifdef ASSERT { Label ok; __ lwz (r0, thread_state_addr); __ compare (r0, _thread_in_Java); __ beq (ok); __ should_not_reach_here (__FILE__, __LINE__); __ bind (ok); } #endif __ load (r0, _thread_in_native); __ stw (r0, thread_state_addr); // Make the call __ call (function); __ fixup_after_potential_safepoint (); // The result will be in r3 (and maybe r4 on 32-bit) or f1. // Wherever it is, we need to store it before calling anything const Register r3_save = r16; #ifdef PPC32 const Register r4_save = r17; #endif const FloatRegister f1_save = f14; __ mr (r3_save, r3); #ifdef PPC32 __ mr (r4_save, r4); #endif __ fmr (f1_save, f1); // Switch thread to "native transition" state before reading the // synchronization state. This additional state is necessary // because reading and testing the synchronization state is not // atomic with respect to garbage collection. __ load (r0, _thread_in_native_trans); __ stw (r0, thread_state_addr); // Ensure the new state is visible to the VM thread. if(os::is_MP()) { if (UseMembar) __ sync (); else __ serialize_memory (r3, r4); } // Check for safepoint operation in progress and/or pending // suspend requests. We use a leaf call in order to leave // the last_Java_frame setup undisturbed. Label block, no_block; __ load (r3, (intptr_t) SafepointSynchronize::address_of_state()); __ lwz (r0, Address(r3, 0)); __ compare (r0, SafepointSynchronize::_not_synchronized); __ bne (block); __ lwz (r0, Address(Rthread, JavaThread::suspend_flags_offset())); __ compare (r0, 0); __ beq (no_block); __ bind (block); __ call_VM_leaf ( CAST_FROM_FN_PTR(address, JavaThread::check_special_condition_for_native_trans)); __ fixup_after_potential_safepoint (); __ bind (no_block); // Change the thread state __ load (r0, _thread_in_Java); __ stw (r0, thread_state_addr); // Reset the frame anchor __ reset_last_Java_frame (); // If the result was an OOP then unbox it and store it in the frame // (where it will be safe from garbage collection) before we release // the handle it might be protected by Label non_oop, store_oop; __ load (r0, (intptr_t) AbstractInterpreter::result_handler(T_OBJECT)); __ compare (r0, handler); __ bne (non_oop); __ compare (r3_save, 0); __ beq (store_oop); __ load (r3_save, Address(r3_save, 0)); __ bind (store_oop); __ store (r3_save, STATE(_oop_temp)); __ bind (non_oop); // Reset handle block __ load (r3, Address(Rthread, JavaThread::active_handles_offset())); __ load (r0, 0); __ stw (r0, Address(r3, JNIHandleBlock::top_offset_in_bytes())); // If there is an exception we skip the result handler and return. // Note that this also skips unlocking which seems totally wrong, // but apparently this is what the asm interpreter does so we do // too. __ load (r0, Address(Rthread, Thread::pending_exception_offset())); __ compare (r0, 0); __ bne (return_to_caller); // Unlock if necessary Label not_synchronized_2; __ bne (CRsync, not_synchronized_2); __ unlock_object (Rmonitor); __ bind (not_synchronized_2); // Restore saved result and call the result handler __ mr (r3, r3_save); #ifdef PPC32 __ mr (r4, r4_save); #endif __ fmr (f1, f1_save); __ mtctr (handler); __ bctrl (); // Unwind the current activation and return __ bind (return_to_caller); generate_unwind_interpreter_state(); __ blr (); native_entry = start; return start; }
address InterpreterGenerator::generate_accessor_entry() { if (!UseFastAccessorMethods) return NULL; Label& slow_path = fast_accessor_slow_entry_path; address start = __ pc(); // Drop into the slow path if we need a safepoint check. __ load (r3, (intptr_t) SafepointSynchronize::address_of_state()); __ load (r0, Address(r3, 0)); __ compare (r0, SafepointSynchronize::_not_synchronized); __ bne (slow_path); // Load the object pointer and drop into the slow path // if we have a NullPointerException. const Register object = r4; __ load (object, Address(Rlocals, 0)); __ compare (object, 0); __ beq (slow_path); // Read the field index from the bytecode, which looks like this: // 0: 0x2a: aload_0 // 1: 0xb4: getfield // 2: index (high byte) // 3: index (low byte) // 4: 0xac/b0: ireturn/areturn const Register index = r5; __ load (index, Address(Rmethod, methodOopDesc::const_offset())); __ lwz (index, Address(index, constMethodOopDesc::codes_offset())); #ifdef ASSERT { Label ok; __ shift_right (r0, index, 16); __ compare (r0, (Bytecodes::_aload_0 << 8) | Bytecodes::_getfield); __ beq (ok); __ should_not_reach_here (__FILE__, __LINE__); __ bind (ok); } #endif __ andi_ (index, index, 0xffff); // Locate the entry in the constant pool cache const Register entry = r6; __ load (entry, Address(Rmethod, methodOopDesc::constants_offset())); __ load (entry, Address(entry,constantPoolOopDesc::cache_offset_in_bytes())); __ la (entry, Address(entry, constantPoolCacheOopDesc::base_offset())); __ shift_left(r0, index, exact_log2(in_words(ConstantPoolCacheEntry::size())) + LogBytesPerWord); __ add (entry, entry, r0); // Check the validity of the cache entry by testing whether the // _indices field contains Bytecode::_getfield in b1 byte. __ load (r0, Address(entry, ConstantPoolCacheEntry::indices_offset())); __ shift_right (r0, r0, 16); __ andi_ (r0, r0, 0xff); __ compare (r0, Bytecodes::_getfield); __ bne (slow_path); // Calculate the type and offset of the field const Register offset = r7; const Register type = r8; __ load (offset, Address(entry, ConstantPoolCacheEntry::f2_offset())); __ load (type, Address(entry, ConstantPoolCacheEntry::flags_offset())); ConstantPoolCacheEntry::verify_tosBits(); __ shift_right (type, type, ConstantPoolCacheEntry::tosBits); // Load the value Label is_object, is_int, is_byte, is_short, is_char; __ compare (type, atos); __ beq (is_object); __ compare (type, itos); __ beq (is_int); __ compare (type, btos); __ beq (is_byte); __ compare (type, stos); __ beq (is_short); __ compare (type, ctos); __ beq (is_char); __ load (r3, (intptr_t) "error: unknown type: %d\n"); __ mr (r4, type); __ call (CAST_FROM_FN_PTR(address, printf)); __ should_not_reach_here (__FILE__, __LINE__); __ bind (is_object); __ load_indexed (r3, object, offset); __ blr (); __ bind (is_int); __ lwax (r3, object, offset); __ blr (); __ bind (is_byte); __ lbax (r3, object, offset); __ blr (); __ bind (is_short); __ lhax (r3, object, offset); __ blr (); __ bind (is_char); __ lhzx (r3, object, offset); __ blr (); return start; }
static void teststdproblem(const ap::real_2d_array& a, int n, double& materr, double& orterr) { int i; int j; ap::real_2d_array ua; ap::real_2d_array la; ap::real_2d_array t; ap::real_2d_array q; ap::real_2d_array t2; ap::real_2d_array t3; ap::real_1d_array tau; ap::real_1d_array d; ap::real_1d_array e; double v; ua.setbounds(0, n-1, 0, n-1); la.setbounds(0, n-1, 0, n-1); t.setbounds(0, n-1, 0, n-1); q.setbounds(0, n-1, 0, n-1); t2.setbounds(0, n-1, 0, n-1); t3.setbounds(0, n-1, 0, n-1); // // fill // for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { ua(i,j) = 0; } } for(i = 0; i <= n-1; i++) { for(j = i; j <= n-1; j++) { ua(i,j) = a(i,j); } } for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { la(i,j) = 0; } } for(i = 0; i <= n-1; i++) { for(j = 0; j <= i; j++) { la(i,j) = a(i,j); } } // // Test 2tridiagonal: upper // smatrixtd(ua, n, true, tau, d, e); smatrixtdunpackq(ua, n, true, tau, q); for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { t(i,j) = 0; } } for(i = 0; i <= n-1; i++) { t(i,i) = d(i); } for(i = 0; i <= n-2; i++) { t(i,i+1) = e(i); t(i+1,i) = e(i); } for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { v = ap::vdotproduct(q.getcolumn(i, 0, n-1), a.getcolumn(j, 0, n-1)); t2(i,j) = v; } } for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { v = ap::vdotproduct(t2.getrow(i, 0, n-1), q.getcolumn(j, 0, n-1)); t3(i,j) = v; } } for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { materr = ap::maxreal(materr, ap::abscomplex(t3(i,j)-t(i,j))); } } for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { v = ap::vdotproduct(&q(i, 0), &q(j, 0), ap::vlen(0,n-1)); if( i==j ) { orterr = ap::maxreal(orterr, ap::abscomplex(v-1)); } else { orterr = ap::maxreal(orterr, ap::abscomplex(v)); } } } // // Test 2tridiagonal: lower // smatrixtd(la, n, false, tau, d, e); smatrixtdunpackq(la, n, false, tau, q); for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { t(i,j) = 0; } } for(i = 0; i <= n-1; i++) { t(i,i) = d(i); } for(i = 0; i <= n-2; i++) { t(i,i+1) = e(i); t(i+1,i) = e(i); } for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { v = ap::vdotproduct(q.getcolumn(i, 0, n-1), a.getcolumn(j, 0, n-1)); t2(i,j) = v; } } for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { v = ap::vdotproduct(t2.getrow(i, 0, n-1), q.getcolumn(j, 0, n-1)); t3(i,j) = v; } } for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { materr = ap::maxreal(materr, ap::abscomplex(t3(i,j)-t(i,j))); } } for(i = 0; i <= n-1; i++) { for(j = 0; j <= n-1; j++) { v = ap::vdotproduct(&q(i, 0), &q(j, 0), ap::vlen(0,n-1)); if( i==j ) { orterr = ap::maxreal(orterr, ap::abscomplex(v-1)); } else { orterr = ap::maxreal(orterr, ap::abscomplex(v)); } } } }
void Matrix::invertInplace(){ determinant = la(size, elements); determinant = 1/determinant; }
int main(int argc, char** argv) { if (argc > 1) printf("Usage: %s\n", argv[0]); #ifdef __x86_vector__ printf("using x86 vectorization\n"); #elif defined(__fpu_vector__) printf("using fpu vectorization\n"); #endif { // test correctness double _a[8] VEC_ALIGN = {0, 1, 2, 3, 4, 5, 6, 7}; double _b[8] VEC_ALIGN = {2, 4, 6, 8, 10, 12, 14, 16}; dvec<8> a(_a); dvec<8> b(_b); dvec<8> c = a + b; double _c[8] VEC_ALIGN = {2, 5, 8, 11, 14, 17, 20, 23}; assert(c == dvec<8>(_c)); dvec<8> d = a - b; double _d[8] VEC_ALIGN = {-2, -3, -4, -5, -6, -7, -8, -9}; assert(d == dvec<8>(_d)); dvec<8> e = a * b; double _e[8] VEC_ALIGN = {0, 4, 12, 24, 40, 60, 84, 112}; assert(e == dvec<8>(_e)); dvec<8> f = a / b; double _f[8] VEC_ALIGN = {0, 0.25, 0.333333333333, 0.375, 0.40, 0.4166666666, 0.42857142, 0.4375}; assert(f == dvec<8>(_f)); dvec<8> g = a.madd(c, b); double _g[8] VEC_ALIGN = {2, 9, 22, 41, 66, 97, 134, 177}; assert(g == dvec<8>(_g)); dvec<8> h = a.madd(2.0, b); double _h[8] VEC_ALIGN = {2, 6, 10, 14, 18, 22, 26, 30}; assert(h == dvec<8>(_h)); srand(time(NULL)); double total = 0.0; double rval[] = { rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0 }; clock_t start = clock(); for (int i = 0; i < COUNT; i++) { double l_a[8] VEC_ALIGN = {rval[i%8], rval[i%8+1], rval[i%8+2], rval[i%8+3], rval[i%8+4], rval[i%8+5], rval[i%8+6], rval[i%8+7]}; double l_b[8] VEC_ALIGN = {rval[i%8+1], rval[i%8+2], rval[i%8+3], rval[i%8+4], rval[i%8+5], rval[i%8+6], rval[i%8+7], rval[i%8+8]}; dvec<8> la(l_a); dvec<8> lb(l_b); dvec<8> lc = la + lb; dvec<8> ld = lc - la; dvec<8> le = ld * lc; dvec<8> lf = le / la; dvec<8> lg = la.madd(rval[i%16], lf); dvec<8> lh = lg.madd(lf, la+lb*lc-ld/le*lf); total += lh[7]; } printf("dvec<8> time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); } /* test correctness */ vec2d a(100.0, -100.0); vec2d b(200.0, -200.0); vec2d c = a + b; assert(vequals(c, vec2d(300.0, -300.0))); vec2d d = a - b; assert(vequals(d, vec2d(-100.0, 100.0))); vec2d e = a * b; assert(vequals(e, vec2d(20000.0, 20000.0))); vec2d f = b / a; assert(vequals(f, vec2d(2.0, 2.0))); vec2d g = a.madd(20.0, b); assert(vequals(g, vec2d(2200.0, -2200.0))); vec2d h = a.madd(d, b); assert(vequals(h, vec2d(-9800.0, -10200.0))); /* simple performance test */ srand(time(NULL)); double total = 0.0; double rval[] = { rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0, rand()/10000.0 }; clock_t start = clock(); for (int i = 0; i < COUNT; i++) { vec2d la(rval[i%12], rval[i%12+2]); vec2d lb(rval[i%12+1], rval[i%12+3]); vec2d lc = la + lb; vec2d ld = lc - la; vec2d le = ld * lc; vec2d lf = le / la; vec2d lg = la.madd(rval[i%12], lf); vec2d lh = lg.madd(lg, la + lb - lc + ld - le + lf); total += lh.x() + lh.y(); } printf("vec2d time: %3.4g\n", (double)(clock()-start)/(double)CLOCKS_PER_SEC); /* return 'fail' if no time elapsed */ return (total > 0) ? 0 : 1; }
void Agent::tick() { // sanity checks to stop ticks on dead agents LifeAssert la(this); if (dying) return; if (sound) { // if the sound is no longer playing... if (sound->getState() != SS_PLAY) { // ...release our reference to it sound.reset(); } else { // otherwise, reposition audio updateAudio(sound); } } // don't tick paused agents if (paused) return; // CA updates if (emitca_index != -1 && emitca_amount != 0.0f) { assert(0 <= emitca_index && emitca_index <= 19); shared_ptr<Room> r = world.map.roomAt(x, y); if (r) { r->catemp[emitca_index] += emitca_amount; /*if (r->catemp[emitca_index] <= 0.0f) r->catemp[emitca_index] = 0.0f; else if (r->catemp[emitca_index] >= 1.0f) r->catemp[emitca_index] = 1.0f;*/ } } // TODO: this might be in the wrong place - note that parts are ticked *before* Agent::tick is called if (rotatable() && spritesperrotation != 0 && numberrotations > 1) { SpritePart *p = dynamic_cast<SpritePart *>(part(0)); if (p) { // change base according to our SPIN and the ROTN settings unsigned int rotation = 0; rotation = (spin - (0.5f / numberrotations)) * numberrotations; // TODO: verify correctness p->setBase(spritesperrotation * rotation); } } // tick the physics engine physicsTick(); if (dying) return; // in case we were autokilled // update the timer if needed, and then queue a timer event if necessary if (timerrate) { tickssincelasttimer++; if (tickssincelasttimer == timerrate) { queueScript(9); // TODO: include this? tickssincelasttimer = 0; } assert(timerrate > tickssincelasttimer); } // tick the agent VM if (vm) vmTick(); // some silly hack to handle delayed voices tickVoices(); }
int main( int argc , char * argv[] ) { std::cout << "算术" << std::endl; int a = 10 , b = 20; int ret; std::plus<int>add; ret = add(a,b); std::cout << ret << std::endl; std::minus<int> min; ret = min(b,a); std::cout << ret << std::endl; std::multiplies<int> mp; ret = mp(a,b); std::cout << ret << std::endl; std::divides<int> divi; ret = divi(a,b); std::cout << ret << std::endl; std::modulus<int> mod; ret = mod(a,b); std::cout << ret << std::endl; std::negate<int> neg; ret = neg(a); std::cout << ret << std::endl; std::cout << "关系" <<std::endl; int a2 = 10 , b2 = 20; int ret2; std::equal_to<int> et; ret2 = et(a,b); std::cout << ret2 <<std::endl; std::not_equal_to<int> net; ret2 = net(a,b); std::cout << ret2 << std::endl; std::greater<int>gt; ret2 = gt(b,a); std::cout << ret2 << std::endl; std::greater_equal<int> gte; ret2 = gte(a,b); std::cout << ret2 <<std::endl; std::less<int> ls; ret2 = ls(a,b); std::cout << ret2 << std::endl; std::less_equal<int> lel; ret2 = lel(a,b); std::cout << ret2 << std::endl; std::cout << "逻辑" << std::endl; int ret3; std::logical_and<int> la; ret3 = la(a,b); std::cout << ret3 <<std::endl; std::logical_or<int> lo; ret3 = lo(a,b); std::cout << ret3 << std::endl; std::logical_not<int>ln; ret3 = ln(b); std::cout << ret3 <<std::endl; return EXIT_SUCCESS; }
int Hull::AddContactsHullHull(Separation& sep, const Point3* pVertsA, const Point3* pVertsB, const Transform& trA, const Transform& trB,const Hull& hullA,const Hull& hullB, HullContactCollector* hullContactCollector) { const int maxContacts = hullContactCollector->GetMaxNumContacts(); Vector3 normalWorld = sep.m_axis; // edge->edge contact is always a single point if (sep.m_separator == Separation::kFeatureBoth) { const Hull::Edge& edgeA = hullA.GetEdge(sep.m_featureA); const Hull::Edge& edgeB = hullB.GetEdge(sep.m_featureB); float ta, tb; Line la(pVertsA[edgeA.m_verts[0]], pVertsA[edgeA.m_verts[1]]); Line lb(pVertsB[edgeB.m_verts[0]], pVertsB[edgeB.m_verts[1]]); Intersect(la, lb, ta, tb); #ifdef VALIDATE_CONTACT_POINTS AssertPointInsideHull(contact.m_points[0].m_pos, trA, hullA); AssertPointInsideHull(contact.m_points[0].m_pos, trB, hullB); #endif Point3 posWorld = Lerp(la.m_start, la.m_end, ta); float depth = -sep.m_dist; Vector3 tangent = Normalize(pVertsA[edgeA.m_verts[1]] - pVertsA[edgeA.m_verts[0]]); sep.m_contact = hullContactCollector->BatchAddContactGroup(sep,1,normalWorld,tangent,&posWorld,&depth); } // face->face contact is polygon else { short faceA = sep.m_featureA; short faceB = sep.m_featureB; Vector3 tangent; // find face of hull A that is most opposite contact axis // TODO: avoid having to transform planes here if (sep.m_separator == Separation::kFeatureB) { const Hull::Edge& edgeB = hullB.GetEdge(hullB.GetFaceFirstEdge(faceB)); tangent = Normalize(pVertsB[edgeB.m_verts[1]] - pVertsB[edgeB.m_verts[0]]); Scalar dmin = Scalar::Consts::MaxValue; for (short face = 0; face < hullA.m_numFaces; face++) { Vector3 normal = hullA.GetPlane(face).GetNormal() * trA; Scalar d = Dot(normal, sep.m_axis); if (d < dmin) { dmin = d; faceA = face; } } } else { const Hull::Edge& edgeA = hullA.GetEdge(hullA.GetFaceFirstEdge(faceA)); tangent = Normalize(pVertsA[edgeA.m_verts[1]] - pVertsA[edgeA.m_verts[0]]); Scalar dmin = Scalar::Consts::MaxValue; for (short face = 0; face < hullB.m_numFaces; face++) { Vector3 normal = hullB.GetPlane(face).GetNormal() * trB; Scalar d = Dot(normal, -sep.m_axis); if (d < dmin) { dmin = d; faceB = face; } } } Point3 workspace[2][Hull::kMaxVerts]; // setup initial clip face (minimizing face from hull B) int numContacts = 0; for (short edge = hullB.GetFaceFirstEdge(faceB); edge != -1; edge = hullB.GetFaceNextEdge(faceB, edge)) workspace[0][numContacts++] = pVertsB[ hullB.GetEdgeVertex0(faceB, edge) ]; // clip polygon to back of planes of all faces of hull A that are adjacent to witness face Point3* pVtxIn = workspace[0]; Point3* pVtxOut = workspace[1]; #if 0 for (short edge = hullA.GetFaceFirstEdge(faceA); edge != -1; edge = hullA.GetFaceNextEdge(faceA, edge)) { Plane planeA = hullA.GetPlane( hullA.GetEdgeOtherFace(edge, faceA) ) * trA; numContacts = ClipFace(numContacts, &pVtxIn, &pVtxOut, planeA); } #else for (short f = 0; f < hullA.GetNumFaces(); f++) { Plane planeA = hullA.GetPlane(f) * trA; numContacts = ClipFace(numContacts, &pVtxIn, &pVtxOut, planeA); } #endif // only keep points that are behind the witness face Plane planeA = hullA.GetPlane(faceA) * trA; float depths[Hull::kMaxVerts]; int numPoints = 0; for (int i = 0; i < numContacts; i++) { Scalar d = Dot(planeA, pVtxIn[i]); if (IsNegative(d)) { depths[numPoints] = (float)-d; pVtxIn[numPoints] = pVtxIn[i]; #ifdef VALIDATE_CONTACT_POINTS AssertPointInsideHull(pVtxIn[numPoints], trA, hullA); AssertPointInsideHull(pVtxIn[numPoints], trB, hullB); #endif numPoints++; } } //we can also use a persistentManifold/reducer class // keep maxContacts points at most if (numPoints > 0) { if (numPoints > maxContacts) { int step = (numPoints << 8) / maxContacts; numPoints = maxContacts; for (int i = 0; i < numPoints; i++) { int nth = (step * i) >> 8; depths[i] = depths[nth]; pVtxIn[i] = pVtxIn[nth]; #ifdef VALIDATE_CONTACT_POINTS AssertPointInsideHull(contact.m_points[i].m_pos, trA, hullA); AssertPointInsideHull(contact.m_points[i].m_pos, trB, hullB); #endif } } sep.m_contact = hullContactCollector->BatchAddContactGroup(sep,numPoints,normalWorld,tangent,pVtxIn,depths); } return numPoints; }