static void e3(void) { { if (scan_test_set(NULL, &rdp_e3_0_first, NULL)) { e4(); } else if (scan_test(NULL, RDP_T_43 /* + */, NULL)) { scan_test(NULL, RDP_T_43 /* + */, &e3_stop); scan_(); e3(); } else if (scan_test(NULL, RDP_T_45 /* - */, NULL)) { scan_test(NULL, RDP_T_45 /* - */, &e3_stop); scan_(); e3(); } else scan_test_set(NULL, &e3_first, &e3_stop) ; scan_test_set(NULL, &e3_stop, &e3_stop); } }
static void e3(rdp_tree_node_data* rdp_tree) { { if (scan_test_set(NULL, &rdp_e3_0_first, NULL)) { if(rdp_tree_update) {rdp_tree->id = "e4"; rdp_tree->token = 0;} e4(rdp_tree); } else if (scan_test(NULL, RDP_T_43 /* + */, NULL)) { scan_test(NULL, RDP_T_43 /* + */, &e3_stop); scan_(); e3(rdp_add_child("e3", rdp_tree)); } else if (scan_test(NULL, RDP_T_45 /* - */, NULL)) { if (rdp_tree_update) memcpy(rdp_tree, text_scan_data, sizeof(scan_data)); scan_test(NULL, RDP_T_45 /* - */, &e3_stop); scan_(); e3(rdp_add_child("e3", rdp_tree)); } else scan_test_set(NULL, &e3_first, &e3_stop) ; scan_test_set(NULL, &e3_stop, &e3_stop); } }
static void e2(void) { { e3(); if (scan_test_set(NULL, &rdp_e2_2_first, NULL)) { /* Start of rdp_e2_2 */ while (1) { { if (scan_test(NULL, RDP_T_42 /* * */, NULL)) { scan_test(NULL, RDP_T_42 /* * */, &e2_stop); scan_(); e3(); } else if (scan_test(NULL, RDP_T_47 /* / */, NULL)) { scan_test(NULL, RDP_T_47 /* / */, &e2_stop); scan_(); e3(); } else scan_test_set(NULL, &rdp_e2_2_first, &e2_stop) ; } if (!scan_test_set(NULL, &rdp_e2_2_first, NULL)) break; } } /* end of rdp_e2_2 */ scan_test_set(NULL, &e2_stop, &e2_stop); } }
static integer e3(void) { integer result; { if (scan_test(NULL, RDP_T_43 /* + */, NULL)) { scan_test(NULL, RDP_T_43 /* + */, &e3_stop); scan_(); result = e3(); } else if (scan_test(NULL, RDP_T_45 /* - */, NULL)) { scan_test(NULL, RDP_T_45 /* - */, &e3_stop); scan_(); result = e3(); result = -result; } else if (scan_test_set(NULL, &rdp_e3_2_first, NULL)) { result = e4(); } else scan_test_set(NULL, &e3_first, &e3_stop) ; scan_test_set(NULL, &e3_stop, &e3_stop); } return result; }
static int e2(void) { if (eq(nxtarg(0), "!")) return(!e3()); ap--; return(e3()); }
static bool e2(void) { if (equal(nxtarg(RETERR), "!")) return !e3(); ap--; return e3(); }
/* <e3> ( != | == | < | > ) <e4> */ static Expression *e4(void) { Expression *left = e3(); enum EKind kind; if (isEqEq()) { kind = eEQ; } else if (isLt()) { kind = eLT; } else if (isGt()) { kind = eGT; } else if (isNe()) { kind = eNE; } else { return left; } consume(); Expression *e = NEW(Expression); e->kind = kind; e->left = left; e->right = e4(); return e; }
std::vector<Domain> AbstractDomainPropertyTest<Domain>::non_extremal_values() { Domain e1("a"); Domain e2({"a", "b", "c"}); Domain e3({"b", "c", "d"}); return {e1, e2, e3}; }
void Blocks::run () { long elementsX = width/size; long elementsY = height/size; int IDCounter = 0; for (int i = 0; i < elementsX-1; i++) { for (int j = 0; j < elementsY-1; j++) { //Points at the Edge Point p1(i*size, j*size, 0); Point p2((i+1)*size, j*size, 0); Point p3((i+1)*size, (j+1)*size, 0); Point p4(i*size, (j+1)*size, 0); std::vector<Point> edgePoints; edgePoints.push_back(p1); edgePoints.push_back(p2); edgePoints.push_back(p3); edgePoints.push_back(p4); //Create Edges Edge e1(0,1); Edge e2(1,2); Edge e3(2,3); Edge e4(3,0); std::vector<Edge> edges; edges.push_back(e1); edges.push_back(e2); edges.push_back(e3); edges.push_back(e4); //Cretae Face std::vector<long> f; f.push_back(0); f.push_back(1); f.push_back(2); f.push_back(3); Face face(f); std::vector<Face> faces; faces.push_back(face); Point centerPoint((i+0.5)*size, (j+0.5)*size, 0); std::vector<Point> centerPoints; centerPoints.push_back(centerPoint); std::stringstream name; name << "Block_" << IDCounter; block->setPoints(name.str(), edgePoints); block->setEdges(name.str(), edges); block->setFaces(name.str(), faces); name.clear(); name << "BlockCenterPoint_" << IDCounter; block->setPoints(name.str(), centerPoints); IDCounter++; } } }
void Foam::coordinateSystem::writeDict(Ostream& os, bool subDict) const { if (subDict) { os << indent << name_ << nl << indent << token::BEGIN_BLOCK << incrIndent << nl; } // only write type for derived types if (type() != typeName_()) { os.writeKeyword("type") << type() << token::END_STATEMENT << nl; } // The note entry is optional if (note_.size()) { os.writeKeyword("note") << note_ << token::END_STATEMENT << nl; } os.writeKeyword("origin") << origin_ << token::END_STATEMENT << nl; os.writeKeyword("e1") << e1() << token::END_STATEMENT << nl; os.writeKeyword("e3") << e3() << token::END_STATEMENT << nl; if (subDict) { os << decrIndent << indent << token::END_BLOCK << endl; } }
Py::Object removeSvgTags(const Py::Tuple& args) { const char* svgcode; if (!PyArg_ParseTuple(args.ptr(), "s",&svgcode)) throw Py::Exception(); std::string svg(svgcode); std::string empty = ""; std::string endline = "--endOfLine--"; std::string linebreak = "\\n"; // removing linebreaks for regex to work boost::regex e1 ("\\n"); svg = boost::regex_replace(svg, e1, endline); // removing starting xml definition boost::regex e2 ("<\\?xml.*?\\?>"); svg = boost::regex_replace(svg, e2, empty); // removing starting svg tag boost::regex e3 ("<svg.*?>"); svg = boost::regex_replace(svg, e3, empty); // removing sodipodi tags -- DANGEROUS, some sodipodi tags are single, better leave it //boost::regex e4 ("<sodipodi.*?>"); //svg = boost::regex_replace(svg, e4, empty); // removing metadata tags boost::regex e5 ("<metadata.*?</metadata>"); svg = boost::regex_replace(svg, e5, empty); // removing closing svg tags boost::regex e6 ("</svg>"); svg = boost::regex_replace(svg, e6, empty); // restoring linebreaks boost::regex e7 ("--endOfLine--"); svg = boost::regex_replace(svg, e7, linebreak); Py::String result(svg); return result; }
bool ElasticBeam::initElement (const std::vector<int>& MNPC, const FiniteElement& fe, const Vec3&, size_t, LocalIntegral& elmInt) { if (!this->initElement(MNPC,elmInt)) return false; Vec3 e1 = fe.XC[1] - fe.XC[0]; // Initial local X-axis const Vector& eV = elmInt.vec.front(); if (!eV.empty()) { // Fetch nodal displacements Vec3 U0(eV.ptr()); Vec3 U1(eV.ptr()+eV.size()-npv); e1 += U1 - U0; // Deformed local X-axis } // Calculate the co-rotated element coordinate system if (e1.normalize() <= 1.0e-8) { std::cerr <<" *** ElasticBeam::initElement: Zero beam length"<< std::endl; return false; } if (fe.Tn.size() < 2) { std::cerr <<" *** ElasticBeam::initElement: No end rotations"<< std::endl; return false; } Vec3 e2(fe.Tn[0][1]+fe.Tn[1][1]); // Sum of the nodal Y-axes Vec3 e3(fe.Tn[0][2]+fe.Tn[1][2]); // Sum of the nodal Z-axes if (e3*e1 < e2*e1) { e2.cross(e3,e1); // Local Y-axis = e3xe1 / |e3xe1| e2.normalize(); e3.cross(e1,e2); // Local Z-axis = e1xe2 } else { e3.cross(e1,e2); // Local Z-axis = e1xe2 / |e1xe2| e3.normalize(); e2.cross(e3,e1); // Local Y-axis = e3xe1 } Matrix& Tlg = this->getLocalAxes(elmInt); Tlg.fillColumn(1,e1.ptr()); Tlg.fillColumn(2,e2.ptr()); Tlg.fillColumn(3,e3.ptr()); #if INT_DEBUG > 1 std::cout <<"ElasticBeam: local-to-global transformation matrix:"<< Tlg <<"ElasticBeam: T1n\n"<< fe.Tn[0] <<"ElasticBeam: T2n\n"<< fe.Tn[1]; #endif return true; }
// ----------------------------------------------------------------------------- // // ----------------------------------------------------------------------------- void StatsGenODFWidget::extractStatsData(int index, StatsData* statsData, unsigned int phaseType) { VectorOfFloatArray arrays; if(phaseType == DREAM3D::PhaseType::PrimaryPhase) { PrimaryStatsData* pp = PrimaryStatsData::SafePointerDownCast(statsData); arrays = pp->getODF_Weights(); } if(phaseType == DREAM3D::PhaseType::PrecipitatePhase) { PrecipitateStatsData* pp = PrecipitateStatsData::SafePointerDownCast(statsData); arrays = pp->getODF_Weights(); } if(phaseType == DREAM3D::PhaseType::TransformationPhase) { TransformationStatsData* tp = TransformationStatsData::SafePointerDownCast(statsData); arrays = tp->getODF_Weights(); } if (arrays.size() > 0) { QVector<float> e1(static_cast<int>(arrays[0]->getNumberOfTuples())); ::memcpy( e1.data(), arrays[0]->getVoidPointer(0), sizeof(float)*e1.size() ); QVector<float> e2(static_cast<int>(arrays[1]->getNumberOfTuples())); ::memcpy( e2.data(), arrays[1]->getVoidPointer(0), sizeof(float)*e2.size() ); QVector<float> e3(static_cast<int>(arrays[2]->getNumberOfTuples())); ::memcpy( e3.data(), arrays[2]->getVoidPointer(0), sizeof(float)*e3.size() ); QVector<float> weights(static_cast<int>(arrays[3]->getNumberOfTuples())); ::memcpy( weights.data(), arrays[3]->getVoidPointer(0), sizeof(float)*weights.size() ); QVector<float> sigmas(static_cast<int>(arrays[4]->getNumberOfTuples())); ::memcpy( sigmas.data(), arrays[4]->getVoidPointer(0), sizeof(float)*sigmas.size() ); // Convert from Radians to Degrees for the Euler Angles for(int i = 0; i < e1.size(); ++i) { e1[i] = e1[i] * 180.0f / M_PI; e2[i] = e2[i] * 180.0f / M_PI; e3[i] = e3[i] * 180.0f / M_PI; } if(e1.size() > 0) { // Load the data into the table model m_ODFTableModel->setTableData(e1, e2, e3, weights, sigmas); } } // Write the MDF Data if we have that functionality enabled if (m_MDFWidget != NULL) { m_MDFWidget->extractStatsData(index, statsData, phaseType); } updatePlots(); }
void Mesh::FindAdjacencies(const aiMesh* paiMesh, vector<unsigned int>& Indices) { // Step 1 - find the two triangles that share every edge for (uint i = 0 ; i < paiMesh->mNumFaces ; i++) { const aiFace& face = paiMesh->mFaces[i]; Face Unique; // If a position vector is duplicated in the VB we fetch the // index of the first occurrence. for (uint j = 0 ; j < 3 ; j++) { uint Index = face.mIndices[j]; aiVector3D& v = paiMesh->mVertices[Index]; if (m_posMap.find(v) == m_posMap.end()) { m_posMap[v] = Index; } else { Index = m_posMap[v]; } Unique.Indices[j] = Index; } m_uniqueFaces.push_back(Unique); Edge e1(Unique.Indices[0], Unique.Indices[1]); Edge e2(Unique.Indices[1], Unique.Indices[2]); Edge e3(Unique.Indices[2], Unique.Indices[0]); m_indexMap[e1].AddNeigbor(i); m_indexMap[e2].AddNeigbor(i); m_indexMap[e3].AddNeigbor(i); } // Step 2 - build the index buffer with the adjacency info for (uint i = 0 ; i < paiMesh->mNumFaces ; i++) { const Face& face = m_uniqueFaces[i]; for (uint j = 0 ; j < 3 ; j++) { Edge e(face.Indices[j], face.Indices[(j + 1) % 3]); assert(m_indexMap.find(e) != m_indexMap.end()); Neighbors n = m_indexMap[e]; uint OtherTri = n.GetOther(i); assert(OtherTri != -1); const Face& OtherFace = m_uniqueFaces[OtherTri]; uint OppositeIndex = OtherFace.GetOppositeIndex(e); Indices.push_back(face.Indices[j]); Indices.push_back(OppositeIndex); } } }
/* **************************************************************************** * * all - */ TEST(OrionError, all) { StatusCode sc(SccBadRequest, "no details 2"); OrionError e0; OrionError e1(SccOk, "no details 3"); OrionError e3(sc); OrionError e4(SccOk, "Good Request"); std::string out; const char* outfile1 = "orion.orionError.all1.valid.xml"; const char* outfile2 = "orion.orionError.all1.valid.json"; const char* outfile5 = "orion.orionError.all3.valid.xml"; const char* outfile6 = "orion.orionError.all3.valid.json"; const char* outfile7 = "orion.orionError.all4.valid.xml"; const char* outfile8 = "orion.orionError.all4.valid.json"; EXPECT_EQ(SccNone, e0.code); EXPECT_EQ("", e0.reasonPhrase); EXPECT_EQ("", e0.details); EXPECT_EQ(SccOk, e1.code); EXPECT_EQ("OK", e1.reasonPhrase); EXPECT_EQ("no details 3", e1.details); EXPECT_EQ(sc.code, e3.code); EXPECT_EQ(sc.reasonPhrase, e3.reasonPhrase); EXPECT_EQ(sc.details, e3.details); EXPECT_EQ(SccOk, e4.code); EXPECT_EQ("OK", e4.reasonPhrase); EXPECT_EQ("Good Request", e4.details); out = e1.render(XML, ""); EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile1)) << "Error getting test data from '" << outfile1 << "'"; EXPECT_STREQ(expectedBuf, out.c_str()); out = e3.render(XML, ""); EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile5)) << "Error getting test data from '" << outfile5 << "'"; EXPECT_STREQ(expectedBuf, out.c_str()); out = e4.render(XML, ""); EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile7)) << "Error getting test data from '" << outfile7 << "'"; EXPECT_STREQ(expectedBuf, out.c_str()); out = e1.render(JSON, ""); EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile2)) << "Error getting test data from '" << outfile2 << "'"; EXPECT_STREQ(expectedBuf, out.c_str()); out = e3.render(JSON, ""); EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile6)) << "Error getting test data from '" << outfile6 << "'"; EXPECT_STREQ(expectedBuf, out.c_str()); out = e4.render(JSON, ""); EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile8)) << "Error getting test data from '" << outfile8 << "'"; EXPECT_STREQ(expectedBuf, out.c_str()); }
int main () { i1(); i3(); i4(); i5(); e1(); e3(); e4(); e5(); }
void init_from_periods(int n, cplx tau1, cplx tau2) { process_periods(tau1, tau2); cplx q(std::exp(tau_*cplx(0, M_PI))); cplx q2(q*q); /* e1 */ cplx e1(0.0); for (cplx q2k(q2); ; q2k *= q2) { cplx t1(1.0 + q2k); cplx t2(1.0 - q2k); cplx term(q2k*(1.0/(t1*t1) + 1.0/(t2*t2))); if (std::abs(term) <= 1e-10) break; e1 += term; } e1 = (e1*8.0 + 2.0/3)*M_PI*M_PI; /* e2 */ cplx e2(0.0); cplx qk; double s = -1; for (qk = q, s = -1; ; qk *= q, s = -s) { cplx t1(1.0 - qk); cplx term(s*qk/(t1*t1)); if (std::abs(term) <= 1e-10) break; e2 += term; } e2 = (e2*8.0 - 1.0/3)*M_PI*M_PI; /* e3 */ cplx e3(0.0); for (qk = q, s = -1; ; qk *= q, s = -s) { cplx t1(1.0 - s*qk); cplx term(qk/(t1*t1)); if (std::abs(term) <= 1e-10) break; e3 += term; } e3 = (e3*8.0 - 1.0/3)*M_PI*M_PI; init(n, e1, e2, e3); }
/* **************************************************************************** * * all - */ TEST(OrionError, all) { StatusCode sc(SccBadRequest, "no details 2"); OrionError e0; OrionError e1(SccOk, "no details 3"); OrionError e3(sc); OrionError e4(SccOk, "Good Request"); std::string out; const char* outfile1 = "orion.orionError.all1.valid.json"; const char* outfile2 = "orion.orionError.all3.valid.json"; const char* outfile3 = "orion.orionError.all4.valid.json"; ConnectionInfo ci; ci.outMimeType = JSON; EXPECT_EQ(SccNone, e0.code); EXPECT_EQ("", e0.reasonPhrase); EXPECT_EQ("", e0.details); EXPECT_EQ(SccOk, e1.code); EXPECT_EQ("OK", e1.reasonPhrase); EXPECT_EQ("no details 3", e1.details); EXPECT_EQ(sc.code, e3.code); EXPECT_EQ(sc.reasonPhrase, e3.reasonPhrase); EXPECT_EQ(sc.details, e3.details); EXPECT_EQ(SccOk, e4.code); EXPECT_EQ("OK", e4.reasonPhrase); EXPECT_EQ("Good Request", e4.details); ci.outMimeType = JSON; out = e1.toJsonV1(); EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile1)) << "Error getting test data from '" << outfile1 << "'"; EXPECT_STREQ(expectedBuf, out.c_str()); out = e3.toJsonV1(); EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile2)) << "Error getting test data from '" << outfile2 << "'"; EXPECT_STREQ(expectedBuf, out.c_str()); out = e4.toJsonV1(); EXPECT_EQ("OK", testDataFromFile(expectedBuf, sizeof(expectedBuf), outfile3)) << "Error getting test data from '" << outfile3 << "'"; EXPECT_STREQ(expectedBuf, out.c_str()); }
TEST(generateExpression, binary_op) { static const bool user_facing = true; std::stringstream msgs; stan::lang::expression e1 = stan::lang::int_literal(5); stan::lang::double_literal b(-2.0); b.string_ = "-2.0"; stan::lang::expression e2(b); stan::lang::expression e3(stan::lang::binary_op(e1,"+",e2)); generate_expression(e3, user_facing, msgs); EXPECT_EQ(msgs.str(), "(5 + -2.0)"); }
int main() { H e1, e2(6), e3(3, 8); e1.display(); e2.display(); e3.display(); H e4 = e3; e4.display(); return 0; }
static integer e2(void) { integer result; integer right; { result = e3(); if (scan_test_set(NULL, &rdp_e2_2_first, NULL)) { /* Start of rdp_e2_2 */ while (1) { { if (scan_test(NULL, RDP_T_42 /* * */, NULL)) { scan_test(NULL, RDP_T_42 /* * */, &e2_stop); scan_(); right = e3(); result *= right; } else if (scan_test(NULL, RDP_T_47 /* / */, NULL)) { scan_test(NULL, RDP_T_47 /* / */, &e2_stop); scan_(); right = e3(); if (result == 0) \ text_message(TEXT_FATAL_ECHO, "Divide by zero attempted\n"); \ else result /= right; \ } else scan_test_set(NULL, &rdp_e2_2_first, &e2_stop) ; } if (!scan_test_set(NULL, &rdp_e2_2_first, NULL)) break; } } /* end of rdp_e2_2 */ scan_test_set(NULL, &e2_stop, &e2_stop); } return result; }
int main() { graph_node<std::string> n1("A"), n2("B"), n3("C"); graph_edge<std::string> e1(n1, n2, 3.0), e2(n1, n3, 1.47), e3(n2, n1, 3.0); std::cout << std::hash<graph_edge<std::string>>()(e1) << '\n'; std::cout << std::hash<graph_edge<std::string>>()(e3) << '\n'; std::cout << std::hash<graph_edge<std::string>>()(e2) << '\n'; if (e1 == e3) { std::cout << "e1 == e3\n"; } }
static void e2(rdp_tree_node_data* rdp_tree) { { if(rdp_tree_update) {rdp_tree->id = "e3"; rdp_tree->token = 0;} e3(rdp_tree); if (scan_test_set(NULL, &rdp_e2_2_first, NULL)) { /* Start of rdp_e2_2 */ while (1) { { if (scan_test(NULL, RDP_T_42 /* * */, NULL)) { if (rdp_tree_update) rdp_add_parent(NULL, rdp_tree); scan_test(NULL, RDP_T_42 /* * */, &e2_stop); scan_(); e3(rdp_add_child("e3", rdp_tree)); } else if (scan_test(NULL, RDP_T_47 /* / */, NULL)) { if (rdp_tree_update) rdp_add_parent(NULL, rdp_tree); scan_test(NULL, RDP_T_47 /* / */, &e2_stop); scan_(); e3(rdp_add_child("e3", rdp_tree)); } else scan_test_set(NULL, &rdp_e2_2_first, &e2_stop) ; } if (!scan_test_set(NULL, &rdp_e2_2_first, NULL)) break; } } /* end of rdp_e2_2 */ else { /* default action processing for rdp_e2_2*/ if (rdp_tree_update) {rdp_tree_node_data *temp = rdp_add_child(NULL, rdp_tree); temp->id = NULL; temp->token = SCAN_P_ID;} } scan_test_set(NULL, &e2_stop, &e2_stop); } }
void Foam::myHeatFluxFvPatchVectorField::updateCoeffs() { if (this->updated()) { return; } // VARIABLEN/FELDER scalarField sn(patch().size()), st(patch().size()), sct(patch().size()), gt(patch().size()); vectorField t(patch().size()), n(patch().size()); vectorField& s = *this; // Berechnung von Richtungen n = this->patch().nf(); // for(int i=0; i<g0.size(); i++){ // if(mag(g0[i]) == 0) // t[i] = vector(0,0,0); // else // t[i] = g0[i]/mag(g0[i]); // } for(int i=0; i<n.size(); i++){ const vector vec = n[i]; t[i] = vector(vec.y(),-vec.x(),0); } // Betrag in normalen Richtung n const volScalarField& internalTheta = db().lookupObject<volScalarField>("Theta"); const label patchID = patch().boundaryMesh().findPatchID(patch().name()); scalarField boundaryTheta = internalTheta.boundaryField()[patchID]; boundaryTheta = OFinterpolate(patch(), db(), boundaryTheta); sn = alpha * (boundaryTheta - Theta_wall); // Betrag in tangentiale Richtung t (Approximation durch einseitige FD) vector e1(1,0,0); vector e2(0,1,0); vector e3(0,0,1); vectorField sc = this->patchInternalField(); scalarField d = 1.0/this->patch().deltaCoeffs(); gt = ( (g0 ^ n) & e3 ); sct = ( (sc ^ n) & e3 ); st = ( sct - d*gt ) / ( 1 + d*gamma ); // gesamter Wärmestrom s s = sn*n + st*t; fixedValueFvPatchVectorField::updateCoeffs(); }
void DsrSendBuffTest::DoRun () { q.SetMaxQueueLen (32); NS_TEST_EXPECT_MSG_EQ (q.GetMaxQueueLen (), 32, "trivial"); q.SetSendBufferTimeout (Seconds (10)); NS_TEST_EXPECT_MSG_EQ (q.GetSendBufferTimeout (), Seconds (10), "trivial"); Ptr<const Packet> packet = Create<Packet> (); Ipv4Address dst1 = Ipv4Address ("0.0.0.1"); dsr::SendBuffEntry e1 (packet, dst1, Seconds (1)); q.Enqueue (e1); q.Enqueue (e1); q.Enqueue (e1); NS_TEST_EXPECT_MSG_EQ (q.Find (Ipv4Address ("0.0.0.1")), true, "trivial"); NS_TEST_EXPECT_MSG_EQ (q.Find (Ipv4Address ("1.1.1.1")), false, "trivial"); NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 1, "trivial"); q.DropPacketWithDst (Ipv4Address ("0.0.0.1")); NS_TEST_EXPECT_MSG_EQ (q.Find (Ipv4Address ("0.0.0.1")), false, "trivial"); NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 0, "trivial"); Ipv4Address dst2 = Ipv4Address ("0.0.0.2"); dsr::SendBuffEntry e2 (packet, dst2, Seconds (1)); q.Enqueue (e1); q.Enqueue (e2); Ptr<Packet> packet2 = Create<Packet> (); dsr::SendBuffEntry e3 (packet2, dst2, Seconds (1)); NS_TEST_EXPECT_MSG_EQ (q.Dequeue (Ipv4Address ("0.0.0.3"), e3), false, "trivial"); NS_TEST_EXPECT_MSG_EQ (q.Dequeue (Ipv4Address ("0.0.0.2"), e3), true, "trivial"); NS_TEST_EXPECT_MSG_EQ (q.Find (Ipv4Address ("0.0.0.2")), false, "trivial"); q.Enqueue (e2); q.Enqueue (e3); NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 2, "trivial"); Ptr<Packet> packet4 = Create<Packet> (); Ipv4Address dst4 = Ipv4Address ("0.0.0.4"); dsr::SendBuffEntry e4 (packet4, dst4, Seconds (20)); q.Enqueue (e4); NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 3, "trivial"); q.DropPacketWithDst (Ipv4Address ("0.0.0.4")); NS_TEST_EXPECT_MSG_EQ (q.GetSize (), 2, "trivial"); CheckSizeLimit (); Simulator::Schedule (q.GetSendBufferTimeout () + Seconds (1), &DsrSendBuffTest::CheckTimeout, this); Simulator::Run (); Simulator::Destroy (); }
TEST(generateExpression, conditional_op) { static const bool user_facing = true; std::stringstream msgs; stan::lang::expression e1 = stan::lang::int_literal(5); stan::lang::double_literal a(2.0); a.string_ = "2.0"; stan::lang::expression e2(a); stan::lang::double_literal b(-2.0); b.string_ = "-2.0"; stan::lang::expression e3(b); stan::lang::expression e4(stan::lang::conditional_op(e1,e2,e3)); generate_expression(e4, user_facing, msgs); EXPECT_EQ(msgs.str(), "(5 ? 2.0 : -2.0 )"); }
int test_main(int,char *[]) { bu::quantity<mixed_length> a1(2.0 * mixed_length()); bu::quantity<si_area> a2(a1); BOOST_CHECK((std::abs(a2.value() - .02) < .0001)); bu::quantity<mixed_length> a3(a2); BOOST_CHECK((std::abs(a3.value() - 2.0) < .0001)); bu::quantity<mixed_energy_1> e1(2.0 * mixed_energy_1()); bu::quantity<mixed_energy_2> e2(e1); BOOST_CHECK((std::abs(e2.value() - 20.0) < .0001)); bu::quantity<bu::si::energy> e3(e1); BOOST_CHECK((std::abs(e3.value() - .0002) < .0001)); bu::quantity<mixed_energy_2> e4(e3); BOOST_CHECK((std::abs(e4.value() - 20.0) < .0001)); bu::quantity<bu::cgs::force> F0 = 20 * bu::cgs::dyne; BOOST_CHECK((std::abs(F0.value() - 20.0) < .0001)); bu::quantity<bu::si::force> F3(F0); BOOST_CHECK((std::abs(F3.value() - 2.0e-4) < .000000001)); bu::quantity<bu::si::force> F5(20 * bu::cgs::dyne); BOOST_CHECK((std::abs(F5.value() - 2.0e-4) < .000000001)); bu::quantity<bu::si::dimensionless> dimensionless_test1(1.0*bu::cgs::dyne/bu::si::newton); BOOST_CHECK(dimensionless_test1 == 1e-5); typedef bu::multiply_typeof_helper<bu::si::length, bu::cgs::length>::type m_cm; typedef bu::divide_typeof_helper<m_cm, m_cm>::type heterogeneous_dimensionless; bu::quantity<heterogeneous_dimensionless> dimensionless_test2(1.0*bu::cgs::dyne/bu::si::newton); BOOST_CHECK(dimensionless_test2.value() == 1e-5); bu::quantity<bu::divide_typeof_helper<bu::cgs::force, bu::si::force>::type> dimensionless_test3(dimensionless_test2); BOOST_UNITS_CHECK_CLOSE(dimensionless_test3.value(), 1.0); //m/cm -> g/kg bu::quantity<bu::divide_typeof_helper<bu::si::length, bu::cgs::length>::type> dimensionless_test4(2.0 * bu::si::meters / bu::cgs::centimeters); bu::quantity<bu::divide_typeof_helper<bu::cgs::mass, bu::si::mass>::type> dimensionless_test5(dimensionless_test4); BOOST_UNITS_CHECK_CLOSE(dimensionless_test5.value(), 2e5); return(0); }
int f4() { try { throw 42; } catch (long & e) { e2(e); } catch (...) { e3(); } return 2; }
const FloatMatrix * TrPlaneStrRot3d :: computeGtoLRotationMatrix() // Returns the rotation matrix of the receiver of the size [3,3] // coords(local) = T * coords(global) // // local coordinate (described by vector triplet e1',e2',e3') is defined as follows: // // e1' : [N2-N1] Ni - means i - th node // help : [N3-N1] // e3' : e1' x help // e2' : e3' x e1' { if ( GtoLRotationMatrix == NULL ) { int i; FloatArray e1(3), e2(3), e3(3), help(3); // compute e1' = [N2-N1] and help = [N3-N1] for ( i = 1; i <= 3; i++ ) { e1.at(i) = ( this->giveNode(2)->giveCoordinate(i) - this->giveNode(1)->giveCoordinate(i) ); help.at(i) = ( this->giveNode(3)->giveCoordinate(i) - this->giveNode(1)->giveCoordinate(i) ); } // let us normalize e1' e1.normalize(); // compute e3' : vector product of e1' x help e3.beVectorProductOf(e1,help); // let us normalize e3.normalize(); // now from e3' x e1' compute e2' e2.beVectorProductOf(e3,e1); // GtoLRotationMatrix = new FloatMatrix(3, 3); for ( i = 1; i <= 3; i++ ) { GtoLRotationMatrix->at(1, i) = e1.at(i); GtoLRotationMatrix->at(2, i) = e2.at(i); GtoLRotationMatrix->at(3, i) = e3.at(i); } } return GtoLRotationMatrix; }
TEST(SerializationMacros, TestClassesCopyCtorAssignWorks) { ComplexEntry e1, e2; e1.setRandom(); e2.setRandom(); ASSERT_TRUE(e1.isBinaryEqual(e1)); ASSERT_FALSE(e1.isBinaryEqual(e2)); ASSERT_FALSE(e2.isBinaryEqual(e1)); e2 = e1; ASSERT_TRUE(e2.isBinaryEqual(e1)); ASSERT_TRUE(e1.isBinaryEqual(e2)); ComplexEntry e3(e1); ASSERT_TRUE(e3.isBinaryEqual(e1)); ASSERT_TRUE(e1.isBinaryEqual(e3)); }